diff options
author | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2019-10-05 15:09:28 +0200 |
commit | c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 (patch) | |
tree | cac3ce030d77b4cbe7c7dc62ed58cfe6d24f73e1 /src/transport/tcp_service_legacy.c | |
parent | fbb71d527c7d6babf269a8fefce1db291b9f7068 (diff) | |
download | gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.tar.gz gnunet-c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207.zip |
global reindent, now with uncrustify hook enabled
Diffstat (limited to 'src/transport/tcp_service_legacy.c')
-rw-r--r-- | src/transport/tcp_service_legacy.c | 1639 |
1 files changed, 820 insertions, 819 deletions
diff --git a/src/transport/tcp_service_legacy.c b/src/transport/tcp_service_legacy.c index 129511fec..54020b642 100644 --- a/src/transport/tcp_service_legacy.c +++ b/src/transport/tcp_service_legacy.c | |||
@@ -45,8 +45,8 @@ | |||
45 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is | 45 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is |
46 | */ | 46 | */ |
47 | static int | 47 | static int |
48 | check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | 48 | check_ipv4_listed (const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, |
49 | const struct in_addr *add) | 49 | const struct in_addr *add) |
50 | { | 50 | { |
51 | unsigned int i; | 51 | unsigned int i; |
52 | 52 | ||
@@ -54,12 +54,12 @@ check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | |||
54 | return GNUNET_NO; | 54 | return GNUNET_NO; |
55 | i = 0; | 55 | i = 0; |
56 | while ((list[i].network.s_addr != 0) || (list[i].netmask.s_addr != 0)) | 56 | while ((list[i].network.s_addr != 0) || (list[i].netmask.s_addr != 0)) |
57 | { | 57 | { |
58 | if ((add->s_addr & list[i].netmask.s_addr) == | 58 | if ((add->s_addr & list[i].netmask.s_addr) == |
59 | (list[i].network.s_addr & list[i].netmask.s_addr)) | 59 | (list[i].network.s_addr & list[i].netmask.s_addr)) |
60 | return GNUNET_YES; | 60 | return GNUNET_YES; |
61 | i++; | 61 | i++; |
62 | } | 62 | } |
63 | return GNUNET_NO; | 63 | return GNUNET_NO; |
64 | } | 64 | } |
65 | 65 | ||
@@ -72,8 +72,8 @@ check_ipv4_listed(const struct GNUNET_STRINGS_IPv4NetworkPolicy *list, | |||
72 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is | 72 | * @return #GNUNET_NO if the IP is not in the list, #GNUNET_YES if it it is |
73 | */ | 73 | */ |
74 | static int | 74 | static int |
75 | check_ipv6_listed(const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, | 75 | check_ipv6_listed (const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, |
76 | const struct in6_addr *ip) | 76 | const struct in6_addr *ip) |
77 | { | 77 | { |
78 | unsigned int i; | 78 | unsigned int i; |
79 | unsigned int j; | 79 | unsigned int j; |
@@ -81,20 +81,20 @@ check_ipv6_listed(const struct GNUNET_STRINGS_IPv6NetworkPolicy *list, | |||
81 | 81 | ||
82 | if (NULL == list) | 82 | if (NULL == list) |
83 | return GNUNET_NO; | 83 | return GNUNET_NO; |
84 | memset(&zero, 0, sizeof(struct in6_addr)); | 84 | memset (&zero, 0, sizeof(struct in6_addr)); |
85 | i = 0; | 85 | i = 0; |
86 | NEXT: | 86 | NEXT: |
87 | while (0 != memcmp(&zero, &list[i].network, sizeof(struct in6_addr))) | 87 | while (0 != memcmp (&zero, &list[i].network, sizeof(struct in6_addr))) |
88 | { | 88 | { |
89 | for (j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++) | 89 | for (j = 0; j < sizeof(struct in6_addr) / sizeof(int); j++) |
90 | if (((((int *)ip)[j] & ((int *)&list[i].netmask)[j])) != | 90 | if (((((int *) ip)[j] & ((int *) &list[i].netmask)[j])) != |
91 | (((int *)&list[i].network)[j] & ((int *)&list[i].netmask)[j])) | 91 | (((int *) &list[i].network)[j] & ((int *) &list[i].netmask)[j])) |
92 | { | 92 | { |
93 | i++; | 93 | i++; |
94 | goto NEXT; | 94 | goto NEXT; |
95 | } | 95 | } |
96 | return GNUNET_YES; | 96 | return GNUNET_YES; |
97 | } | 97 | } |
98 | return GNUNET_NO; | 98 | return GNUNET_NO; |
99 | } | 99 | } |
100 | 100 | ||
@@ -105,7 +105,8 @@ NEXT: | |||
105 | /** | 105 | /** |
106 | * Context for "service_task". | 106 | * Context for "service_task". |
107 | */ | 107 | */ |
108 | struct LEGACY_SERVICE_Context { | 108 | struct LEGACY_SERVICE_Context |
109 | { | ||
109 | /** | 110 | /** |
110 | * Our configuration. | 111 | * Our configuration. |
111 | */ | 112 | */ |
@@ -237,20 +238,20 @@ struct LEGACY_SERVICE_Context { | |||
237 | * @return number of bytes written to 'buf' | 238 | * @return number of bytes written to 'buf' |
238 | */ | 239 | */ |
239 | static size_t | 240 | static size_t |
240 | write_test(void *cls, size_t size, void *buf) | 241 | write_test (void *cls, size_t size, void *buf) |
241 | { | 242 | { |
242 | struct GNUNET_SERVER_Client *client = cls; | 243 | struct GNUNET_SERVER_Client *client = cls; |
243 | struct GNUNET_MessageHeader *msg; | 244 | struct GNUNET_MessageHeader *msg; |
244 | 245 | ||
245 | if (size < sizeof(struct GNUNET_MessageHeader)) | 246 | if (size < sizeof(struct GNUNET_MessageHeader)) |
246 | { | 247 | { |
247 | GNUNET_SERVER_receive_done(client, GNUNET_SYSERR); | 248 | GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); |
248 | return 0; /* client disconnected */ | 249 | return 0; /* client disconnected */ |
249 | } | 250 | } |
250 | msg = (struct GNUNET_MessageHeader *)buf; | 251 | msg = (struct GNUNET_MessageHeader *) buf; |
251 | msg->type = htons(GNUNET_MESSAGE_TYPE_TEST); | 252 | msg->type = htons (GNUNET_MESSAGE_TYPE_TEST); |
252 | msg->size = htons(sizeof(struct GNUNET_MessageHeader)); | 253 | msg->size = htons (sizeof(struct GNUNET_MessageHeader)); |
253 | GNUNET_SERVER_receive_done(client, GNUNET_OK); | 254 | GNUNET_SERVER_receive_done (client, GNUNET_OK); |
254 | return sizeof(struct GNUNET_MessageHeader); | 255 | return sizeof(struct GNUNET_MessageHeader); |
255 | } | 256 | } |
256 | 257 | ||
@@ -263,18 +264,18 @@ write_test(void *cls, size_t size, void *buf) | |||
263 | * @param message the actual message | 264 | * @param message the actual message |
264 | */ | 265 | */ |
265 | static void | 266 | static void |
266 | handle_test(void *cls, | 267 | handle_test (void *cls, |
267 | struct GNUNET_SERVER_Client *client, | 268 | struct GNUNET_SERVER_Client *client, |
268 | const struct GNUNET_MessageHeader *message) | 269 | const struct GNUNET_MessageHeader *message) |
269 | { | 270 | { |
270 | /* simply bounce message back to acknowledge */ | 271 | /* simply bounce message back to acknowledge */ |
271 | if (NULL == | 272 | if (NULL == |
272 | GNUNET_SERVER_notify_transmit_ready(client, | 273 | GNUNET_SERVER_notify_transmit_ready (client, |
273 | sizeof(struct GNUNET_MessageHeader), | 274 | sizeof(struct GNUNET_MessageHeader), |
274 | GNUNET_TIME_UNIT_FOREVER_REL, | 275 | GNUNET_TIME_UNIT_FOREVER_REL, |
275 | &write_test, | 276 | &write_test, |
276 | client)) | 277 | client)) |
277 | GNUNET_SERVER_receive_done(client, GNUNET_SYSERR); | 278 | GNUNET_SERVER_receive_done (client, GNUNET_SYSERR); |
278 | } | 279 | } |
279 | 280 | ||
280 | 281 | ||
@@ -305,10 +306,10 @@ static const struct GNUNET_SERVER_MessageHandler defhandlers[] = | |||
305 | * for unknown address family (will be denied). | 306 | * for unknown address family (will be denied). |
306 | */ | 307 | */ |
307 | static int | 308 | static int |
308 | check_access(void *cls, | 309 | check_access (void *cls, |
309 | const struct GNUNET_CONNECTION_Credentials *uc, | 310 | const struct GNUNET_CONNECTION_Credentials *uc, |
310 | const struct sockaddr *addr, | 311 | const struct sockaddr *addr, |
311 | socklen_t addrlen) | 312 | socklen_t addrlen) |
312 | { | 313 | { |
313 | struct LEGACY_SERVICE_Context *sctx = cls; | 314 | struct LEGACY_SERVICE_Context *sctx = cls; |
314 | const struct sockaddr_in *i4; | 315 | const struct sockaddr_in *i4; |
@@ -316,42 +317,42 @@ check_access(void *cls, | |||
316 | int ret; | 317 | int ret; |
317 | 318 | ||
318 | switch (addr->sa_family) | 319 | switch (addr->sa_family) |
319 | { | 320 | { |
320 | case AF_INET: | 321 | case AF_INET: |
321 | GNUNET_assert(addrlen == sizeof(struct sockaddr_in)); | 322 | GNUNET_assert (addrlen == sizeof(struct sockaddr_in)); |
322 | i4 = (const struct sockaddr_in *)addr; | 323 | i4 = (const struct sockaddr_in *) addr; |
323 | ret = ((NULL == sctx->v4_allowed) || | 324 | ret = ((NULL == sctx->v4_allowed) || |
324 | (check_ipv4_listed(sctx->v4_allowed, &i4->sin_addr))) && | 325 | (check_ipv4_listed (sctx->v4_allowed, &i4->sin_addr))) && |
325 | ((NULL == sctx->v4_denied) || | 326 | ((NULL == sctx->v4_denied) || |
326 | (!check_ipv4_listed(sctx->v4_denied, &i4->sin_addr))); | 327 | (! check_ipv4_listed (sctx->v4_denied, &i4->sin_addr))); |
327 | break; | 328 | break; |
328 | 329 | ||
329 | case AF_INET6: | 330 | case AF_INET6: |
330 | GNUNET_assert(addrlen == sizeof(struct sockaddr_in6)); | 331 | GNUNET_assert (addrlen == sizeof(struct sockaddr_in6)); |
331 | i6 = (const struct sockaddr_in6 *)addr; | 332 | i6 = (const struct sockaddr_in6 *) addr; |
332 | ret = ((NULL == sctx->v6_allowed) || | 333 | ret = ((NULL == sctx->v6_allowed) || |
333 | (check_ipv6_listed(sctx->v6_allowed, &i6->sin6_addr))) && | 334 | (check_ipv6_listed (sctx->v6_allowed, &i6->sin6_addr))) && |
334 | ((NULL == sctx->v6_denied) || | 335 | ((NULL == sctx->v6_denied) || |
335 | (!check_ipv6_listed(sctx->v6_denied, &i6->sin6_addr))); | 336 | (! check_ipv6_listed (sctx->v6_denied, &i6->sin6_addr))); |
336 | break; | 337 | break; |
337 | 338 | ||
338 | case AF_UNIX: | 339 | case AF_UNIX: |
339 | ret = GNUNET_OK; /* controlled using file-system ACL now */ | 340 | ret = GNUNET_OK; /* controlled using file-system ACL now */ |
340 | break; | 341 | break; |
341 | 342 | ||
342 | default: | 343 | default: |
343 | LOG(GNUNET_ERROR_TYPE_WARNING, | 344 | LOG (GNUNET_ERROR_TYPE_WARNING, |
344 | _("Unknown address family %d\n"), | 345 | _ ("Unknown address family %d\n"), |
345 | addr->sa_family); | 346 | addr->sa_family); |
346 | return GNUNET_SYSERR; | 347 | return GNUNET_SYSERR; |
347 | } | 348 | } |
348 | if (GNUNET_OK != ret) | 349 | if (GNUNET_OK != ret) |
349 | { | 350 | { |
350 | LOG(GNUNET_ERROR_TYPE_WARNING, | 351 | LOG (GNUNET_ERROR_TYPE_WARNING, |
351 | _("Access from `%s' denied to service `%s'\n"), | 352 | _ ("Access from `%s' denied to service `%s'\n"), |
352 | GNUNET_a2s(addr, addrlen), | 353 | GNUNET_a2s (addr, addrlen), |
353 | sctx->service_name); | 354 | sctx->service_name); |
354 | } | 355 | } |
355 | return ret; | 356 | return ret; |
356 | } | 357 | } |
357 | 358 | ||
@@ -364,14 +365,14 @@ check_access(void *cls, | |||
364 | * @return name of the file for the process ID | 365 | * @return name of the file for the process ID |
365 | */ | 366 | */ |
366 | static char * | 367 | static char * |
367 | get_pid_file_name(struct LEGACY_SERVICE_Context *sctx) | 368 | get_pid_file_name (struct LEGACY_SERVICE_Context *sctx) |
368 | { | 369 | { |
369 | char *pif; | 370 | char *pif; |
370 | 371 | ||
371 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sctx->cfg, | 372 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, |
372 | sctx->service_name, | 373 | sctx->service_name, |
373 | "PIDFILE", | 374 | "PIDFILE", |
374 | &pif)) | 375 | &pif)) |
375 | return NULL; | 376 | return NULL; |
376 | return pif; | 377 | return pif; |
377 | } | 378 | } |
@@ -387,33 +388,33 @@ get_pid_file_name(struct LEGACY_SERVICE_Context *sctx) | |||
387 | * no ACL configured) | 388 | * no ACL configured) |
388 | */ | 389 | */ |
389 | static int | 390 | static int |
390 | process_acl4(struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, | 391 | process_acl4 (struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, |
391 | struct LEGACY_SERVICE_Context *sctx, | 392 | struct LEGACY_SERVICE_Context *sctx, |
392 | const char *option) | 393 | const char *option) |
393 | { | 394 | { |
394 | char *opt; | 395 | char *opt; |
395 | 396 | ||
396 | if (!GNUNET_CONFIGURATION_have_value(sctx->cfg, sctx->service_name, option)) | 397 | if (! GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, option)) |
397 | { | 398 | { |
398 | *ret = NULL; | 399 | *ret = NULL; |
399 | return GNUNET_OK; | 400 | return GNUNET_OK; |
400 | } | 401 | } |
401 | GNUNET_break(GNUNET_OK == | 402 | GNUNET_break (GNUNET_OK == |
402 | GNUNET_CONFIGURATION_get_value_string(sctx->cfg, | 403 | GNUNET_CONFIGURATION_get_value_string (sctx->cfg, |
403 | sctx->service_name, | 404 | sctx->service_name, |
404 | option, | 405 | option, |
405 | &opt)); | 406 | &opt)); |
406 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy(opt))) | 407 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv4_policy (opt))) |
407 | { | 408 | { |
408 | LOG(GNUNET_ERROR_TYPE_WARNING, | 409 | LOG (GNUNET_ERROR_TYPE_WARNING, |
409 | _("Could not parse IPv4 network specification `%s' for `%s:%s'\n"), | 410 | _ ("Could not parse IPv4 network specification `%s' for `%s:%s'\n"), |
410 | opt, | 411 | opt, |
411 | sctx->service_name, | 412 | sctx->service_name, |
412 | option); | 413 | option); |
413 | GNUNET_free(opt); | 414 | GNUNET_free (opt); |
414 | return GNUNET_SYSERR; | 415 | return GNUNET_SYSERR; |
415 | } | 416 | } |
416 | GNUNET_free(opt); | 417 | GNUNET_free (opt); |
417 | return GNUNET_OK; | 418 | return GNUNET_OK; |
418 | } | 419 | } |
419 | 420 | ||
@@ -428,33 +429,33 @@ process_acl4(struct GNUNET_STRINGS_IPv4NetworkPolicy **ret, | |||
428 | * no ACL configured) | 429 | * no ACL configured) |
429 | */ | 430 | */ |
430 | static int | 431 | static int |
431 | process_acl6(struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, | 432 | process_acl6 (struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, |
432 | struct LEGACY_SERVICE_Context *sctx, | 433 | struct LEGACY_SERVICE_Context *sctx, |
433 | const char *option) | 434 | const char *option) |
434 | { | 435 | { |
435 | char *opt; | 436 | char *opt; |
436 | 437 | ||
437 | if (!GNUNET_CONFIGURATION_have_value(sctx->cfg, sctx->service_name, option)) | 438 | if (! GNUNET_CONFIGURATION_have_value (sctx->cfg, sctx->service_name, option)) |
438 | { | 439 | { |
439 | *ret = NULL; | 440 | *ret = NULL; |
440 | return GNUNET_OK; | 441 | return GNUNET_OK; |
441 | } | 442 | } |
442 | GNUNET_break(GNUNET_OK == | 443 | GNUNET_break (GNUNET_OK == |
443 | GNUNET_CONFIGURATION_get_value_string(sctx->cfg, | 444 | GNUNET_CONFIGURATION_get_value_string (sctx->cfg, |
444 | sctx->service_name, | 445 | sctx->service_name, |
445 | option, | 446 | option, |
446 | &opt)); | 447 | &opt)); |
447 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy(opt))) | 448 | if (NULL == (*ret = GNUNET_STRINGS_parse_ipv6_policy (opt))) |
448 | { | 449 | { |
449 | LOG(GNUNET_ERROR_TYPE_WARNING, | 450 | LOG (GNUNET_ERROR_TYPE_WARNING, |
450 | _("Could not parse IPv6 network specification `%s' for `%s:%s'\n"), | 451 | _ ("Could not parse IPv6 network specification `%s' for `%s:%s'\n"), |
451 | opt, | 452 | opt, |
452 | sctx->service_name, | 453 | sctx->service_name, |
453 | option); | 454 | option); |
454 | GNUNET_free(opt); | 455 | GNUNET_free (opt); |
455 | return GNUNET_SYSERR; | 456 | return GNUNET_SYSERR; |
456 | } | 457 | } |
457 | GNUNET_free(opt); | 458 | GNUNET_free (opt); |
458 | return GNUNET_OK; | 459 | return GNUNET_OK; |
459 | } | 460 | } |
460 | 461 | ||
@@ -470,30 +471,30 @@ process_acl6(struct GNUNET_STRINGS_IPv6NetworkPolicy **ret, | |||
470 | * parameter is ignore on systems other than LINUX | 471 | * parameter is ignore on systems other than LINUX |
471 | */ | 472 | */ |
472 | static void | 473 | static void |
473 | add_unixpath(struct sockaddr **saddrs, | 474 | add_unixpath (struct sockaddr **saddrs, |
474 | socklen_t *saddrlens, | 475 | socklen_t *saddrlens, |
475 | const char *unixpath, | 476 | const char *unixpath, |
476 | int abstract) | 477 | int abstract) |
477 | { | 478 | { |
478 | #ifdef AF_UNIX | 479 | #ifdef AF_UNIX |
479 | struct sockaddr_un *un; | 480 | struct sockaddr_un *un; |
480 | 481 | ||
481 | un = GNUNET_new(struct sockaddr_un); | 482 | un = GNUNET_new (struct sockaddr_un); |
482 | un->sun_family = AF_UNIX; | 483 | un->sun_family = AF_UNIX; |
483 | GNUNET_strlcpy(un->sun_path, unixpath, sizeof(un->sun_path)); | 484 | GNUNET_strlcpy (un->sun_path, unixpath, sizeof(un->sun_path)); |
484 | #ifdef LINUX | 485 | #ifdef LINUX |
485 | if (GNUNET_YES == abstract) | 486 | if (GNUNET_YES == abstract) |
486 | un->sun_path[0] = '\0'; | 487 | un->sun_path[0] = '\0'; |
487 | #endif | 488 | #endif |
488 | #if HAVE_SOCKADDR_UN_SUN_LEN | 489 | #if HAVE_SOCKADDR_UN_SUN_LEN |
489 | un->sun_len = (u_char)sizeof(struct sockaddr_un); | 490 | un->sun_len = (u_char) sizeof(struct sockaddr_un); |
490 | #endif | 491 | #endif |
491 | *saddrs = (struct sockaddr *)un; | 492 | *saddrs = (struct sockaddr *) un; |
492 | *saddrlens = sizeof(struct sockaddr_un); | 493 | *saddrlens = sizeof(struct sockaddr_un); |
493 | #else | 494 | #else |
494 | /* this function should never be called | 495 | /* this function should never be called |
495 | * unless AF_UNIX is defined! */ | 496 | * unless AF_UNIX is defined! */ |
496 | GNUNET_assert(0); | 497 | GNUNET_assert (0); |
497 | #endif | 498 | #endif |
498 | } | 499 | } |
499 | 500 | ||
@@ -519,7 +520,7 @@ add_unixpath(struct sockaddr **saddrs, | |||
519 | * set to NULL). | 520 | * set to NULL). |
520 | */ | 521 | */ |
521 | int | 522 | int |
522 | LEGACY_SERVICE_get_server_addresses( | 523 | LEGACY_SERVICE_get_server_addresses ( |
523 | const char *service_name, | 524 | const char *service_name, |
524 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 525 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
525 | struct sockaddr ***addrs, | 526 | struct sockaddr ***addrs, |
@@ -544,72 +545,72 @@ LEGACY_SERVICE_get_server_addresses( | |||
544 | *addrs = NULL; | 545 | *addrs = NULL; |
545 | *addr_lens = NULL; | 546 | *addr_lens = NULL; |
546 | desc = NULL; | 547 | desc = NULL; |
547 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "DISABLEV6")) | 548 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "DISABLEV6")) |
548 | { | 549 | { |
549 | if (GNUNET_SYSERR == | 550 | if (GNUNET_SYSERR == |
550 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno(cfg, | 551 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (cfg, |
551 | service_name, | 552 | service_name, |
552 | "DISABLEV6"))) | 553 | "DISABLEV6"))) |
553 | return GNUNET_SYSERR; | 554 | return GNUNET_SYSERR; |
554 | } | 555 | } |
555 | else | 556 | else |
556 | disablev6 = GNUNET_NO; | 557 | disablev6 = GNUNET_NO; |
557 | 558 | ||
558 | if (!disablev6) | 559 | if (! disablev6) |
560 | { | ||
561 | /* probe IPv6 support */ | ||
562 | desc = GNUNET_NETWORK_socket_create (PF_INET6, SOCK_STREAM, 0); | ||
563 | if (NULL == desc) | ||
559 | { | 564 | { |
560 | /* probe IPv6 support */ | 565 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || |
561 | desc = GNUNET_NETWORK_socket_create(PF_INET6, SOCK_STREAM, 0); | 566 | (EACCES == errno)) |
562 | if (NULL == desc) | 567 | { |
563 | { | 568 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); |
564 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 569 | return GNUNET_SYSERR; |
565 | (EACCES == errno)) | 570 | } |
566 | { | 571 | LOG (GNUNET_ERROR_TYPE_INFO, |
567 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 572 | _ ( |
568 | return GNUNET_SYSERR; | 573 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), |
569 | } | 574 | service_name, |
570 | LOG(GNUNET_ERROR_TYPE_INFO, | 575 | strerror (errno)); |
571 | _( | 576 | disablev6 = GNUNET_YES; |
572 | "Disabling IPv6 support for service `%s', failed to create IPv6 socket: %s\n"), | ||
573 | service_name, | ||
574 | strerror(errno)); | ||
575 | disablev6 = GNUNET_YES; | ||
576 | } | ||
577 | else | ||
578 | { | ||
579 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
580 | desc = NULL; | ||
581 | } | ||
582 | } | 577 | } |
578 | else | ||
579 | { | ||
580 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | ||
581 | desc = NULL; | ||
582 | } | ||
583 | } | ||
583 | 584 | ||
584 | port = 0; | 585 | port = 0; |
585 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "PORT")) | 586 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "PORT")) |
587 | { | ||
588 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number (cfg, | ||
589 | service_name, | ||
590 | "PORT", | ||
591 | &port)) | ||
586 | { | 592 | { |
587 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_number(cfg, | 593 | LOG (GNUNET_ERROR_TYPE_ERROR, |
588 | service_name, | 594 | _ ("Require valid port number for service `%s' in configuration!\n"), |
589 | "PORT", | 595 | service_name); |
590 | &port)) | ||
591 | { | ||
592 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
593 | _("Require valid port number for service `%s' in configuration!\n"), | ||
594 | service_name); | ||
595 | } | ||
596 | if (port > 65535) | ||
597 | { | ||
598 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
599 | _("Require valid port number for service `%s' in configuration!\n"), | ||
600 | service_name); | ||
601 | return GNUNET_SYSERR; | ||
602 | } | ||
603 | } | 596 | } |
604 | 597 | if (port > 65535) | |
605 | if (GNUNET_CONFIGURATION_have_value(cfg, service_name, "BINDTO")) | ||
606 | { | 598 | { |
607 | GNUNET_break(GNUNET_OK == | 599 | LOG (GNUNET_ERROR_TYPE_ERROR, |
608 | GNUNET_CONFIGURATION_get_value_string(cfg, | 600 | _ ("Require valid port number for service `%s' in configuration!\n"), |
601 | service_name); | ||
602 | return GNUNET_SYSERR; | ||
603 | } | ||
604 | } | ||
605 | |||
606 | if (GNUNET_CONFIGURATION_have_value (cfg, service_name, "BINDTO")) | ||
607 | { | ||
608 | GNUNET_break (GNUNET_OK == | ||
609 | GNUNET_CONFIGURATION_get_value_string (cfg, | ||
609 | service_name, | 610 | service_name, |
610 | "BINDTO", | 611 | "BINDTO", |
611 | &hostname)); | 612 | &hostname)); |
612 | } | 613 | } |
613 | else | 614 | else |
614 | hostname = NULL; | 615 | hostname = NULL; |
615 | 616 | ||
@@ -617,232 +618,232 @@ LEGACY_SERVICE_get_server_addresses( | |||
617 | abstract = GNUNET_NO; | 618 | abstract = GNUNET_NO; |
618 | #ifdef AF_UNIX | 619 | #ifdef AF_UNIX |
619 | if ((GNUNET_YES == | 620 | if ((GNUNET_YES == |
620 | GNUNET_CONFIGURATION_have_value(cfg, service_name, "UNIXPATH")) && | 621 | GNUNET_CONFIGURATION_have_value (cfg, service_name, "UNIXPATH")) && |
621 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename(cfg, | 622 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_filename (cfg, |
622 | service_name, | 623 | service_name, |
623 | "UNIXPATH", | 624 | "UNIXPATH", |
624 | &unixpath)) && | 625 | &unixpath)) && |
625 | (0 < strlen(unixpath))) | 626 | (0 < strlen (unixpath))) |
627 | { | ||
628 | /* probe UNIX support */ | ||
629 | struct sockaddr_un s_un; | ||
630 | |||
631 | if (strlen (unixpath) >= sizeof(s_un.sun_path)) | ||
626 | { | 632 | { |
627 | /* probe UNIX support */ | 633 | LOG (GNUNET_ERROR_TYPE_WARNING, |
628 | struct sockaddr_un s_un; | 634 | _ ("UNIXPATH `%s' too long, maximum length is %llu\n"), |
629 | 635 | unixpath, | |
630 | if (strlen(unixpath) >= sizeof(s_un.sun_path)) | 636 | (unsigned long long) sizeof(s_un.sun_path)); |
631 | { | 637 | unixpath = GNUNET_NETWORK_shorten_unixpath (unixpath); |
632 | LOG(GNUNET_ERROR_TYPE_WARNING, | 638 | LOG (GNUNET_ERROR_TYPE_INFO, _ ("Using `%s' instead\n"), unixpath); |
633 | _("UNIXPATH `%s' too long, maximum length is %llu\n"), | 639 | } |
634 | unixpath, | ||
635 | (unsigned long long)sizeof(s_un.sun_path)); | ||
636 | unixpath = GNUNET_NETWORK_shorten_unixpath(unixpath); | ||
637 | LOG(GNUNET_ERROR_TYPE_INFO, _("Using `%s' instead\n"), unixpath); | ||
638 | } | ||
639 | #ifdef LINUX | 640 | #ifdef LINUX |
640 | abstract = GNUNET_CONFIGURATION_get_value_yesno(cfg, | 641 | abstract = GNUNET_CONFIGURATION_get_value_yesno (cfg, |
641 | "TESTING", | 642 | "TESTING", |
642 | "USE_ABSTRACT_SOCKETS"); | 643 | "USE_ABSTRACT_SOCKETS"); |
643 | if (GNUNET_SYSERR == abstract) | 644 | if (GNUNET_SYSERR == abstract) |
644 | abstract = GNUNET_NO; | 645 | abstract = GNUNET_NO; |
645 | #endif | 646 | #endif |
646 | if ((GNUNET_YES != abstract) && | 647 | if ((GNUNET_YES != abstract) && |
647 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file(unixpath))) | 648 | (GNUNET_OK != GNUNET_DISK_directory_create_for_file (unixpath))) |
648 | GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); | 649 | GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_ERROR, "mkdir", unixpath); |
649 | } | 650 | } |
650 | if (NULL != unixpath) | 651 | if (NULL != unixpath) |
652 | { | ||
653 | desc = GNUNET_NETWORK_socket_create (AF_UNIX, SOCK_STREAM, 0); | ||
654 | if (NULL == desc) | ||
651 | { | 655 | { |
652 | desc = GNUNET_NETWORK_socket_create(AF_UNIX, SOCK_STREAM, 0); | 656 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || |
653 | if (NULL == desc) | 657 | (EACCES == errno)) |
654 | { | 658 | { |
655 | if ((ENOBUFS == errno) || (ENOMEM == errno) || (ENFILE == errno) || | 659 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "socket"); |
656 | (EACCES == errno)) | 660 | GNUNET_free_non_null (hostname); |
657 | { | 661 | GNUNET_free (unixpath); |
658 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "socket"); | 662 | return GNUNET_SYSERR; |
659 | GNUNET_free_non_null(hostname); | 663 | } |
660 | GNUNET_free(unixpath); | 664 | LOG (GNUNET_ERROR_TYPE_INFO, |
661 | return GNUNET_SYSERR; | 665 | _ ( |
662 | } | 666 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), |
663 | LOG(GNUNET_ERROR_TYPE_INFO, | 667 | service_name, |
664 | _( | 668 | strerror (errno)); |
665 | "Disabling UNIX domain socket support for service `%s', failed to create UNIX domain socket: %s\n"), | 669 | GNUNET_free (unixpath); |
666 | service_name, | 670 | unixpath = NULL; |
667 | strerror(errno)); | ||
668 | GNUNET_free(unixpath); | ||
669 | unixpath = NULL; | ||
670 | } | ||
671 | else | ||
672 | { | ||
673 | GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(desc)); | ||
674 | desc = NULL; | ||
675 | } | ||
676 | } | 671 | } |
672 | else | ||
673 | { | ||
674 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (desc)); | ||
675 | desc = NULL; | ||
676 | } | ||
677 | } | ||
677 | #endif | 678 | #endif |
678 | 679 | ||
679 | if ((0 == port) && (NULL == unixpath)) | 680 | if ((0 == port) && (NULL == unixpath)) |
681 | { | ||
682 | LOG (GNUNET_ERROR_TYPE_ERROR, | ||
683 | _ ( | ||
684 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | ||
685 | service_name); | ||
686 | GNUNET_free_non_null (hostname); | ||
687 | return GNUNET_SYSERR; | ||
688 | } | ||
689 | if (0 == port) | ||
690 | { | ||
691 | saddrs = GNUNET_malloc (2 * sizeof(struct sockaddr *)); | ||
692 | saddrlens = GNUNET_malloc (2 * sizeof(socklen_t)); | ||
693 | add_unixpath (saddrs, saddrlens, unixpath, abstract); | ||
694 | GNUNET_free_non_null (unixpath); | ||
695 | GNUNET_free_non_null (hostname); | ||
696 | *addrs = saddrs; | ||
697 | *addr_lens = saddrlens; | ||
698 | return 1; | ||
699 | } | ||
700 | |||
701 | if (NULL != hostname) | ||
702 | { | ||
703 | LOG (GNUNET_ERROR_TYPE_DEBUG, | ||
704 | "Resolving `%s' since that is where `%s' will bind to.\n", | ||
705 | hostname, | ||
706 | service_name); | ||
707 | memset (&hints, 0, sizeof(struct addrinfo)); | ||
708 | if (disablev6) | ||
709 | hints.ai_family = AF_INET; | ||
710 | hints.ai_protocol = IPPROTO_TCP; | ||
711 | if ((0 != (ret = getaddrinfo (hostname, NULL, &hints, &res))) || | ||
712 | (NULL == res)) | ||
680 | { | 713 | { |
681 | LOG(GNUNET_ERROR_TYPE_ERROR, | 714 | LOG (GNUNET_ERROR_TYPE_ERROR, |
682 | _( | 715 | _ ("Failed to resolve `%s': %s\n"), |
683 | "Have neither PORT nor UNIXPATH for service `%s', but one is required\n"), | 716 | hostname, |
684 | service_name); | 717 | gai_strerror (ret)); |
685 | GNUNET_free_non_null(hostname); | 718 | GNUNET_free (hostname); |
719 | GNUNET_free_non_null (unixpath); | ||
686 | return GNUNET_SYSERR; | 720 | return GNUNET_SYSERR; |
687 | } | 721 | } |
688 | if (0 == port) | 722 | next = res; |
723 | i = 0; | ||
724 | while (NULL != (pos = next)) | ||
689 | { | 725 | { |
690 | saddrs = GNUNET_malloc(2 * sizeof(struct sockaddr *)); | 726 | next = pos->ai_next; |
691 | saddrlens = GNUNET_malloc(2 * sizeof(socklen_t)); | 727 | if ((disablev6) && (pos->ai_family == AF_INET6)) |
692 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 728 | continue; |
693 | GNUNET_free_non_null(unixpath); | 729 | i++; |
694 | GNUNET_free_non_null(hostname); | ||
695 | *addrs = saddrs; | ||
696 | *addr_lens = saddrlens; | ||
697 | return 1; | ||
698 | } | 730 | } |
699 | 731 | if (0 == i) | |
700 | if (NULL != hostname) | ||
701 | { | 732 | { |
702 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 733 | LOG (GNUNET_ERROR_TYPE_ERROR, |
703 | "Resolving `%s' since that is where `%s' will bind to.\n", | 734 | _ ("Failed to find %saddress for `%s'.\n"), |
704 | hostname, | 735 | disablev6 ? "IPv4 " : "", |
705 | service_name); | 736 | hostname); |
706 | memset(&hints, 0, sizeof(struct addrinfo)); | 737 | freeaddrinfo (res); |
707 | if (disablev6) | 738 | GNUNET_free (hostname); |
708 | hints.ai_family = AF_INET; | 739 | GNUNET_free_non_null (unixpath); |
709 | hints.ai_protocol = IPPROTO_TCP; | 740 | return GNUNET_SYSERR; |
710 | if ((0 != (ret = getaddrinfo(hostname, NULL, &hints, &res))) || | 741 | } |
711 | (NULL == res)) | 742 | resi = i; |
712 | { | 743 | if (NULL != unixpath) |
713 | LOG(GNUNET_ERROR_TYPE_ERROR, | 744 | resi++; |
714 | _("Failed to resolve `%s': %s\n"), | 745 | saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *)); |
715 | hostname, | 746 | saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t)); |
716 | gai_strerror(ret)); | 747 | i = 0; |
717 | GNUNET_free(hostname); | 748 | if (NULL != unixpath) |
718 | GNUNET_free_non_null(unixpath); | 749 | { |
719 | return GNUNET_SYSERR; | 750 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
720 | } | 751 | i++; |
721 | next = res; | 752 | } |
722 | i = 0; | 753 | next = res; |
723 | while (NULL != (pos = next)) | 754 | while (NULL != (pos = next)) |
724 | { | 755 | { |
725 | next = pos->ai_next; | 756 | next = pos->ai_next; |
726 | if ((disablev6) && (pos->ai_family == AF_INET6)) | 757 | if ((disablev6) && (AF_INET6 == pos->ai_family)) |
727 | continue; | 758 | continue; |
728 | i++; | 759 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) |
729 | } | 760 | continue; /* not TCP */ |
730 | if (0 == i) | 761 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) |
731 | { | 762 | continue; /* huh? */ |
732 | LOG(GNUNET_ERROR_TYPE_ERROR, | 763 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
733 | _("Failed to find %saddress for `%s'.\n"), | 764 | "Service `%s' will bind to `%s'\n", |
734 | disablev6 ? "IPv4 " : "", | 765 | service_name, |
735 | hostname); | 766 | GNUNET_a2s (pos->ai_addr, pos->ai_addrlen)); |
736 | freeaddrinfo(res); | 767 | if (AF_INET == pos->ai_family) |
737 | GNUNET_free(hostname); | 768 | { |
738 | GNUNET_free_non_null(unixpath); | 769 | GNUNET_assert (sizeof(struct sockaddr_in) == pos->ai_addrlen); |
739 | return GNUNET_SYSERR; | 770 | saddrlens[i] = pos->ai_addrlen; |
740 | } | 771 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
741 | resi = i; | 772 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); |
773 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | ||
774 | } | ||
775 | else | ||
776 | { | ||
777 | GNUNET_assert (AF_INET6 == pos->ai_family); | ||
778 | GNUNET_assert (sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
779 | saddrlens[i] = pos->ai_addrlen; | ||
780 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | ||
781 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | ||
782 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | ||
783 | } | ||
784 | i++; | ||
785 | } | ||
786 | GNUNET_free (hostname); | ||
787 | freeaddrinfo (res); | ||
788 | resi = i; | ||
789 | } | ||
790 | else | ||
791 | { | ||
792 | /* will bind against everything, just set port */ | ||
793 | if (disablev6) | ||
794 | { | ||
795 | /* V4-only */ | ||
796 | resi = 1; | ||
742 | if (NULL != unixpath) | 797 | if (NULL != unixpath) |
743 | resi++; | 798 | resi++; |
744 | saddrs = GNUNET_malloc((resi + 1) * sizeof(struct sockaddr *)); | ||
745 | saddrlens = GNUNET_malloc((resi + 1) * sizeof(socklen_t)); | ||
746 | i = 0; | 799 | i = 0; |
800 | saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *)); | ||
801 | saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t)); | ||
747 | if (NULL != unixpath) | 802 | if (NULL != unixpath) |
748 | { | 803 | { |
749 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 804 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
750 | i++; | 805 | i++; |
751 | } | 806 | } |
752 | next = res; | 807 | saddrlens[i] = sizeof(struct sockaddr_in); |
753 | while (NULL != (pos = next)) | 808 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
754 | { | ||
755 | next = pos->ai_next; | ||
756 | if ((disablev6) && (AF_INET6 == pos->ai_family)) | ||
757 | continue; | ||
758 | if ((IPPROTO_TCP != pos->ai_protocol) && (0 != pos->ai_protocol)) | ||
759 | continue; /* not TCP */ | ||
760 | if ((SOCK_STREAM != pos->ai_socktype) && (0 != pos->ai_socktype)) | ||
761 | continue; /* huh? */ | ||
762 | LOG(GNUNET_ERROR_TYPE_DEBUG, | ||
763 | "Service `%s' will bind to `%s'\n", | ||
764 | service_name, | ||
765 | GNUNET_a2s(pos->ai_addr, pos->ai_addrlen)); | ||
766 | if (AF_INET == pos->ai_family) | ||
767 | { | ||
768 | GNUNET_assert(sizeof(struct sockaddr_in) == pos->ai_addrlen); | ||
769 | saddrlens[i] = pos->ai_addrlen; | ||
770 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
771 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
772 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | ||
773 | } | ||
774 | else | ||
775 | { | ||
776 | GNUNET_assert(AF_INET6 == pos->ai_family); | ||
777 | GNUNET_assert(sizeof(struct sockaddr_in6) == pos->ai_addrlen); | ||
778 | saddrlens[i] = pos->ai_addrlen; | ||
779 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
780 | GNUNET_memcpy(saddrs[i], pos->ai_addr, saddrlens[i]); | ||
781 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | ||
782 | } | ||
783 | i++; | ||
784 | } | ||
785 | GNUNET_free(hostname); | ||
786 | freeaddrinfo(res); | ||
787 | resi = i; | ||
788 | } | ||
789 | else | ||
790 | { | ||
791 | /* will bind against everything, just set port */ | ||
792 | if (disablev6) | ||
793 | { | ||
794 | /* V4-only */ | ||
795 | resi = 1; | ||
796 | if (NULL != unixpath) | ||
797 | resi++; | ||
798 | i = 0; | ||
799 | saddrs = GNUNET_malloc((resi + 1) * sizeof(struct sockaddr *)); | ||
800 | saddrlens = GNUNET_malloc((resi + 1) * sizeof(socklen_t)); | ||
801 | if (NULL != unixpath) | ||
802 | { | ||
803 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | ||
804 | i++; | ||
805 | } | ||
806 | saddrlens[i] = sizeof(struct sockaddr_in); | ||
807 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | ||
808 | #if HAVE_SOCKADDR_IN_SIN_LEN | 809 | #if HAVE_SOCKADDR_IN_SIN_LEN |
809 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[i]; | 810 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[i]; |
810 | #endif | 811 | #endif |
811 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 812 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
812 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 813 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
813 | } | 814 | } |
814 | else | 815 | else |
815 | { | 816 | { |
816 | /* dual stack */ | 817 | /* dual stack */ |
817 | resi = 2; | 818 | resi = 2; |
818 | if (NULL != unixpath) | 819 | if (NULL != unixpath) |
819 | resi++; | 820 | resi++; |
820 | saddrs = GNUNET_malloc((resi + 1) * sizeof(struct sockaddr *)); | 821 | saddrs = GNUNET_malloc ((resi + 1) * sizeof(struct sockaddr *)); |
821 | saddrlens = GNUNET_malloc((resi + 1) * sizeof(socklen_t)); | 822 | saddrlens = GNUNET_malloc ((resi + 1) * sizeof(socklen_t)); |
822 | i = 0; | 823 | i = 0; |
823 | if (NULL != unixpath) | 824 | if (NULL != unixpath) |
824 | { | 825 | { |
825 | add_unixpath(saddrs, saddrlens, unixpath, abstract); | 826 | add_unixpath (saddrs, saddrlens, unixpath, abstract); |
826 | i++; | 827 | i++; |
827 | } | 828 | } |
828 | saddrlens[i] = sizeof(struct sockaddr_in6); | 829 | saddrlens[i] = sizeof(struct sockaddr_in6); |
829 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 830 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
830 | #if HAVE_SOCKADDR_IN_SIN_LEN | 831 | #if HAVE_SOCKADDR_IN_SIN_LEN |
831 | ((struct sockaddr_in6 *)saddrs[i])->sin6_len = saddrlens[0]; | 832 | ((struct sockaddr_in6 *) saddrs[i])->sin6_len = saddrlens[0]; |
832 | #endif | 833 | #endif |
833 | ((struct sockaddr_in6 *)saddrs[i])->sin6_family = AF_INET6; | 834 | ((struct sockaddr_in6 *) saddrs[i])->sin6_family = AF_INET6; |
834 | ((struct sockaddr_in6 *)saddrs[i])->sin6_port = htons(port); | 835 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); |
835 | i++; | 836 | i++; |
836 | saddrlens[i] = sizeof(struct sockaddr_in); | 837 | saddrlens[i] = sizeof(struct sockaddr_in); |
837 | saddrs[i] = GNUNET_malloc(saddrlens[i]); | 838 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
838 | #if HAVE_SOCKADDR_IN_SIN_LEN | 839 | #if HAVE_SOCKADDR_IN_SIN_LEN |
839 | ((struct sockaddr_in *)saddrs[i])->sin_len = saddrlens[1]; | 840 | ((struct sockaddr_in *) saddrs[i])->sin_len = saddrlens[1]; |
840 | #endif | 841 | #endif |
841 | ((struct sockaddr_in *)saddrs[i])->sin_family = AF_INET; | 842 | ((struct sockaddr_in *) saddrs[i])->sin_family = AF_INET; |
842 | ((struct sockaddr_in *)saddrs[i])->sin_port = htons(port); | 843 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
843 | } | ||
844 | } | 844 | } |
845 | GNUNET_free_non_null(unixpath); | 845 | } |
846 | GNUNET_free_non_null (unixpath); | ||
846 | *addrs = saddrs; | 847 | *addrs = saddrs; |
847 | *addr_lens = saddrlens; | 848 | *addr_lens = saddrlens; |
848 | return resi; | 849 | return resi; |
@@ -868,7 +869,7 @@ LEGACY_SERVICE_get_server_addresses( | |||
868 | * @return #GNUNET_OK if configuration succeeded | 869 | * @return #GNUNET_OK if configuration succeeded |
869 | */ | 870 | */ |
870 | static int | 871 | static int |
871 | setup_service(struct LEGACY_SERVICE_Context *sctx) | 872 | setup_service (struct LEGACY_SERVICE_Context *sctx) |
872 | { | 873 | { |
873 | struct GNUNET_TIME_Relative idleout; | 874 | struct GNUNET_TIME_Relative idleout; |
874 | int tolerant; | 875 | int tolerant; |
@@ -876,91 +877,91 @@ setup_service(struct LEGACY_SERVICE_Context *sctx) | |||
876 | unsigned int cnt; | 877 | unsigned int cnt; |
877 | int flags; | 878 | int flags; |
878 | 879 | ||
879 | if (GNUNET_CONFIGURATION_have_value(sctx->cfg, | 880 | if (GNUNET_CONFIGURATION_have_value (sctx->cfg, |
880 | sctx->service_name, | 881 | sctx->service_name, |
881 | "TIMEOUT")) | 882 | "TIMEOUT")) |
883 | { | ||
884 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time (sctx->cfg, | ||
885 | sctx->service_name, | ||
886 | "TIMEOUT", | ||
887 | &idleout)) | ||
882 | { | 888 | { |
883 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_time(sctx->cfg, | 889 | LOG (GNUNET_ERROR_TYPE_ERROR, |
884 | sctx->service_name, | 890 | _ ("Specified value for `%s' of service `%s' is invalid\n"), |
885 | "TIMEOUT", | 891 | "TIMEOUT", |
886 | &idleout)) | 892 | sctx->service_name); |
887 | { | 893 | return GNUNET_SYSERR; |
888 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
889 | _("Specified value for `%s' of service `%s' is invalid\n"), | ||
890 | "TIMEOUT", | ||
891 | sctx->service_name); | ||
892 | return GNUNET_SYSERR; | ||
893 | } | ||
894 | sctx->timeout = idleout; | ||
895 | } | 894 | } |
895 | sctx->timeout = idleout; | ||
896 | } | ||
896 | else | 897 | else |
897 | sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL; | 898 | sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL; |
898 | 899 | ||
899 | if (GNUNET_CONFIGURATION_have_value(sctx->cfg, | 900 | if (GNUNET_CONFIGURATION_have_value (sctx->cfg, |
900 | sctx->service_name, | 901 | sctx->service_name, |
901 | "TOLERANT")) | 902 | "TOLERANT")) |
903 | { | ||
904 | if (GNUNET_SYSERR == | ||
905 | (tolerant = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, | ||
906 | sctx->service_name, | ||
907 | "TOLERANT"))) | ||
902 | { | 908 | { |
903 | if (GNUNET_SYSERR == | 909 | LOG (GNUNET_ERROR_TYPE_ERROR, |
904 | (tolerant = GNUNET_CONFIGURATION_get_value_yesno(sctx->cfg, | 910 | _ ("Specified value for `%s' of service `%s' is invalid\n"), |
905 | sctx->service_name, | 911 | "TOLERANT", |
906 | "TOLERANT"))) | 912 | sctx->service_name); |
907 | { | 913 | return GNUNET_SYSERR; |
908 | LOG(GNUNET_ERROR_TYPE_ERROR, | ||
909 | _("Specified value for `%s' of service `%s' is invalid\n"), | ||
910 | "TOLERANT", | ||
911 | sctx->service_name); | ||
912 | return GNUNET_SYSERR; | ||
913 | } | ||
914 | } | 914 | } |
915 | } | ||
915 | else | 916 | else |
916 | tolerant = GNUNET_NO; | 917 | tolerant = GNUNET_NO; |
917 | 918 | ||
918 | errno = 0; | 919 | errno = 0; |
919 | if ((NULL != (nfds = getenv("LISTEN_FDS"))) && | 920 | if ((NULL != (nfds = getenv ("LISTEN_FDS"))) && |
920 | (1 == sscanf(nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) && | 921 | (1 == sscanf (nfds, "%u", &cnt)) && (cnt > 0) && (cnt < FD_SETSIZE) && |
921 | (cnt + 4 < FD_SETSIZE)) | 922 | (cnt + 4 < FD_SETSIZE)) |
923 | { | ||
924 | sctx->lsocks = | ||
925 | GNUNET_malloc (sizeof(struct GNUNET_NETWORK_Handle *) * (cnt + 1)); | ||
926 | while (0 < cnt--) | ||
922 | { | 927 | { |
923 | sctx->lsocks = | 928 | flags = fcntl (3 + cnt, F_GETFD); |
924 | GNUNET_malloc(sizeof(struct GNUNET_NETWORK_Handle *) * (cnt + 1)); | 929 | if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) || |
925 | while (0 < cnt--) | 930 | (NULL == |
926 | { | 931 | (sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native (3 + cnt)))) |
927 | flags = fcntl(3 + cnt, F_GETFD); | 932 | { |
928 | if ((flags < 0) || (0 != (flags & FD_CLOEXEC)) || | 933 | LOG (GNUNET_ERROR_TYPE_ERROR, |
929 | (NULL == | 934 | _ ( |
930 | (sctx->lsocks[cnt] = GNUNET_NETWORK_socket_box_native(3 + cnt)))) | 935 | "Could not access pre-bound socket %u, will try to bind myself\n"), |
931 | { | 936 | (unsigned int) 3 + cnt); |
932 | LOG(GNUNET_ERROR_TYPE_ERROR, | 937 | cnt++; |
933 | _( | 938 | while (sctx->lsocks[cnt] != NULL) |
934 | "Could not access pre-bound socket %u, will try to bind myself\n"), | 939 | GNUNET_break (0 == GNUNET_NETWORK_socket_close (sctx->lsocks[cnt++])); |
935 | (unsigned int)3 + cnt); | 940 | GNUNET_free (sctx->lsocks); |
936 | cnt++; | 941 | sctx->lsocks = NULL; |
937 | while (sctx->lsocks[cnt] != NULL) | 942 | break; |
938 | GNUNET_break(0 == GNUNET_NETWORK_socket_close(sctx->lsocks[cnt++])); | 943 | } |
939 | GNUNET_free(sctx->lsocks); | ||
940 | sctx->lsocks = NULL; | ||
941 | break; | ||
942 | } | ||
943 | } | ||
944 | unsetenv("LISTEN_FDS"); | ||
945 | } | 944 | } |
945 | unsetenv ("LISTEN_FDS"); | ||
946 | } | ||
946 | 947 | ||
947 | if ((NULL == sctx->lsocks) && | 948 | if ((NULL == sctx->lsocks) && |
948 | (GNUNET_SYSERR == LEGACY_SERVICE_get_server_addresses(sctx->service_name, | 949 | (GNUNET_SYSERR == LEGACY_SERVICE_get_server_addresses (sctx->service_name, |
949 | sctx->cfg, | 950 | sctx->cfg, |
950 | &sctx->addrs, | 951 | &sctx->addrs, |
951 | &sctx->addrlens))) | 952 | &sctx->addrlens))) |
952 | return GNUNET_SYSERR; | 953 | return GNUNET_SYSERR; |
953 | sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES; | 954 | sctx->require_found = tolerant ? GNUNET_NO : GNUNET_YES; |
954 | sctx->match_uid = GNUNET_CONFIGURATION_get_value_yesno(sctx->cfg, | 955 | sctx->match_uid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, |
955 | sctx->service_name, | 956 | sctx->service_name, |
956 | "UNIX_MATCH_UID"); | 957 | "UNIX_MATCH_UID"); |
957 | sctx->match_gid = GNUNET_CONFIGURATION_get_value_yesno(sctx->cfg, | 958 | sctx->match_gid = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, |
958 | sctx->service_name, | 959 | sctx->service_name, |
959 | "UNIX_MATCH_GID"); | 960 | "UNIX_MATCH_GID"); |
960 | process_acl4(&sctx->v4_denied, sctx, "REJECT_FROM"); | 961 | process_acl4 (&sctx->v4_denied, sctx, "REJECT_FROM"); |
961 | process_acl4(&sctx->v4_allowed, sctx, "ACCEPT_FROM"); | 962 | process_acl4 (&sctx->v4_allowed, sctx, "ACCEPT_FROM"); |
962 | process_acl6(&sctx->v6_denied, sctx, "REJECT_FROM6"); | 963 | process_acl6 (&sctx->v6_denied, sctx, "REJECT_FROM6"); |
963 | process_acl6(&sctx->v6_allowed, sctx, "ACCEPT_FROM6"); | 964 | process_acl6 (&sctx->v6_allowed, sctx, "ACCEPT_FROM6"); |
964 | 965 | ||
965 | return GNUNET_OK; | 966 | return GNUNET_OK; |
966 | } | 967 | } |
@@ -974,14 +975,14 @@ setup_service(struct LEGACY_SERVICE_Context *sctx) | |||
974 | * @return value of the 'USERNAME' option | 975 | * @return value of the 'USERNAME' option |
975 | */ | 976 | */ |
976 | static char * | 977 | static char * |
977 | get_user_name(struct LEGACY_SERVICE_Context *sctx) | 978 | get_user_name (struct LEGACY_SERVICE_Context *sctx) |
978 | { | 979 | { |
979 | char *un; | 980 | char *un; |
980 | 981 | ||
981 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename(sctx->cfg, | 982 | if (GNUNET_OK != GNUNET_CONFIGURATION_get_value_filename (sctx->cfg, |
982 | sctx->service_name, | 983 | sctx->service_name, |
983 | "USERNAME", | 984 | "USERNAME", |
984 | &un)) | 985 | &un)) |
985 | return NULL; | 986 | return NULL; |
986 | return un; | 987 | return un; |
987 | } | 988 | } |
@@ -995,7 +996,7 @@ get_user_name(struct LEGACY_SERVICE_Context *sctx) | |||
995 | * @return #GNUNET_OK on success (including no work to be done) | 996 | * @return #GNUNET_OK on success (including no work to be done) |
996 | */ | 997 | */ |
997 | static int | 998 | static int |
998 | write_pid_file(struct LEGACY_SERVICE_Context *sctx, pid_t pid) | 999 | write_pid_file (struct LEGACY_SERVICE_Context *sctx, pid_t pid) |
999 | { | 1000 | { |
1000 | FILE *pidfd; | 1001 | FILE *pidfd; |
1001 | char *pif; | 1002 | char *pif; |
@@ -1003,46 +1004,46 @@ write_pid_file(struct LEGACY_SERVICE_Context *sctx, pid_t pid) | |||
1003 | char *rdir; | 1004 | char *rdir; |
1004 | int len; | 1005 | int len; |
1005 | 1006 | ||
1006 | if (NULL == (pif = get_pid_file_name(sctx))) | 1007 | if (NULL == (pif = get_pid_file_name (sctx))) |
1007 | return GNUNET_OK; /* no file desired */ | 1008 | return GNUNET_OK; /* no file desired */ |
1008 | user = get_user_name(sctx); | 1009 | user = get_user_name (sctx); |
1009 | rdir = GNUNET_strdup(pif); | 1010 | rdir = GNUNET_strdup (pif); |
1010 | len = strlen(rdir); | 1011 | len = strlen (rdir); |
1011 | while ((len > 0) && (rdir[len] != DIR_SEPARATOR)) | 1012 | while ((len > 0) && (rdir[len] != DIR_SEPARATOR)) |
1012 | len--; | 1013 | len--; |
1013 | rdir[len] = '\0'; | 1014 | rdir[len] = '\0'; |
1014 | if (0 != access(rdir, F_OK)) | 1015 | if (0 != access (rdir, F_OK)) |
1015 | { | 1016 | { |
1016 | /* we get to create a directory -- and claim it | 1017 | /* we get to create a directory -- and claim it |
1017 | * as ours! */ | 1018 | * as ours! */ |
1018 | (void)GNUNET_DISK_directory_create(rdir); | 1019 | (void) GNUNET_DISK_directory_create (rdir); |
1019 | if ((NULL != user) && (0 < strlen(user))) | 1020 | if ((NULL != user) && (0 < strlen (user))) |
1020 | GNUNET_DISK_file_change_owner(rdir, user); | 1021 | GNUNET_DISK_file_change_owner (rdir, user); |
1021 | } | 1022 | } |
1022 | if (0 != access(rdir, W_OK | X_OK)) | 1023 | if (0 != access (rdir, W_OK | X_OK)) |
1023 | { | 1024 | { |
1024 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "access", rdir); | 1025 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "access", rdir); |
1025 | GNUNET_free(rdir); | 1026 | GNUNET_free (rdir); |
1026 | GNUNET_free_non_null(user); | 1027 | GNUNET_free_non_null (user); |
1027 | GNUNET_free(pif); | 1028 | GNUNET_free (pif); |
1028 | return GNUNET_SYSERR; | 1029 | return GNUNET_SYSERR; |
1029 | } | 1030 | } |
1030 | GNUNET_free(rdir); | 1031 | GNUNET_free (rdir); |
1031 | pidfd = fopen(pif, "w"); | 1032 | pidfd = fopen (pif, "w"); |
1032 | if (NULL == pidfd) | 1033 | if (NULL == pidfd) |
1033 | { | 1034 | { |
1034 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_ERROR, "fopen", pif); | 1035 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_ERROR, "fopen", pif); |
1035 | GNUNET_free(pif); | 1036 | GNUNET_free (pif); |
1036 | GNUNET_free_non_null(user); | 1037 | GNUNET_free_non_null (user); |
1037 | return GNUNET_SYSERR; | 1038 | return GNUNET_SYSERR; |
1038 | } | 1039 | } |
1039 | if (0 > fprintf(pidfd, "%u", pid)) | 1040 | if (0 > fprintf (pidfd, "%u", pid)) |
1040 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "fprintf", pif); | 1041 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "fprintf", pif); |
1041 | GNUNET_break(0 == fclose(pidfd)); | 1042 | GNUNET_break (0 == fclose (pidfd)); |
1042 | if ((NULL != user) && (0 < strlen(user))) | 1043 | if ((NULL != user) && (0 < strlen (user))) |
1043 | GNUNET_DISK_file_change_owner(pif, user); | 1044 | GNUNET_DISK_file_change_owner (pif, user); |
1044 | GNUNET_free_non_null(user); | 1045 | GNUNET_free_non_null (user); |
1045 | GNUNET_free(pif); | 1046 | GNUNET_free (pif); |
1046 | return GNUNET_OK; | 1047 | return GNUNET_OK; |
1047 | } | 1048 | } |
1048 | 1049 | ||
@@ -1053,16 +1054,16 @@ write_pid_file(struct LEGACY_SERVICE_Context *sctx, pid_t pid) | |||
1053 | * @param cls the `struct LEGACY_SERVICE_Context` | 1054 | * @param cls the `struct LEGACY_SERVICE_Context` |
1054 | */ | 1055 | */ |
1055 | static void | 1056 | static void |
1056 | shutdown_task(void *cls) | 1057 | shutdown_task (void *cls) |
1057 | { | 1058 | { |
1058 | struct LEGACY_SERVICE_Context *service = cls; | 1059 | struct LEGACY_SERVICE_Context *service = cls; |
1059 | struct GNUNET_SERVER_Handle *server = service->server; | 1060 | struct GNUNET_SERVER_Handle *server = service->server; |
1060 | 1061 | ||
1061 | service->shutdown_task = NULL; | 1062 | service->shutdown_task = NULL; |
1062 | if (0 != (service->options & LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN)) | 1063 | if (0 != (service->options & LEGACY_SERVICE_OPTION_SOFT_SHUTDOWN)) |
1063 | GNUNET_SERVER_stop_listening(server); | 1064 | GNUNET_SERVER_stop_listening (server); |
1064 | else | 1065 | else |
1065 | GNUNET_SERVER_destroy(server); | 1066 | GNUNET_SERVER_destroy (server); |
1066 | } | 1067 | } |
1067 | 1068 | ||
1068 | 1069 | ||
@@ -1072,79 +1073,79 @@ shutdown_task(void *cls) | |||
1072 | * @param cls service context | 1073 | * @param cls service context |
1073 | */ | 1074 | */ |
1074 | static void | 1075 | static void |
1075 | service_task(void *cls) | 1076 | service_task (void *cls) |
1076 | { | 1077 | { |
1077 | struct LEGACY_SERVICE_Context *sctx = cls; | 1078 | struct LEGACY_SERVICE_Context *sctx = cls; |
1078 | unsigned int i; | 1079 | unsigned int i; |
1079 | 1080 | ||
1080 | GNUNET_RESOLVER_connect(sctx->cfg); | 1081 | GNUNET_RESOLVER_connect (sctx->cfg); |
1081 | if (NULL != sctx->lsocks) | 1082 | if (NULL != sctx->lsocks) |
1082 | sctx->server = GNUNET_SERVER_create_with_sockets(&check_access, | 1083 | sctx->server = GNUNET_SERVER_create_with_sockets (&check_access, |
1083 | sctx, | 1084 | sctx, |
1084 | sctx->lsocks, | 1085 | sctx->lsocks, |
1085 | sctx->timeout, | 1086 | sctx->timeout, |
1086 | sctx->require_found); | 1087 | sctx->require_found); |
1087 | else | 1088 | else |
1088 | sctx->server = GNUNET_SERVER_create(&check_access, | 1089 | sctx->server = GNUNET_SERVER_create (&check_access, |
1089 | sctx, | 1090 | sctx, |
1090 | sctx->addrs, | 1091 | sctx->addrs, |
1091 | sctx->addrlens, | 1092 | sctx->addrlens, |
1092 | sctx->timeout, | 1093 | sctx->timeout, |
1093 | sctx->require_found); | 1094 | sctx->require_found); |
1094 | if (NULL == sctx->server) | 1095 | if (NULL == sctx->server) |
1095 | { | 1096 | { |
1096 | if (NULL != sctx->addrs) | 1097 | if (NULL != sctx->addrs) |
1097 | for (i = 0; NULL != sctx->addrs[i]; i++) | 1098 | for (i = 0; NULL != sctx->addrs[i]; i++) |
1098 | LOG(GNUNET_ERROR_TYPE_INFO, | 1099 | LOG (GNUNET_ERROR_TYPE_INFO, |
1099 | _("Failed to start `%s' at `%s'\n"), | 1100 | _ ("Failed to start `%s' at `%s'\n"), |
1100 | sctx->service_name, | 1101 | sctx->service_name, |
1101 | GNUNET_a2s(sctx->addrs[i], sctx->addrlens[i])); | 1102 | GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i])); |
1102 | sctx->ret = GNUNET_SYSERR; | 1103 | sctx->ret = GNUNET_SYSERR; |
1103 | return; | 1104 | return; |
1104 | } | 1105 | } |
1105 | 1106 | ||
1106 | if (NULL != sctx->addrs) | 1107 | if (NULL != sctx->addrs) |
1107 | for (i = 0; NULL != sctx->addrs[i]; i++) | 1108 | for (i = 0; NULL != sctx->addrs[i]; i++) |
1108 | if ((AF_UNIX == sctx->addrs[i]->sa_family) && | 1109 | if ((AF_UNIX == sctx->addrs[i]->sa_family) && |
1109 | ('\0' != ((const struct sockaddr_un *)sctx->addrs[i])->sun_path[0])) | 1110 | ('\0' != ((const struct sockaddr_un *) sctx->addrs[i])->sun_path[0])) |
1110 | GNUNET_DISK_fix_permissions(((const struct sockaddr_un *) | 1111 | GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) |
1111 | sctx->addrs[i]) | 1112 | sctx->addrs[i]) |
1112 | ->sun_path, | 1113 | ->sun_path, |
1113 | sctx->match_uid, | 1114 | sctx->match_uid, |
1114 | sctx->match_gid); | 1115 | sctx->match_gid); |
1115 | 1116 | ||
1116 | if (0 == (sctx->options & LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN)) | 1117 | if (0 == (sctx->options & LEGACY_SERVICE_OPTION_MANUAL_SHUTDOWN)) |
1117 | { | 1118 | { |
1118 | /* install a task that will kill the server | 1119 | /* install a task that will kill the server |
1119 | * process if the scheduler ever gets a shutdown signal */ | 1120 | * process if the scheduler ever gets a shutdown signal */ |
1120 | sctx->shutdown_task = GNUNET_SCHEDULER_add_shutdown(&shutdown_task, sctx); | 1121 | sctx->shutdown_task = GNUNET_SCHEDULER_add_shutdown (&shutdown_task, sctx); |
1121 | } | 1122 | } |
1122 | sctx->my_handlers = GNUNET_malloc(sizeof(defhandlers)); | 1123 | sctx->my_handlers = GNUNET_malloc (sizeof(defhandlers)); |
1123 | GNUNET_memcpy(sctx->my_handlers, defhandlers, sizeof(defhandlers)); | 1124 | GNUNET_memcpy (sctx->my_handlers, defhandlers, sizeof(defhandlers)); |
1124 | i = 0; | 1125 | i = 0; |
1125 | while (NULL != sctx->my_handlers[i].callback) | 1126 | while (NULL != sctx->my_handlers[i].callback) |
1126 | sctx->my_handlers[i++].callback_cls = sctx; | 1127 | sctx->my_handlers[i++].callback_cls = sctx; |
1127 | GNUNET_SERVER_add_handlers(sctx->server, sctx->my_handlers); | 1128 | GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers); |
1128 | if (-1 != sctx->ready_confirm_fd) | 1129 | if (-1 != sctx->ready_confirm_fd) |
1129 | { | 1130 | { |
1130 | GNUNET_break(1 == write(sctx->ready_confirm_fd, ".", 1)); | 1131 | GNUNET_break (1 == write (sctx->ready_confirm_fd, ".", 1)); |
1131 | GNUNET_break(0 == close(sctx->ready_confirm_fd)); | 1132 | GNUNET_break (0 == close (sctx->ready_confirm_fd)); |
1132 | sctx->ready_confirm_fd = -1; | 1133 | sctx->ready_confirm_fd = -1; |
1133 | write_pid_file(sctx, getpid()); | 1134 | write_pid_file (sctx, getpid ()); |
1134 | } | 1135 | } |
1135 | if (NULL != sctx->addrs) | 1136 | if (NULL != sctx->addrs) |
1137 | { | ||
1138 | i = 0; | ||
1139 | while (NULL != sctx->addrs[i]) | ||
1136 | { | 1140 | { |
1137 | i = 0; | 1141 | LOG (GNUNET_ERROR_TYPE_INFO, |
1138 | while (NULL != sctx->addrs[i]) | 1142 | _ ("Service `%s' runs at %s\n"), |
1139 | { | 1143 | sctx->service_name, |
1140 | LOG(GNUNET_ERROR_TYPE_INFO, | 1144 | GNUNET_a2s (sctx->addrs[i], sctx->addrlens[i])); |
1141 | _("Service `%s' runs at %s\n"), | 1145 | i++; |
1142 | sctx->service_name, | ||
1143 | GNUNET_a2s(sctx->addrs[i], sctx->addrlens[i])); | ||
1144 | i++; | ||
1145 | } | ||
1146 | } | 1146 | } |
1147 | sctx->task(sctx->task_cls, sctx->server, sctx->cfg); | 1147 | } |
1148 | sctx->task (sctx->task_cls, sctx->server, sctx->cfg); | ||
1148 | } | 1149 | } |
1149 | 1150 | ||
1150 | 1151 | ||
@@ -1155,73 +1156,73 @@ service_task(void *cls) | |||
1155 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1156 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1156 | */ | 1157 | */ |
1157 | static int | 1158 | static int |
1158 | detach_terminal(struct LEGACY_SERVICE_Context *sctx) | 1159 | detach_terminal (struct LEGACY_SERVICE_Context *sctx) |
1159 | { | 1160 | { |
1160 | pid_t pid; | 1161 | pid_t pid; |
1161 | int nullfd; | 1162 | int nullfd; |
1162 | int filedes[2]; | 1163 | int filedes[2]; |
1163 | 1164 | ||
1164 | if (0 != pipe(filedes)) | 1165 | if (0 != pipe (filedes)) |
1165 | { | 1166 | { |
1166 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "pipe"); | 1167 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "pipe"); |
1167 | return GNUNET_SYSERR; | 1168 | return GNUNET_SYSERR; |
1168 | } | 1169 | } |
1169 | pid = fork(); | 1170 | pid = fork (); |
1170 | if (pid < 0) | 1171 | if (pid < 0) |
1171 | { | 1172 | { |
1172 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "fork"); | 1173 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "fork"); |
1173 | return GNUNET_SYSERR; | 1174 | return GNUNET_SYSERR; |
1174 | } | 1175 | } |
1175 | if (0 != pid) | 1176 | if (0 != pid) |
1177 | { | ||
1178 | /* Parent */ | ||
1179 | char c; | ||
1180 | |||
1181 | GNUNET_break (0 == close (filedes[1])); | ||
1182 | c = 'X'; | ||
1183 | if (1 != read (filedes[0], &c, sizeof(char))) | ||
1184 | LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "read"); | ||
1185 | fflush (stdout); | ||
1186 | switch (c) | ||
1176 | { | 1187 | { |
1177 | /* Parent */ | 1188 | case '.': |
1178 | char c; | 1189 | exit (0); |
1179 | 1190 | ||
1180 | GNUNET_break(0 == close(filedes[1])); | 1191 | case 'I': |
1181 | c = 'X'; | 1192 | LOG (GNUNET_ERROR_TYPE_INFO, |
1182 | if (1 != read(filedes[0], &c, sizeof(char))) | 1193 | _ ("Service process failed to initialize\n")); |
1183 | LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "read"); | 1194 | break; |
1184 | fflush(stdout); | 1195 | |
1185 | switch (c) | 1196 | case 'S': |
1186 | { | 1197 | LOG (GNUNET_ERROR_TYPE_INFO, |
1187 | case '.': | 1198 | _ ("Service process could not initialize server function\n")); |
1188 | exit(0); | 1199 | break; |
1189 | 1200 | ||
1190 | case 'I': | 1201 | case 'X': |
1191 | LOG(GNUNET_ERROR_TYPE_INFO, | 1202 | LOG (GNUNET_ERROR_TYPE_INFO, |
1192 | _("Service process failed to initialize\n")); | 1203 | _ ("Service process failed to report status\n")); |
1193 | break; | 1204 | break; |
1194 | |||
1195 | case 'S': | ||
1196 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
1197 | _("Service process could not initialize server function\n")); | ||
1198 | break; | ||
1199 | |||
1200 | case 'X': | ||
1201 | LOG(GNUNET_ERROR_TYPE_INFO, | ||
1202 | _("Service process failed to report status\n")); | ||
1203 | break; | ||
1204 | } | ||
1205 | exit(1); /* child reported error */ | ||
1206 | } | 1205 | } |
1207 | GNUNET_break(0 == close(0)); | 1206 | exit (1); /* child reported error */ |
1208 | GNUNET_break(0 == close(1)); | 1207 | } |
1209 | GNUNET_break(0 == close(filedes[0])); | 1208 | GNUNET_break (0 == close (0)); |
1210 | nullfd = open("/dev/null", O_RDWR | O_APPEND); | 1209 | GNUNET_break (0 == close (1)); |
1210 | GNUNET_break (0 == close (filedes[0])); | ||
1211 | nullfd = open ("/dev/null", O_RDWR | O_APPEND); | ||
1211 | if (nullfd < 0) | 1212 | if (nullfd < 0) |
1212 | return GNUNET_SYSERR; | 1213 | return GNUNET_SYSERR; |
1213 | /* set stdin/stdout to /dev/null */ | 1214 | /* set stdin/stdout to /dev/null */ |
1214 | if ((dup2(nullfd, 0) < 0) || (dup2(nullfd, 1) < 0)) | 1215 | if ((dup2 (nullfd, 0) < 0) || (dup2 (nullfd, 1) < 0)) |
1215 | { | 1216 | { |
1216 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "dup2"); | 1217 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "dup2"); |
1217 | (void)close(nullfd); | 1218 | (void) close (nullfd); |
1218 | return GNUNET_SYSERR; | 1219 | return GNUNET_SYSERR; |
1219 | } | 1220 | } |
1220 | (void)close(nullfd); | 1221 | (void) close (nullfd); |
1221 | /* Detach from controlling terminal */ | 1222 | /* Detach from controlling terminal */ |
1222 | pid = setsid(); | 1223 | pid = setsid (); |
1223 | if (-1 == pid) | 1224 | if (-1 == pid) |
1224 | LOG_STRERROR(GNUNET_ERROR_TYPE_ERROR, "setsid"); | 1225 | LOG_STRERROR (GNUNET_ERROR_TYPE_ERROR, "setsid"); |
1225 | sctx->ready_confirm_fd = filedes[1]; | 1226 | sctx->ready_confirm_fd = filedes[1]; |
1226 | 1227 | ||
1227 | return GNUNET_OK; | 1228 | return GNUNET_OK; |
@@ -1235,45 +1236,45 @@ detach_terminal(struct LEGACY_SERVICE_Context *sctx) | |||
1235 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error | 1236 | * @return #GNUNET_OK on success, #GNUNET_SYSERR on error |
1236 | */ | 1237 | */ |
1237 | static int | 1238 | static int |
1238 | set_user_id(struct LEGACY_SERVICE_Context *sctx) | 1239 | set_user_id (struct LEGACY_SERVICE_Context *sctx) |
1239 | { | 1240 | { |
1240 | char *user; | 1241 | char *user; |
1241 | 1242 | ||
1242 | if (NULL == (user = get_user_name(sctx))) | 1243 | if (NULL == (user = get_user_name (sctx))) |
1243 | return GNUNET_OK; /* keep */ | 1244 | return GNUNET_OK; /* keep */ |
1244 | 1245 | ||
1245 | struct passwd *pws; | 1246 | struct passwd *pws; |
1246 | 1247 | ||
1247 | errno = 0; | 1248 | errno = 0; |
1248 | pws = getpwnam(user); | 1249 | pws = getpwnam (user); |
1249 | if (NULL == pws) | 1250 | if (NULL == pws) |
1250 | { | 1251 | { |
1251 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1252 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1252 | _("Cannot obtain information about user `%s': %s\n"), | 1253 | _ ("Cannot obtain information about user `%s': %s\n"), |
1253 | user, | 1254 | user, |
1254 | errno == 0 ? _("No such user") : strerror(errno)); | 1255 | errno == 0 ? _ ("No such user") : strerror (errno)); |
1255 | GNUNET_free(user); | 1256 | GNUNET_free (user); |
1256 | return GNUNET_SYSERR; | 1257 | return GNUNET_SYSERR; |
1257 | } | 1258 | } |
1258 | if ((0 != setgid(pws->pw_gid)) || (0 != setegid(pws->pw_gid)) || | 1259 | if ((0 != setgid (pws->pw_gid)) || (0 != setegid (pws->pw_gid)) || |
1259 | #if HAVE_INITGROUPS | 1260 | #if HAVE_INITGROUPS |
1260 | (0 != initgroups(user, pws->pw_gid)) || | 1261 | (0 != initgroups (user, pws->pw_gid)) || |
1261 | #endif | 1262 | #endif |
1262 | (0 != setuid(pws->pw_uid)) || (0 != seteuid(pws->pw_uid))) | 1263 | (0 != setuid (pws->pw_uid)) || (0 != seteuid (pws->pw_uid))) |
1264 | { | ||
1265 | if ((0 != setregid (pws->pw_gid, pws->pw_gid)) || | ||
1266 | (0 != setreuid (pws->pw_uid, pws->pw_uid))) | ||
1263 | { | 1267 | { |
1264 | if ((0 != setregid(pws->pw_gid, pws->pw_gid)) || | 1268 | LOG (GNUNET_ERROR_TYPE_ERROR, |
1265 | (0 != setreuid(pws->pw_uid, pws->pw_uid))) | 1269 | _ ("Cannot change user/group to `%s': %s\n"), |
1266 | { | 1270 | user, |
1267 | LOG(GNUNET_ERROR_TYPE_ERROR, | 1271 | strerror (errno)); |
1268 | _("Cannot change user/group to `%s': %s\n"), | 1272 | GNUNET_free (user); |
1269 | user, | 1273 | return GNUNET_SYSERR; |
1270 | strerror(errno)); | ||
1271 | GNUNET_free(user); | ||
1272 | return GNUNET_SYSERR; | ||
1273 | } | ||
1274 | } | 1274 | } |
1275 | } | ||
1275 | 1276 | ||
1276 | GNUNET_free(user); | 1277 | GNUNET_free (user); |
1277 | return GNUNET_OK; | 1278 | return GNUNET_OK; |
1278 | } | 1279 | } |
1279 | 1280 | ||
@@ -1284,15 +1285,15 @@ set_user_id(struct LEGACY_SERVICE_Context *sctx) | |||
1284 | * @param sctx service context | 1285 | * @param sctx service context |
1285 | */ | 1286 | */ |
1286 | static void | 1287 | static void |
1287 | pid_file_delete(struct LEGACY_SERVICE_Context *sctx) | 1288 | pid_file_delete (struct LEGACY_SERVICE_Context *sctx) |
1288 | { | 1289 | { |
1289 | char *pif = get_pid_file_name(sctx); | 1290 | char *pif = get_pid_file_name (sctx); |
1290 | 1291 | ||
1291 | if (NULL == pif) | 1292 | if (NULL == pif) |
1292 | return; /* no PID file */ | 1293 | return; /* no PID file */ |
1293 | if (0 != unlink(pif)) | 1294 | if (0 != unlink (pif)) |
1294 | LOG_STRERROR_FILE(GNUNET_ERROR_TYPE_WARNING, "unlink", pif); | 1295 | LOG_STRERROR_FILE (GNUNET_ERROR_TYPE_WARNING, "unlink", pif); |
1295 | GNUNET_free(pif); | 1296 | GNUNET_free (pif); |
1296 | } | 1297 | } |
1297 | 1298 | ||
1298 | 1299 | ||
@@ -1310,19 +1311,19 @@ pid_file_delete(struct LEGACY_SERVICE_Context *sctx) | |||
1310 | * if we shutdown nicely | 1311 | * if we shutdown nicely |
1311 | */ | 1312 | */ |
1312 | int | 1313 | int |
1313 | LEGACY_SERVICE_run(int argc, | 1314 | LEGACY_SERVICE_run (int argc, |
1314 | char *const *argv, | 1315 | char *const *argv, |
1315 | const char *service_name, | 1316 | const char *service_name, |
1316 | enum LEGACY_SERVICE_Options options, | 1317 | enum LEGACY_SERVICE_Options options, |
1317 | LEGACY_SERVICE_Main task, | 1318 | LEGACY_SERVICE_Main task, |
1318 | void *task_cls) | 1319 | void *task_cls) |
1319 | { | 1320 | { |
1320 | #define HANDLE_ERROR \ | 1321 | #define HANDLE_ERROR \ |
1321 | do \ | 1322 | do \ |
1322 | { \ | 1323 | { \ |
1323 | GNUNET_break(0); \ | 1324 | GNUNET_break (0); \ |
1324 | goto shutdown; \ | 1325 | goto shutdown; \ |
1325 | } while (0) | 1326 | } while (0) |
1326 | 1327 | ||
1327 | int err; | 1328 | int err; |
1328 | int ret; | 1329 | int ret; |
@@ -1340,32 +1341,32 @@ LEGACY_SERVICE_run(int argc, | |||
1340 | const char *xdg; | 1341 | const char *xdg; |
1341 | 1342 | ||
1342 | struct GNUNET_GETOPT_CommandLineOption service_options[] = | 1343 | struct GNUNET_GETOPT_CommandLineOption service_options[] = |
1343 | { GNUNET_GETOPT_option_cfgfile(&opt_cfg_fn), | 1344 | { GNUNET_GETOPT_option_cfgfile (&opt_cfg_fn), |
1344 | GNUNET_GETOPT_option_flag('d', | 1345 | GNUNET_GETOPT_option_flag ('d', |
1345 | "daemonize", | 1346 | "daemonize", |
1346 | gettext_noop( | 1347 | gettext_noop ( |
1347 | "do daemonize (detach from terminal)"), | 1348 | "do daemonize (detach from terminal)"), |
1348 | &do_daemonize), | 1349 | &do_daemonize), |
1349 | GNUNET_GETOPT_option_help(NULL), | 1350 | GNUNET_GETOPT_option_help (NULL), |
1350 | GNUNET_GETOPT_option_loglevel(&loglev), | 1351 | GNUNET_GETOPT_option_loglevel (&loglev), |
1351 | GNUNET_GETOPT_option_logfile(&logfile), | 1352 | GNUNET_GETOPT_option_logfile (&logfile), |
1352 | GNUNET_GETOPT_option_version(PACKAGE_VERSION " " VCS_VERSION), | 1353 | GNUNET_GETOPT_option_version (PACKAGE_VERSION " " VCS_VERSION), |
1353 | GNUNET_GETOPT_OPTION_END }; | 1354 | GNUNET_GETOPT_OPTION_END }; |
1354 | err = 1; | 1355 | err = 1; |
1355 | do_daemonize = 0; | 1356 | do_daemonize = 0; |
1356 | logfile = NULL; | 1357 | logfile = NULL; |
1357 | loglev = NULL; | 1358 | loglev = NULL; |
1358 | opt_cfg_fn = NULL; | 1359 | opt_cfg_fn = NULL; |
1359 | xdg = getenv("XDG_CONFIG_HOME"); | 1360 | xdg = getenv ("XDG_CONFIG_HOME"); |
1360 | if (NULL != xdg) | 1361 | if (NULL != xdg) |
1361 | GNUNET_asprintf(&cfg_fn, | 1362 | GNUNET_asprintf (&cfg_fn, |
1362 | "%s%s%s", | 1363 | "%s%s%s", |
1363 | xdg, | 1364 | xdg, |
1364 | DIR_SEPARATOR_STR, | 1365 | DIR_SEPARATOR_STR, |
1365 | GNUNET_OS_project_data_get()->config_file); | 1366 | GNUNET_OS_project_data_get ()->config_file); |
1366 | else | 1367 | else |
1367 | cfg_fn = GNUNET_strdup(GNUNET_OS_project_data_get()->user_config_file); | 1368 | cfg_fn = GNUNET_strdup (GNUNET_OS_project_data_get ()->user_config_file); |
1368 | memset(&sctx, 0, sizeof(sctx)); | 1369 | memset (&sctx, 0, sizeof(sctx)); |
1369 | sctx.options = options; | 1370 | sctx.options = options; |
1370 | sctx.ready_confirm_fd = -1; | 1371 | sctx.ready_confirm_fd = -1; |
1371 | sctx.ret = GNUNET_OK; | 1372 | sctx.ret = GNUNET_OK; |
@@ -1373,117 +1374,117 @@ LEGACY_SERVICE_run(int argc, | |||
1373 | sctx.task = task; | 1374 | sctx.task = task; |
1374 | sctx.task_cls = task_cls; | 1375 | sctx.task_cls = task_cls; |
1375 | sctx.service_name = service_name; | 1376 | sctx.service_name = service_name; |
1376 | sctx.cfg = cfg = GNUNET_CONFIGURATION_create(); | 1377 | sctx.cfg = cfg = GNUNET_CONFIGURATION_create (); |
1377 | 1378 | ||
1378 | /* setup subsystems */ | 1379 | /* setup subsystems */ |
1379 | ret = GNUNET_GETOPT_run(service_name, service_options, argc, argv); | 1380 | ret = GNUNET_GETOPT_run (service_name, service_options, argc, argv); |
1380 | if (GNUNET_SYSERR == ret) | 1381 | if (GNUNET_SYSERR == ret) |
1381 | goto shutdown; | 1382 | goto shutdown; |
1382 | if (GNUNET_NO == ret) | 1383 | if (GNUNET_NO == ret) |
1383 | { | 1384 | { |
1384 | err = 0; | 1385 | err = 0; |
1385 | goto shutdown; | 1386 | goto shutdown; |
1386 | } | 1387 | } |
1387 | if (GNUNET_OK != GNUNET_log_setup(service_name, loglev, logfile)) | 1388 | if (GNUNET_OK != GNUNET_log_setup (service_name, loglev, logfile)) |
1388 | HANDLE_ERROR; | 1389 | HANDLE_ERROR; |
1389 | if (NULL == opt_cfg_fn) | 1390 | if (NULL == opt_cfg_fn) |
1390 | opt_cfg_fn = GNUNET_strdup(cfg_fn); | 1391 | opt_cfg_fn = GNUNET_strdup (cfg_fn); |
1391 | if (GNUNET_YES == GNUNET_DISK_file_test(opt_cfg_fn)) | 1392 | if (GNUNET_YES == GNUNET_DISK_file_test (opt_cfg_fn)) |
1393 | { | ||
1394 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, opt_cfg_fn)) | ||
1392 | { | 1395 | { |
1393 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, opt_cfg_fn)) | 1396 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1394 | { | 1397 | _ ("Malformed configuration file `%s', exit ...\n"), |
1395 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1398 | opt_cfg_fn); |
1396 | _("Malformed configuration file `%s', exit ...\n"), | 1399 | goto shutdown; |
1397 | opt_cfg_fn); | ||
1398 | goto shutdown; | ||
1399 | } | ||
1400 | } | 1400 | } |
1401 | } | ||
1401 | else | 1402 | else |
1403 | { | ||
1404 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load (cfg, NULL)) | ||
1402 | { | 1405 | { |
1403 | if (GNUNET_SYSERR == GNUNET_CONFIGURATION_load(cfg, NULL)) | 1406 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, |
1404 | { | 1407 | _ ("Malformed configuration, exit ...\n")); |
1405 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | 1408 | goto shutdown; |
1406 | _("Malformed configuration, exit ...\n")); | ||
1407 | goto shutdown; | ||
1408 | } | ||
1409 | if (0 != strcmp(opt_cfg_fn, cfg_fn)) | ||
1410 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, | ||
1411 | _("Could not access configuration file `%s'\n"), | ||
1412 | opt_cfg_fn); | ||
1413 | } | 1409 | } |
1414 | if (GNUNET_OK != setup_service(&sctx)) | 1410 | if (0 != strcmp (opt_cfg_fn, cfg_fn)) |
1411 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | ||
1412 | _ ("Could not access configuration file `%s'\n"), | ||
1413 | opt_cfg_fn); | ||
1414 | } | ||
1415 | if (GNUNET_OK != setup_service (&sctx)) | ||
1415 | goto shutdown; | 1416 | goto shutdown; |
1416 | if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal(&sctx))) | 1417 | if ((1 == do_daemonize) && (GNUNET_OK != detach_terminal (&sctx))) |
1417 | HANDLE_ERROR; | 1418 | HANDLE_ERROR; |
1418 | if (GNUNET_OK != set_user_id(&sctx)) | 1419 | if (GNUNET_OK != set_user_id (&sctx)) |
1419 | goto shutdown; | 1420 | goto shutdown; |
1420 | LOG(GNUNET_ERROR_TYPE_DEBUG, | 1421 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
1421 | "Service `%s' runs with configuration from `%s'\n", | 1422 | "Service `%s' runs with configuration from `%s'\n", |
1422 | service_name, | 1423 | service_name, |
1423 | opt_cfg_fn); | 1424 | opt_cfg_fn); |
1424 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sctx.cfg, | 1425 | if ((GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sctx.cfg, |
1425 | "TESTING", | 1426 | "TESTING", |
1426 | "SKEW_OFFSET", | 1427 | "SKEW_OFFSET", |
1427 | &skew_offset)) && | 1428 | &skew_offset)) && |
1428 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number(sctx.cfg, | 1429 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_number (sctx.cfg, |
1429 | "TESTING", | 1430 | "TESTING", |
1430 | "SKEW_VARIANCE", | 1431 | "SKEW_VARIANCE", |
1431 | &skew_variance))) | 1432 | &skew_variance))) |
1432 | { | 1433 | { |
1433 | clock_offset = skew_offset - skew_variance; | 1434 | clock_offset = skew_offset - skew_variance; |
1434 | GNUNET_TIME_set_offset(clock_offset); | 1435 | GNUNET_TIME_set_offset (clock_offset); |
1435 | LOG(GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset); | 1436 | LOG (GNUNET_ERROR_TYPE_DEBUG, "Skewing clock by %dll ms\n", clock_offset); |
1436 | } | 1437 | } |
1437 | /* actually run service */ | 1438 | /* actually run service */ |
1438 | err = 0; | 1439 | err = 0; |
1439 | GNUNET_SCHEDULER_run(&service_task, &sctx); | 1440 | GNUNET_SCHEDULER_run (&service_task, &sctx); |
1440 | /* shutdown */ | 1441 | /* shutdown */ |
1441 | if ((1 == do_daemonize) && (NULL != sctx.server)) | 1442 | if ((1 == do_daemonize) && (NULL != sctx.server)) |
1442 | pid_file_delete(&sctx); | 1443 | pid_file_delete (&sctx); |
1443 | GNUNET_free_non_null(sctx.my_handlers); | 1444 | GNUNET_free_non_null (sctx.my_handlers); |
1444 | 1445 | ||
1445 | shutdown: | 1446 | shutdown: |
1446 | if (-1 != sctx.ready_confirm_fd) | 1447 | if (-1 != sctx.ready_confirm_fd) |
1447 | { | 1448 | { |
1448 | if (1 != write(sctx.ready_confirm_fd, err ? "I" : "S", 1)) | 1449 | if (1 != write (sctx.ready_confirm_fd, err ? "I" : "S", 1)) |
1449 | LOG_STRERROR(GNUNET_ERROR_TYPE_WARNING, "write"); | 1450 | LOG_STRERROR (GNUNET_ERROR_TYPE_WARNING, "write"); |
1450 | GNUNET_break(0 == close(sctx.ready_confirm_fd)); | 1451 | GNUNET_break (0 == close (sctx.ready_confirm_fd)); |
1451 | } | 1452 | } |
1452 | #if HAVE_MALLINFO | 1453 | #if HAVE_MALLINFO |
1453 | { | 1454 | { |
1454 | char *counter; | 1455 | char *counter; |
1455 | 1456 | ||
1456 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value(sctx.cfg, | 1457 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (sctx.cfg, |
1457 | service_name, | 1458 | service_name, |
1458 | "GAUGER_HEAP")) && | 1459 | "GAUGER_HEAP")) && |
1459 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(sctx.cfg, | 1460 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (sctx.cfg, |
1460 | service_name, | 1461 | service_name, |
1461 | "GAUGER_HEAP", | 1462 | "GAUGER_HEAP", |
1462 | &counter))) | 1463 | &counter))) |
1463 | { | 1464 | { |
1464 | struct mallinfo mi; | 1465 | struct mallinfo mi; |
1465 | 1466 | ||
1466 | mi = mallinfo(); | 1467 | mi = mallinfo (); |
1467 | GAUGER(service_name, counter, mi.usmblks, "blocks"); | 1468 | GAUGER (service_name, counter, mi.usmblks, "blocks"); |
1468 | GNUNET_free(counter); | 1469 | GNUNET_free (counter); |
1469 | } | 1470 | } |
1470 | } | 1471 | } |
1471 | #endif | 1472 | #endif |
1472 | GNUNET_CONFIGURATION_destroy(cfg); | 1473 | GNUNET_CONFIGURATION_destroy (cfg); |
1473 | i = 0; | 1474 | i = 0; |
1474 | if (NULL != sctx.addrs) | 1475 | if (NULL != sctx.addrs) |
1475 | while (NULL != sctx.addrs[i]) | 1476 | while (NULL != sctx.addrs[i]) |
1476 | GNUNET_free(sctx.addrs[i++]); | 1477 | GNUNET_free (sctx.addrs[i++]); |
1477 | GNUNET_free_non_null(sctx.addrs); | 1478 | GNUNET_free_non_null (sctx.addrs); |
1478 | GNUNET_free_non_null(sctx.addrlens); | 1479 | GNUNET_free_non_null (sctx.addrlens); |
1479 | GNUNET_free_non_null(logfile); | 1480 | GNUNET_free_non_null (logfile); |
1480 | GNUNET_free_non_null(loglev); | 1481 | GNUNET_free_non_null (loglev); |
1481 | GNUNET_free(cfg_fn); | 1482 | GNUNET_free (cfg_fn); |
1482 | GNUNET_free_non_null(opt_cfg_fn); | 1483 | GNUNET_free_non_null (opt_cfg_fn); |
1483 | GNUNET_free_non_null(sctx.v4_denied); | 1484 | GNUNET_free_non_null (sctx.v4_denied); |
1484 | GNUNET_free_non_null(sctx.v6_denied); | 1485 | GNUNET_free_non_null (sctx.v6_denied); |
1485 | GNUNET_free_non_null(sctx.v4_allowed); | 1486 | GNUNET_free_non_null (sctx.v4_allowed); |
1486 | GNUNET_free_non_null(sctx.v6_allowed); | 1487 | GNUNET_free_non_null (sctx.v6_allowed); |
1487 | 1488 | ||
1488 | return err ? GNUNET_SYSERR : sctx.ret; | 1489 | return err ? GNUNET_SYSERR : sctx.ret; |
1489 | } | 1490 | } |
@@ -1499,14 +1500,14 @@ shutdown: | |||
1499 | * @return NULL on error, service handle | 1500 | * @return NULL on error, service handle |
1500 | */ | 1501 | */ |
1501 | struct LEGACY_SERVICE_Context * | 1502 | struct LEGACY_SERVICE_Context * |
1502 | LEGACY_SERVICE_start(const char *service_name, | 1503 | LEGACY_SERVICE_start (const char *service_name, |
1503 | const struct GNUNET_CONFIGURATION_Handle *cfg, | 1504 | const struct GNUNET_CONFIGURATION_Handle *cfg, |
1504 | enum LEGACY_SERVICE_Options options) | 1505 | enum LEGACY_SERVICE_Options options) |
1505 | { | 1506 | { |
1506 | int i; | 1507 | int i; |
1507 | struct LEGACY_SERVICE_Context *sctx; | 1508 | struct LEGACY_SERVICE_Context *sctx; |
1508 | 1509 | ||
1509 | sctx = GNUNET_new(struct LEGACY_SERVICE_Context); | 1510 | sctx = GNUNET_new (struct LEGACY_SERVICE_Context); |
1510 | sctx->ready_confirm_fd = -1; /* no daemonizing */ | 1511 | sctx->ready_confirm_fd = -1; /* no daemonizing */ |
1511 | sctx->ret = GNUNET_OK; | 1512 | sctx->ret = GNUNET_OK; |
1512 | sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL; | 1513 | sctx->timeout = GNUNET_TIME_UNIT_FOREVER_REL; |
@@ -1515,47 +1516,47 @@ LEGACY_SERVICE_start(const char *service_name, | |||
1515 | sctx->options = options; | 1516 | sctx->options = options; |
1516 | 1517 | ||
1517 | /* setup subsystems */ | 1518 | /* setup subsystems */ |
1518 | if (GNUNET_OK != setup_service(sctx)) | 1519 | if (GNUNET_OK != setup_service (sctx)) |
1519 | { | 1520 | { |
1520 | LEGACY_SERVICE_stop(sctx); | 1521 | LEGACY_SERVICE_stop (sctx); |
1521 | return NULL; | 1522 | return NULL; |
1522 | } | 1523 | } |
1523 | if (NULL != sctx->lsocks) | 1524 | if (NULL != sctx->lsocks) |
1524 | sctx->server = GNUNET_SERVER_create_with_sockets(&check_access, | 1525 | sctx->server = GNUNET_SERVER_create_with_sockets (&check_access, |
1525 | sctx, | 1526 | sctx, |
1526 | sctx->lsocks, | 1527 | sctx->lsocks, |
1527 | sctx->timeout, | 1528 | sctx->timeout, |
1528 | sctx->require_found); | 1529 | sctx->require_found); |
1529 | else | 1530 | else |
1530 | sctx->server = GNUNET_SERVER_create(&check_access, | 1531 | sctx->server = GNUNET_SERVER_create (&check_access, |
1531 | sctx, | 1532 | sctx, |
1532 | sctx->addrs, | 1533 | sctx->addrs, |
1533 | sctx->addrlens, | 1534 | sctx->addrlens, |
1534 | sctx->timeout, | 1535 | sctx->timeout, |
1535 | sctx->require_found); | 1536 | sctx->require_found); |
1536 | 1537 | ||
1537 | if (NULL == sctx->server) | 1538 | if (NULL == sctx->server) |
1538 | { | 1539 | { |
1539 | LEGACY_SERVICE_stop(sctx); | 1540 | LEGACY_SERVICE_stop (sctx); |
1540 | return NULL; | 1541 | return NULL; |
1541 | } | 1542 | } |
1542 | 1543 | ||
1543 | if (NULL != sctx->addrs) | 1544 | if (NULL != sctx->addrs) |
1544 | for (i = 0; NULL != sctx->addrs[i]; i++) | 1545 | for (i = 0; NULL != sctx->addrs[i]; i++) |
1545 | if ((AF_UNIX == sctx->addrs[i]->sa_family) && | 1546 | if ((AF_UNIX == sctx->addrs[i]->sa_family) && |
1546 | ('\0' != ((const struct sockaddr_un *)sctx->addrs[i])->sun_path[0])) | 1547 | ('\0' != ((const struct sockaddr_un *) sctx->addrs[i])->sun_path[0])) |
1547 | GNUNET_DISK_fix_permissions(((const struct sockaddr_un *) | 1548 | GNUNET_DISK_fix_permissions (((const struct sockaddr_un *) |
1548 | sctx->addrs[i]) | 1549 | sctx->addrs[i]) |
1549 | ->sun_path, | 1550 | ->sun_path, |
1550 | sctx->match_uid, | 1551 | sctx->match_uid, |
1551 | sctx->match_gid); | 1552 | sctx->match_gid); |
1552 | 1553 | ||
1553 | sctx->my_handlers = GNUNET_malloc(sizeof(defhandlers)); | 1554 | sctx->my_handlers = GNUNET_malloc (sizeof(defhandlers)); |
1554 | GNUNET_memcpy(sctx->my_handlers, defhandlers, sizeof(defhandlers)); | 1555 | GNUNET_memcpy (sctx->my_handlers, defhandlers, sizeof(defhandlers)); |
1555 | i = 0; | 1556 | i = 0; |
1556 | while ((sctx->my_handlers[i].callback != NULL)) | 1557 | while ((sctx->my_handlers[i].callback != NULL)) |
1557 | sctx->my_handlers[i++].callback_cls = sctx; | 1558 | sctx->my_handlers[i++].callback_cls = sctx; |
1558 | GNUNET_SERVER_add_handlers(sctx->server, sctx->my_handlers); | 1559 | GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers); |
1559 | return sctx; | 1560 | return sctx; |
1560 | } | 1561 | } |
1561 | 1562 | ||
@@ -1568,7 +1569,7 @@ LEGACY_SERVICE_start(const char *service_name, | |||
1568 | * @return handle to the server for this service, NULL if there is none | 1569 | * @return handle to the server for this service, NULL if there is none |
1569 | */ | 1570 | */ |
1570 | struct GNUNET_SERVER_Handle * | 1571 | struct GNUNET_SERVER_Handle * |
1571 | LEGACY_SERVICE_get_server(struct LEGACY_SERVICE_Context *ctx) | 1572 | LEGACY_SERVICE_get_server (struct LEGACY_SERVICE_Context *ctx) |
1572 | { | 1573 | { |
1573 | return ctx->server; | 1574 | return ctx->server; |
1574 | } | 1575 | } |
@@ -1582,7 +1583,7 @@ LEGACY_SERVICE_get_server(struct LEGACY_SERVICE_Context *ctx) | |||
1582 | * array of listen sockets. | 1583 | * array of listen sockets. |
1583 | */ | 1584 | */ |
1584 | struct GNUNET_NETWORK_Handle *const * | 1585 | struct GNUNET_NETWORK_Handle *const * |
1585 | LEGACY_SERVICE_get_listen_sockets(struct LEGACY_SERVICE_Context *ctx) | 1586 | LEGACY_SERVICE_get_listen_sockets (struct LEGACY_SERVICE_Context *ctx) |
1586 | { | 1587 | { |
1587 | return ctx->lsocks; | 1588 | return ctx->lsocks; |
1588 | } | 1589 | } |
@@ -1594,7 +1595,7 @@ LEGACY_SERVICE_get_listen_sockets(struct LEGACY_SERVICE_Context *ctx) | |||
1594 | * @param sctx the service context returned from the start function | 1595 | * @param sctx the service context returned from the start function |
1595 | */ | 1596 | */ |
1596 | void | 1597 | void |
1597 | LEGACY_SERVICE_stop(struct LEGACY_SERVICE_Context *sctx) | 1598 | LEGACY_SERVICE_stop (struct LEGACY_SERVICE_Context *sctx) |
1598 | { | 1599 | { |
1599 | unsigned int i; | 1600 | unsigned int i; |
1600 | 1601 | ||
@@ -1602,43 +1603,43 @@ LEGACY_SERVICE_stop(struct LEGACY_SERVICE_Context *sctx) | |||
1602 | { | 1603 | { |
1603 | char *counter; | 1604 | char *counter; |
1604 | 1605 | ||
1605 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value(sctx->cfg, | 1606 | if ((GNUNET_YES == GNUNET_CONFIGURATION_have_value (sctx->cfg, |
1606 | sctx->service_name, | 1607 | sctx->service_name, |
1607 | "GAUGER_HEAP")) && | 1608 | "GAUGER_HEAP")) && |
1608 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string(sctx->cfg, | 1609 | (GNUNET_OK == GNUNET_CONFIGURATION_get_value_string (sctx->cfg, |
1609 | sctx->service_name, | 1610 | sctx->service_name, |
1610 | "GAUGER_HEAP", | 1611 | "GAUGER_HEAP", |
1611 | &counter))) | 1612 | &counter))) |
1612 | { | 1613 | { |
1613 | struct mallinfo mi; | 1614 | struct mallinfo mi; |
1614 | 1615 | ||
1615 | mi = mallinfo(); | 1616 | mi = mallinfo (); |
1616 | GAUGER(sctx->service_name, counter, mi.usmblks, "blocks"); | 1617 | GAUGER (sctx->service_name, counter, mi.usmblks, "blocks"); |
1617 | GNUNET_free(counter); | 1618 | GNUNET_free (counter); |
1618 | } | 1619 | } |
1619 | } | 1620 | } |
1620 | #endif | 1621 | #endif |
1621 | if (NULL != sctx->shutdown_task) | 1622 | if (NULL != sctx->shutdown_task) |
1622 | { | 1623 | { |
1623 | GNUNET_SCHEDULER_cancel(sctx->shutdown_task); | 1624 | GNUNET_SCHEDULER_cancel (sctx->shutdown_task); |
1624 | sctx->shutdown_task = NULL; | 1625 | sctx->shutdown_task = NULL; |
1625 | } | 1626 | } |
1626 | if (NULL != sctx->server) | 1627 | if (NULL != sctx->server) |
1627 | GNUNET_SERVER_destroy(sctx->server); | 1628 | GNUNET_SERVER_destroy (sctx->server); |
1628 | GNUNET_free_non_null(sctx->my_handlers); | 1629 | GNUNET_free_non_null (sctx->my_handlers); |
1629 | if (NULL != sctx->addrs) | 1630 | if (NULL != sctx->addrs) |
1630 | { | 1631 | { |
1631 | i = 0; | 1632 | i = 0; |
1632 | while (NULL != sctx->addrs[i]) | 1633 | while (NULL != sctx->addrs[i]) |
1633 | GNUNET_free(sctx->addrs[i++]); | 1634 | GNUNET_free (sctx->addrs[i++]); |
1634 | GNUNET_free(sctx->addrs); | 1635 | GNUNET_free (sctx->addrs); |
1635 | } | 1636 | } |
1636 | GNUNET_free_non_null(sctx->addrlens); | 1637 | GNUNET_free_non_null (sctx->addrlens); |
1637 | GNUNET_free_non_null(sctx->v4_denied); | 1638 | GNUNET_free_non_null (sctx->v4_denied); |
1638 | GNUNET_free_non_null(sctx->v6_denied); | 1639 | GNUNET_free_non_null (sctx->v6_denied); |
1639 | GNUNET_free_non_null(sctx->v4_allowed); | 1640 | GNUNET_free_non_null (sctx->v4_allowed); |
1640 | GNUNET_free_non_null(sctx->v6_allowed); | 1641 | GNUNET_free_non_null (sctx->v6_allowed); |
1641 | GNUNET_free(sctx); | 1642 | GNUNET_free (sctx); |
1642 | } | 1643 | } |
1643 | 1644 | ||
1644 | 1645 | ||