diff options
author | Christian Grothoff <christian@grothoff.org> | 2009-11-08 21:31:27 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2009-11-08 21:31:27 +0000 |
commit | 024450ec8ac7d00b5c7c830d34ee1843b6c3a753 (patch) | |
tree | f5f8e91f837474ef4bca22f91672a3b14a606787 | |
parent | bb82fb7f4ea781b843f032c6869f98e6fa6fa107 (diff) | |
download | gnunet-024450ec8ac7d00b5c7c830d34ee1843b6c3a753.tar.gz gnunet-024450ec8ac7d00b5c7c830d34ee1843b6c3a753.zip |
indenting
-rw-r--r-- | src/util/client.c | 41 | ||||
-rw-r--r-- | src/util/connection.c | 36 | ||||
-rw-r--r-- | src/util/container_heap.c | 8 | ||||
-rw-r--r-- | src/util/disk.c | 4 | ||||
-rw-r--r-- | src/util/disk.h | 4 | ||||
-rw-r--r-- | src/util/gnunet-service-resolver.c | 2 | ||||
-rw-r--r-- | src/util/perf_crypto_hash.c | 4 | ||||
-rw-r--r-- | src/util/scheduler.c | 125 | ||||
-rw-r--r-- | src/util/server.c | 43 | ||||
-rw-r--r-- | src/util/service.c | 18 | ||||
-rw-r--r-- | src/util/test_bio.c | 528 | ||||
-rw-r--r-- | src/util/test_crypto_rsa.c | 4 | ||||
-rw-r--r-- | src/util/test_scheduler.c | 22 | ||||
-rw-r--r-- | src/util/test_server_with_client.c | 3 | ||||
-rw-r--r-- | src/util/test_service.c | 10 |
15 files changed, 439 insertions, 413 deletions
diff --git a/src/util/client.c b/src/util/client.c index bfeaccc25..4d158ab2f 100644 --- a/src/util/client.c +++ b/src/util/client.c | |||
@@ -344,8 +344,7 @@ GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock) | |||
344 | GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th); | 344 | GNUNET_CLIENT_notify_transmit_ready_cancel (sock->th); |
345 | if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK) | 345 | if (sock->receive_task != GNUNET_SCHEDULER_NO_TASK) |
346 | { | 346 | { |
347 | GNUNET_SCHEDULER_cancel (sock->sched, | 347 | GNUNET_SCHEDULER_cancel (sock->sched, sock->receive_task); |
348 | sock->receive_task); | ||
349 | sock->receive_task = GNUNET_SCHEDULER_NO_TASK; | 348 | sock->receive_task = GNUNET_SCHEDULER_NO_TASK; |
350 | } | 349 | } |
351 | GNUNET_array_grow (sock->received_buf, sock->received_size, 0); | 350 | GNUNET_array_grow (sock->received_buf, sock->received_size, 0); |
@@ -363,8 +362,8 @@ check_complete (struct GNUNET_CLIENT_Connection *conn) | |||
363 | { | 362 | { |
364 | if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) && | 363 | if ((conn->received_pos >= sizeof (struct GNUNET_MessageHeader)) && |
365 | (conn->received_pos >= | 364 | (conn->received_pos >= |
366 | ntohs (((const struct GNUNET_MessageHeader *) conn->received_buf)-> | 365 | ntohs (((const struct GNUNET_MessageHeader *) conn-> |
367 | size))) | 366 | received_buf)->size))) |
368 | conn->msg_complete = GNUNET_YES; | 367 | conn->msg_complete = GNUNET_YES; |
369 | } | 368 | } |
370 | 369 | ||
@@ -399,7 +398,7 @@ receive_helper (void *cls, | |||
399 | /* signal timeout! */ | 398 | /* signal timeout! */ |
400 | if (NULL != (receive_handler = conn->receiver_handler)) | 399 | if (NULL != (receive_handler = conn->receiver_handler)) |
401 | { | 400 | { |
402 | receive_handler_cls = conn->receiver_handler_cls; | 401 | receive_handler_cls = conn->receiver_handler_cls; |
403 | conn->receiver_handler = NULL; | 402 | conn->receiver_handler = NULL; |
404 | receive_handler (receive_handler_cls, NULL); | 403 | receive_handler (receive_handler_cls, NULL); |
405 | } | 404 | } |
@@ -491,15 +490,15 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock, | |||
491 | if (GNUNET_YES == sock->msg_complete) | 490 | if (GNUNET_YES == sock->msg_complete) |
492 | { | 491 | { |
493 | sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched, | 492 | sock->receive_task = GNUNET_SCHEDULER_add_after (sock->sched, |
494 | GNUNET_SCHEDULER_NO_TASK, | 493 | GNUNET_SCHEDULER_NO_TASK, |
495 | &receive_task, sock); | 494 | &receive_task, sock); |
496 | } | 495 | } |
497 | else | 496 | else |
498 | { | 497 | { |
499 | sock->in_receive = GNUNET_YES; | 498 | sock->in_receive = GNUNET_YES; |
500 | GNUNET_CONNECTION_receive (sock->sock, | 499 | GNUNET_CONNECTION_receive (sock->sock, |
501 | GNUNET_SERVER_MAX_MESSAGE_SIZE, | 500 | GNUNET_SERVER_MAX_MESSAGE_SIZE, |
502 | timeout, &receive_helper, sock); | 501 | timeout, &receive_helper, sock); |
503 | } | 502 | } |
504 | } | 503 | } |
505 | 504 | ||
@@ -611,8 +610,7 @@ write_test (void *cls, size_t size, void *buf) | |||
611 | } | 610 | } |
612 | #if DEBUG_CLIENT | 611 | #if DEBUG_CLIENT |
613 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 612 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
614 | "Transmitting `%s' request.\n", | 613 | "Transmitting `%s' request.\n", "TEST"); |
615 | "TEST"); | ||
616 | #endif | 614 | #endif |
617 | msg = (struct GNUNET_MessageHeader *) buf; | 615 | msg = (struct GNUNET_MessageHeader *) buf; |
618 | msg->type = htons (GNUNET_MESSAGE_TYPE_TEST); | 616 | msg->type = htons (GNUNET_MESSAGE_TYPE_TEST); |
@@ -706,11 +704,11 @@ client_delayed_retry (void *cls, | |||
706 | { | 704 | { |
707 | #if DEBUG_CLIENT | 705 | #if DEBUG_CLIENT |
708 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 706 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
709 | "Transmission failed due to shutdown.\n"); | 707 | "Transmission failed due to shutdown.\n"); |
710 | #endif | 708 | #endif |
711 | th->sock->th = NULL; | 709 | th->sock->th = NULL; |
712 | th->notify (th->notify_cls, 0, NULL); | 710 | th->notify (th->notify_cls, 0, NULL); |
713 | GNUNET_free (th); | 711 | GNUNET_free (th); |
714 | return; | 712 | return; |
715 | } | 713 | } |
716 | th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock, | 714 | th->th = GNUNET_CONNECTION_notify_transmit_ready (th->sock->sock, |
@@ -758,9 +756,9 @@ client_notify (void *cls, size_t size, void *buf) | |||
758 | (0 == --th->attempts_left) || (delay.value < 1)) | 756 | (0 == --th->attempts_left) || (delay.value < 1)) |
759 | { | 757 | { |
760 | #if DEBUG_CLIENT | 758 | #if DEBUG_CLIENT |
761 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 759 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
762 | "Transmission failed %u times, giving up.\n", | 760 | "Transmission failed %u times, giving up.\n", |
763 | MAX_ATTEMPTS - th->attempts_left); | 761 | MAX_ATTEMPTS - th->attempts_left); |
764 | #endif | 762 | #endif |
765 | GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL)); | 763 | GNUNET_break (0 == th->notify (th->notify_cls, 0, NULL)); |
766 | GNUNET_free (th); | 764 | GNUNET_free (th); |
@@ -774,13 +772,14 @@ client_notify (void *cls, size_t size, void *buf) | |||
774 | delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS); | 772 | delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS); |
775 | #if DEBUG_CLIENT | 773 | #if DEBUG_CLIENT |
776 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 774 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
777 | "Transmission failed %u times, trying again in %llums.\n", | 775 | "Transmission failed %u times, trying again in %llums.\n", |
778 | MAX_ATTEMPTS - th->attempts_left, | 776 | MAX_ATTEMPTS - th->attempts_left, |
779 | (unsigned long long) delay.value); | 777 | (unsigned long long) delay.value); |
780 | #endif | 778 | #endif |
781 | th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched, | 779 | th->reconnect_task = GNUNET_SCHEDULER_add_delayed (th->sock->sched, |
782 | delay, | 780 | delay, |
783 | &client_delayed_retry, th); | 781 | &client_delayed_retry, |
782 | th); | ||
784 | th->sock->th = th; | 783 | th->sock->th = th; |
785 | return 0; | 784 | return 0; |
786 | } | 785 | } |
diff --git a/src/util/connection.c b/src/util/connection.c index f88a7b5f2..8a7be4045 100644 --- a/src/util/connection.c +++ b/src/util/connection.c | |||
@@ -785,16 +785,14 @@ try_connect_using_address (void *cls, | |||
785 | delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT; | 785 | delay = GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT; |
786 | if (h->nth.notify_ready != NULL) | 786 | if (h->nth.notify_ready != NULL) |
787 | delay = GNUNET_TIME_relative_min (delay, | 787 | delay = GNUNET_TIME_relative_min (delay, |
788 | GNUNET_TIME_absolute_get_remaining (h-> | 788 | GNUNET_TIME_absolute_get_remaining |
789 | nth. | 789 | (h->nth.transmit_timeout)); |
790 | transmit_timeout)); | ||
791 | if (h->receiver != NULL) | 790 | if (h->receiver != NULL) |
792 | delay = GNUNET_TIME_relative_min (delay, | 791 | delay = GNUNET_TIME_relative_min (delay, |
793 | GNUNET_TIME_absolute_get_remaining (h-> | 792 | GNUNET_TIME_absolute_get_remaining |
794 | receive_timeout)); | 793 | (h->receive_timeout)); |
795 | ap->task = | 794 | ap->task = |
796 | GNUNET_SCHEDULER_add_write_net (h->sched, | 795 | GNUNET_SCHEDULER_add_write_net (h->sched, delay, ap->sock, |
797 | delay, ap->sock, | ||
798 | &connect_probe_continuation, ap); | 796 | &connect_probe_continuation, ap); |
799 | } | 797 | } |
800 | 798 | ||
@@ -813,11 +811,12 @@ retry_connect_continuation (void *cls, | |||
813 | 811 | ||
814 | GNUNET_assert (sock->dns_active == NULL); | 812 | GNUNET_assert (sock->dns_active == NULL); |
815 | sock->dns_active = GNUNET_RESOLVER_ip_get (sock->sched, | 813 | sock->dns_active = GNUNET_RESOLVER_ip_get (sock->sched, |
816 | sock->cfg, | 814 | sock->cfg, |
817 | sock->hostname, | 815 | sock->hostname, |
818 | AF_UNSPEC, | 816 | AF_UNSPEC, |
819 | GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT, | 817 | GNUNET_CONNECTION_CONNECT_RETRY_TIMEOUT, |
820 | &try_connect_using_address, sock); | 818 | &try_connect_using_address, |
819 | sock); | ||
821 | } | 820 | } |
822 | 821 | ||
823 | 822 | ||
@@ -1000,8 +999,9 @@ receive_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1000 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 999 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
1001 | "Receive from `%s' encounters error: time out by %llums... (%p)\n", | 1000 | "Receive from `%s' encounters error: time out by %llums... (%p)\n", |
1002 | GNUNET_a2s (sh->addr, sh->addrlen), | 1001 | GNUNET_a2s (sh->addr, sh->addrlen), |
1003 | GNUNET_TIME_absolute_get_duration (sh->receive_timeout). | 1002 | GNUNET_TIME_absolute_get_duration (sh-> |
1004 | value, sh); | 1003 | receive_timeout).value, |
1004 | sh); | ||
1005 | #endif | 1005 | #endif |
1006 | signal_timeout (sh); | 1006 | signal_timeout (sh); |
1007 | return; | 1007 | return; |
@@ -1348,8 +1348,8 @@ transmit_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1348 | GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size); | 1348 | GNUNET_assert (sock->write_buffer_pos <= sock->write_buffer_size); |
1349 | RETRY: | 1349 | RETRY: |
1350 | ret = GNUNET_NETWORK_socket_send (sock->sock, | 1350 | ret = GNUNET_NETWORK_socket_send (sock->sock, |
1351 | &sock->write_buffer[sock-> | 1351 | &sock-> |
1352 | write_buffer_pos], | 1352 | write_buffer[sock->write_buffer_pos], |
1353 | have); | 1353 | have); |
1354 | if (ret == -1) | 1354 | if (ret == -1) |
1355 | { | 1355 | { |
@@ -1446,8 +1446,8 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle | |||
1446 | #endif | 1446 | #endif |
1447 | sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched, | 1447 | sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched, |
1448 | GNUNET_TIME_absolute_get_remaining | 1448 | GNUNET_TIME_absolute_get_remaining |
1449 | (sock->nth. | 1449 | (sock-> |
1450 | transmit_timeout), | 1450 | nth.transmit_timeout), |
1451 | sock->sock, | 1451 | sock->sock, |
1452 | &transmit_ready, | 1452 | &transmit_ready, |
1453 | sock); | 1453 | sock); |
diff --git a/src/util/container_heap.c b/src/util/container_heap.c index 9a2afaebc..cde678257 100644 --- a/src/util/container_heap.c +++ b/src/util/container_heap.c | |||
@@ -392,9 +392,7 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *root) | |||
392 | struct GNUNET_CONTAINER_heap_node *root_node; | 392 | struct GNUNET_CONTAINER_heap_node *root_node; |
393 | struct GNUNET_CONTAINER_heap_node *last; | 393 | struct GNUNET_CONTAINER_heap_node *last; |
394 | 394 | ||
395 | if ( (root == NULL) || | 395 | if ((root == NULL) || (root->size == 0) || (root->root == NULL)) |
396 | (root->size == 0) || | ||
397 | (root->root == NULL) ) | ||
398 | { | 396 | { |
399 | GNUNET_break (0); | 397 | GNUNET_break (0); |
400 | return NULL; | 398 | return NULL; |
@@ -404,7 +402,7 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *root) | |||
404 | ret = root_node->element; | 402 | ret = root_node->element; |
405 | last = getPos (root, root->size); | 403 | last = getPos (root, root->size); |
406 | 404 | ||
407 | if ( (root_node == last) && (root->size == 1)) | 405 | if ((root_node == last) && (root->size == 1)) |
408 | { | 406 | { |
409 | /* We are removing the last node in the heap! */ | 407 | /* We are removing the last node in the heap! */ |
410 | GNUNET_free (last); | 408 | GNUNET_free (last); |
@@ -423,7 +421,7 @@ GNUNET_CONTAINER_heap_remove_root (struct GNUNET_CONTAINER_Heap *root) | |||
423 | root_node->cost = last->cost; | 421 | root_node->cost = last->cost; |
424 | 422 | ||
425 | if (root->traversal_pos == last) | 423 | if (root->traversal_pos == last) |
426 | root->traversal_pos = root->root; | 424 | root->traversal_pos = root->root; |
427 | GNUNET_free (last); | 425 | GNUNET_free (last); |
428 | root->size--; | 426 | root->size--; |
429 | percolateDownHeap (root->root, root); | 427 | percolateDownHeap (root->root, root); |
diff --git a/src/util/disk.c b/src/util/disk.c index 3b3cb9e65..5ced6ad17 100644 --- a/src/util/disk.c +++ b/src/util/disk.c | |||
@@ -857,8 +857,8 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator | |||
857 | return GNUNET_NO; | 857 | return GNUNET_NO; |
858 | } | 858 | } |
859 | GNUNET_SCHEDULER_add_with_priority (iter->sched, | 859 | GNUNET_SCHEDULER_add_with_priority (iter->sched, |
860 | iter->priority, | 860 | iter->priority, |
861 | &directory_iterator_task, iter); | 861 | &directory_iterator_task, iter); |
862 | return GNUNET_YES; | 862 | return GNUNET_YES; |
863 | } | 863 | } |
864 | 864 | ||
diff --git a/src/util/disk.h b/src/util/disk.h index 21c1ab9a1..3d52b9ec8 100644 --- a/src/util/disk.h +++ b/src/util/disk.h | |||
@@ -41,13 +41,13 @@ struct GNUNET_DISK_FileHandle | |||
41 | */ | 41 | */ |
42 | HANDLE h; | 42 | HANDLE h; |
43 | 43 | ||
44 | #else /* */ | 44 | #else /* */ |
45 | /** | 45 | /** |
46 | * File handle on other OSes. | 46 | * File handle on other OSes. |
47 | */ | 47 | */ |
48 | int fd; | 48 | int fd; |
49 | 49 | ||
50 | #endif /* */ | 50 | #endif /* */ |
51 | }; | 51 | }; |
52 | 52 | ||
53 | /** | 53 | /** |
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c index 70f9128cc..b3e40b889 100644 --- a/src/util/gnunet-service-resolver.c +++ b/src/util/gnunet-service-resolver.c | |||
@@ -517,7 +517,7 @@ main (int argc, char *const *argv) | |||
517 | GNUNET_SERVICE_run (argc, | 517 | GNUNET_SERVICE_run (argc, |
518 | argv, | 518 | argv, |
519 | "resolver", GNUNET_SERVICE_OPTION_NONE, | 519 | "resolver", GNUNET_SERVICE_OPTION_NONE, |
520 | &run, NULL)) ? 0 : 1; | 520 | &run, NULL)) ? 0 : 1; |
521 | 521 | ||
522 | while (head != NULL) | 522 | while (head != NULL) |
523 | { | 523 | { |
diff --git a/src/util/perf_crypto_hash.c b/src/util/perf_crypto_hash.c index 6e505b807..82170223f 100644 --- a/src/util/perf_crypto_hash.c +++ b/src/util/perf_crypto_hash.c | |||
@@ -57,8 +57,8 @@ main (int argc, char *argv[]) | |||
57 | start = GNUNET_TIME_absolute_get (); | 57 | start = GNUNET_TIME_absolute_get (); |
58 | perfHash (); | 58 | perfHash (); |
59 | printf ("Hash perf took %llu ms\n", | 59 | printf ("Hash perf took %llu ms\n", |
60 | (unsigned long long) GNUNET_TIME_absolute_get_duration (start). | 60 | (unsigned long long) |
61 | value); | 61 | GNUNET_TIME_absolute_get_duration (start).value); |
62 | return 0; | 62 | return 0; |
63 | } | 63 | } |
64 | 64 | ||
diff --git a/src/util/scheduler.c b/src/util/scheduler.c index ba4c8dbcf..ef9f8841d 100644 --- a/src/util/scheduler.c +++ b/src/util/scheduler.c | |||
@@ -250,7 +250,7 @@ update_sets (struct GNUNET_SCHEDULER_Handle *sched, | |||
250 | if (pos->write_set != NULL) | 250 | if (pos->write_set != NULL) |
251 | GNUNET_NETWORK_fdset_add (ws, pos->write_set); | 251 | GNUNET_NETWORK_fdset_add (ws, pos->write_set); |
252 | if (pos->reason != 0) | 252 | if (pos->reason != 0) |
253 | *timeout = GNUNET_TIME_UNIT_ZERO; | 253 | *timeout = GNUNET_TIME_UNIT_ZERO; |
254 | pos = pos->next; | 254 | pos = pos->next; |
255 | } | 255 | } |
256 | } | 256 | } |
@@ -300,7 +300,7 @@ is_ready (struct GNUNET_SCHEDULER_Handle *sched, | |||
300 | const struct GNUNET_NETWORK_FDSet *rs, | 300 | const struct GNUNET_NETWORK_FDSet *rs, |
301 | const struct GNUNET_NETWORK_FDSet *ws) | 301 | const struct GNUNET_NETWORK_FDSet *ws) |
302 | { | 302 | { |
303 | if (now.value >= task->timeout.value) | 303 | if (now.value >= task->timeout.value) |
304 | task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; | 304 | task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; |
305 | if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && | 305 | if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && |
306 | (rs != NULL) && (set_overlaps (rs, task->read_set))) | 306 | (rs != NULL) && (set_overlaps (rs, task->read_set))) |
@@ -399,8 +399,8 @@ GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched) | |||
399 | { | 399 | { |
400 | pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; | 400 | pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; |
401 | /* we don't move the task into the ready queue yet; check_ready | 401 | /* we don't move the task into the ready queue yet; check_ready |
402 | will do that later, possibly adding additional | 402 | will do that later, possibly adding additional |
403 | readyness-factors */ | 403 | readyness-factors */ |
404 | pos = pos->next; | 404 | pos = pos->next; |
405 | } | 405 | } |
406 | } | 406 | } |
@@ -532,20 +532,20 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls) | |||
532 | GNUNET_assert (sigpipe != NULL); | 532 | GNUNET_assert (sigpipe != NULL); |
533 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); | 533 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); |
534 | GNUNET_assert (pr != NULL); | 534 | GNUNET_assert (pr != NULL); |
535 | shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown); | 535 | shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown); |
536 | shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown); | 536 | shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown); |
537 | shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown); | 537 | shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown); |
538 | shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown); | 538 | shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown); |
539 | #endif | 539 | #endif |
540 | memset (&sched, 0, sizeof (sched)); | 540 | memset (&sched, 0, sizeof (sched)); |
541 | sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; | 541 | sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; |
542 | GNUNET_SCHEDULER_add_continuation (&sched, | 542 | GNUNET_SCHEDULER_add_continuation (&sched, |
543 | task, | 543 | task, |
544 | task_cls, | 544 | task_cls, |
545 | GNUNET_SCHEDULER_REASON_STARTUP); | 545 | GNUNET_SCHEDULER_REASON_STARTUP); |
546 | last_tr = 0; | 546 | last_tr = 0; |
547 | busy_wait_warning = 0; | 547 | busy_wait_warning = 0; |
548 | while ( (sched.pending != NULL) || (sched.ready_count > 0) ) | 548 | while ((sched.pending != NULL) || (sched.ready_count > 0)) |
549 | { | 549 | { |
550 | GNUNET_NETWORK_fdset_zero (rs); | 550 | GNUNET_NETWORK_fdset_zero (rs); |
551 | GNUNET_NETWORK_fdset_zero (ws); | 551 | GNUNET_NETWORK_fdset_zero (ws); |
@@ -567,12 +567,12 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls) | |||
567 | } | 567 | } |
568 | #ifndef MINGW | 568 | #ifndef MINGW |
569 | if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) | 569 | if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) |
570 | { | 570 | { |
571 | /* consume the signal */ | 571 | /* consume the signal */ |
572 | GNUNET_DISK_file_read (pr, &c, sizeof(c)); | 572 | GNUNET_DISK_file_read (pr, &c, sizeof (c)); |
573 | /* mark all active tasks as ready due to shutdown */ | 573 | /* mark all active tasks as ready due to shutdown */ |
574 | GNUNET_SCHEDULER_shutdown (&sched); | 574 | GNUNET_SCHEDULER_shutdown (&sched); |
575 | } | 575 | } |
576 | #endif | 576 | #endif |
577 | if (last_tr == sched.tasks_run) | 577 | if (last_tr == sched.tasks_run) |
578 | { | 578 | { |
@@ -755,11 +755,10 @@ GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched, | |||
755 | GNUNET_SCHEDULER_TaskIdentifier | 755 | GNUNET_SCHEDULER_TaskIdentifier |
756 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, | 756 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, |
757 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | 757 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, |
758 | GNUNET_SCHEDULER_Task task, | 758 | GNUNET_SCHEDULER_Task task, void *task_cls) |
759 | void *task_cls) | ||
760 | { | 759 | { |
761 | return GNUNET_SCHEDULER_add_select (sched, | 760 | return GNUNET_SCHEDULER_add_select (sched, |
762 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 761 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
763 | prerequisite_task, | 762 | prerequisite_task, |
764 | GNUNET_TIME_UNIT_ZERO, | 763 | GNUNET_TIME_UNIT_ZERO, |
765 | NULL, NULL, task, task_cls); | 764 | NULL, NULL, task, task_cls); |
@@ -777,13 +776,13 @@ GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, | |||
777 | * only valid until "task" is started! | 776 | * only valid until "task" is started! |
778 | */ | 777 | */ |
779 | GNUNET_SCHEDULER_TaskIdentifier | 778 | GNUNET_SCHEDULER_TaskIdentifier |
780 | GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched, | 779 | GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle * sched, |
781 | enum GNUNET_SCHEDULER_Priority prio, | 780 | enum GNUNET_SCHEDULER_Priority prio, |
782 | GNUNET_SCHEDULER_Task task, | 781 | GNUNET_SCHEDULER_Task task, |
783 | void *task_cls) | 782 | void *task_cls) |
784 | { | 783 | { |
785 | return GNUNET_SCHEDULER_add_select (sched, | 784 | return GNUNET_SCHEDULER_add_select (sched, |
786 | prio, | 785 | prio, |
787 | GNUNET_SCHEDULER_NO_TASK, | 786 | GNUNET_SCHEDULER_NO_TASK, |
788 | GNUNET_TIME_UNIT_ZERO, | 787 | GNUNET_TIME_UNIT_ZERO, |
789 | NULL, NULL, task, task_cls); | 788 | NULL, NULL, task, task_cls); |
@@ -805,13 +804,12 @@ GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched, | |||
805 | * only valid until "task" is started! | 804 | * only valid until "task" is started! |
806 | */ | 805 | */ |
807 | GNUNET_SCHEDULER_TaskIdentifier | 806 | GNUNET_SCHEDULER_TaskIdentifier |
808 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, | 807 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched, |
809 | struct GNUNET_TIME_Relative delay, | 808 | struct GNUNET_TIME_Relative delay, |
810 | GNUNET_SCHEDULER_Task task, | 809 | GNUNET_SCHEDULER_Task task, void *task_cls) |
811 | void *task_cls) | ||
812 | { | 810 | { |
813 | return GNUNET_SCHEDULER_add_select (sched, | 811 | return GNUNET_SCHEDULER_add_select (sched, |
814 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 812 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
815 | GNUNET_SCHEDULER_NO_TASK, delay, | 813 | GNUNET_SCHEDULER_NO_TASK, delay, |
816 | NULL, NULL, task, task_cls); | 814 | NULL, NULL, task, task_cls); |
817 | } | 815 | } |
@@ -835,11 +833,10 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, | |||
835 | * only valid until "task" is started! | 833 | * only valid until "task" is started! |
836 | */ | 834 | */ |
837 | GNUNET_SCHEDULER_TaskIdentifier | 835 | GNUNET_SCHEDULER_TaskIdentifier |
838 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, | 836 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched, |
839 | struct GNUNET_TIME_Relative delay, | 837 | struct GNUNET_TIME_Relative delay, |
840 | struct GNUNET_NETWORK_Handle *rfd, | 838 | struct GNUNET_NETWORK_Handle * rfd, |
841 | GNUNET_SCHEDULER_Task task, | 839 | GNUNET_SCHEDULER_Task task, void *task_cls) |
842 | void *task_cls) | ||
843 | { | 840 | { |
844 | struct GNUNET_NETWORK_FDSet *rs; | 841 | struct GNUNET_NETWORK_FDSet *rs; |
845 | GNUNET_SCHEDULER_TaskIdentifier ret; | 842 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -847,11 +844,10 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
847 | GNUNET_assert (rfd != NULL); | 844 | GNUNET_assert (rfd != NULL); |
848 | rs = GNUNET_NETWORK_fdset_create (); | 845 | rs = GNUNET_NETWORK_fdset_create (); |
849 | GNUNET_NETWORK_fdset_set (rs, rfd); | 846 | GNUNET_NETWORK_fdset_set (rs, rfd); |
850 | ret = GNUNET_SCHEDULER_add_select (sched, | 847 | ret = GNUNET_SCHEDULER_add_select (sched, |
851 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 848 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
852 | GNUNET_SCHEDULER_NO_TASK, | 849 | GNUNET_SCHEDULER_NO_TASK, |
853 | delay, | 850 | delay, rs, NULL, task, task_cls); |
854 | rs, NULL, task, task_cls); | ||
855 | GNUNET_NETWORK_fdset_destroy (rs); | 851 | GNUNET_NETWORK_fdset_destroy (rs); |
856 | return ret; | 852 | return ret; |
857 | } | 853 | } |
@@ -875,11 +871,10 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
875 | * only valid until "task" is started! | 871 | * only valid until "task" is started! |
876 | */ | 872 | */ |
877 | GNUNET_SCHEDULER_TaskIdentifier | 873 | GNUNET_SCHEDULER_TaskIdentifier |
878 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, | 874 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched, |
879 | struct GNUNET_TIME_Relative delay, | 875 | struct GNUNET_TIME_Relative delay, |
880 | struct GNUNET_NETWORK_Handle *wfd, | 876 | struct GNUNET_NETWORK_Handle * wfd, |
881 | GNUNET_SCHEDULER_Task task, | 877 | GNUNET_SCHEDULER_Task task, void *task_cls) |
882 | void *task_cls) | ||
883 | { | 878 | { |
884 | struct GNUNET_NETWORK_FDSet *ws; | 879 | struct GNUNET_NETWORK_FDSet *ws; |
885 | GNUNET_SCHEDULER_TaskIdentifier ret; | 880 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -887,8 +882,8 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
887 | GNUNET_assert (wfd != NULL); | 882 | GNUNET_assert (wfd != NULL); |
888 | ws = GNUNET_NETWORK_fdset_create (); | 883 | ws = GNUNET_NETWORK_fdset_create (); |
889 | GNUNET_NETWORK_fdset_set (ws, wfd); | 884 | GNUNET_NETWORK_fdset_set (ws, wfd); |
890 | ret = GNUNET_SCHEDULER_add_select (sched, | 885 | ret = GNUNET_SCHEDULER_add_select (sched, |
891 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 886 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
892 | GNUNET_SCHEDULER_NO_TASK, delay, | 887 | GNUNET_SCHEDULER_NO_TASK, delay, |
893 | NULL, ws, task, task_cls); | 888 | NULL, ws, task, task_cls); |
894 | GNUNET_NETWORK_fdset_destroy (ws); | 889 | GNUNET_NETWORK_fdset_destroy (ws); |
@@ -914,11 +909,10 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
914 | * only valid until "task" is started! | 909 | * only valid until "task" is started! |
915 | */ | 910 | */ |
916 | GNUNET_SCHEDULER_TaskIdentifier | 911 | GNUNET_SCHEDULER_TaskIdentifier |
917 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | 912 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched, |
918 | struct GNUNET_TIME_Relative delay, | 913 | struct GNUNET_TIME_Relative delay, |
919 | const struct GNUNET_DISK_FileHandle *rfd, | 914 | const struct GNUNET_DISK_FileHandle * rfd, |
920 | GNUNET_SCHEDULER_Task task, | 915 | GNUNET_SCHEDULER_Task task, void *task_cls) |
921 | void *task_cls) | ||
922 | { | 916 | { |
923 | struct GNUNET_NETWORK_FDSet *rs; | 917 | struct GNUNET_NETWORK_FDSet *rs; |
924 | GNUNET_SCHEDULER_TaskIdentifier ret; | 918 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -927,8 +921,8 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
927 | rs = GNUNET_NETWORK_fdset_create (); | 921 | rs = GNUNET_NETWORK_fdset_create (); |
928 | GNUNET_NETWORK_fdset_handle_set (rs, rfd); | 922 | GNUNET_NETWORK_fdset_handle_set (rs, rfd); |
929 | ret = GNUNET_SCHEDULER_add_select (sched, | 923 | ret = GNUNET_SCHEDULER_add_select (sched, |
930 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 924 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
931 | GNUNET_SCHEDULER_NO_TASK, delay, | 925 | GNUNET_SCHEDULER_NO_TASK, delay, |
932 | rs, NULL, task, task_cls); | 926 | rs, NULL, task, task_cls); |
933 | GNUNET_NETWORK_fdset_destroy (rs); | 927 | GNUNET_NETWORK_fdset_destroy (rs); |
934 | return ret; | 928 | return ret; |
@@ -953,11 +947,10 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
953 | * only valid until "task" is started! | 947 | * only valid until "task" is started! |
954 | */ | 948 | */ |
955 | GNUNET_SCHEDULER_TaskIdentifier | 949 | GNUNET_SCHEDULER_TaskIdentifier |
956 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | 950 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched, |
957 | struct GNUNET_TIME_Relative delay, | 951 | struct GNUNET_TIME_Relative delay, |
958 | const struct GNUNET_DISK_FileHandle *wfd, | 952 | const struct GNUNET_DISK_FileHandle * wfd, |
959 | GNUNET_SCHEDULER_Task task, | 953 | GNUNET_SCHEDULER_Task task, void *task_cls) |
960 | void *task_cls) | ||
961 | { | 954 | { |
962 | struct GNUNET_NETWORK_FDSet *ws; | 955 | struct GNUNET_NETWORK_FDSet *ws; |
963 | GNUNET_SCHEDULER_TaskIdentifier ret; | 956 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -965,11 +958,10 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
965 | GNUNET_assert (wfd != NULL); | 958 | GNUNET_assert (wfd != NULL); |
966 | ws = GNUNET_NETWORK_fdset_create (); | 959 | ws = GNUNET_NETWORK_fdset_create (); |
967 | GNUNET_NETWORK_fdset_handle_set (ws, wfd); | 960 | GNUNET_NETWORK_fdset_handle_set (ws, wfd); |
968 | ret = GNUNET_SCHEDULER_add_select (sched, | 961 | ret = GNUNET_SCHEDULER_add_select (sched, |
969 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 962 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
970 | GNUNET_SCHEDULER_NO_TASK, | 963 | GNUNET_SCHEDULER_NO_TASK, |
971 | delay, | 964 | delay, NULL, ws, task, task_cls); |
972 | NULL, ws, task, task_cls); | ||
973 | GNUNET_NETWORK_fdset_destroy (ws); | 965 | GNUNET_NETWORK_fdset_destroy (ws); |
974 | return ret; | 966 | return ret; |
975 | } | 967 | } |
@@ -1010,15 +1002,14 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
1010 | * only valid until "task" is started! | 1002 | * only valid until "task" is started! |
1011 | */ | 1003 | */ |
1012 | GNUNET_SCHEDULER_TaskIdentifier | 1004 | GNUNET_SCHEDULER_TaskIdentifier |
1013 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched, | 1005 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched, |
1014 | enum GNUNET_SCHEDULER_Priority prio, | 1006 | enum GNUNET_SCHEDULER_Priority prio, |
1015 | GNUNET_SCHEDULER_TaskIdentifier | 1007 | GNUNET_SCHEDULER_TaskIdentifier |
1016 | prerequisite_task, | 1008 | prerequisite_task, |
1017 | struct GNUNET_TIME_Relative delay, | 1009 | struct GNUNET_TIME_Relative delay, |
1018 | const struct GNUNET_NETWORK_FDSet * rs, | 1010 | const struct GNUNET_NETWORK_FDSet * rs, |
1019 | const struct GNUNET_NETWORK_FDSet * ws, | 1011 | const struct GNUNET_NETWORK_FDSet * ws, |
1020 | GNUNET_SCHEDULER_Task task, | 1012 | GNUNET_SCHEDULER_Task task, void *task_cls) |
1021 | void *task_cls) | ||
1022 | { | 1013 | { |
1023 | struct Task *t; | 1014 | struct Task *t; |
1024 | 1015 | ||
diff --git a/src/util/server.c b/src/util/server.c index d761f6a92..de81a08ea 100644 --- a/src/util/server.c +++ b/src/util/server.c | |||
@@ -275,16 +275,17 @@ process_listen_socket (void *cls, | |||
275 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | 275 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) |
276 | { | 276 | { |
277 | server->listen_task = GNUNET_SCHEDULER_add_select (server->sched, | 277 | server->listen_task = GNUNET_SCHEDULER_add_select (server->sched, |
278 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 278 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
279 | GNUNET_SCHEDULER_NO_TASK, | 279 | GNUNET_SCHEDULER_NO_TASK, |
280 | GNUNET_TIME_UNIT_FOREVER_REL, | 280 | GNUNET_TIME_UNIT_FOREVER_REL, |
281 | r, NULL, &process_listen_socket, | 281 | r, NULL, |
282 | server); | 282 | &process_listen_socket, |
283 | server); | ||
283 | GNUNET_NETWORK_fdset_destroy (r); | 284 | GNUNET_NETWORK_fdset_destroy (r); |
284 | return; /* ignore shutdown, someone else will take care of it! */ | 285 | return; /* ignore shutdown, someone else will take care of it! */ |
285 | } | 286 | } |
286 | GNUNET_assert (GNUNET_NETWORK_fdset_isset | 287 | GNUNET_assert (GNUNET_NETWORK_fdset_isset |
287 | (tc->read_ready, server->listen_socket)); | 288 | (tc->read_ready, server->listen_socket)); |
288 | sock = | 289 | sock = |
289 | GNUNET_CONNECTION_create_from_accept (tc->sched, server->access, | 290 | GNUNET_CONNECTION_create_from_accept (tc->sched, server->access, |
290 | server->access_cls, | 291 | server->access_cls, |
@@ -302,10 +303,12 @@ process_listen_socket (void *cls, | |||
302 | } | 303 | } |
303 | /* listen for more! */ | 304 | /* listen for more! */ |
304 | server->listen_task = GNUNET_SCHEDULER_add_select (server->sched, | 305 | server->listen_task = GNUNET_SCHEDULER_add_select (server->sched, |
305 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 306 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
306 | GNUNET_SCHEDULER_NO_TASK, | 307 | GNUNET_SCHEDULER_NO_TASK, |
307 | GNUNET_TIME_UNIT_FOREVER_REL, | 308 | GNUNET_TIME_UNIT_FOREVER_REL, |
308 | r, NULL, &process_listen_socket, server); | 309 | r, NULL, |
310 | &process_listen_socket, | ||
311 | server); | ||
309 | GNUNET_NETWORK_fdset_destroy (r); | 312 | GNUNET_NETWORK_fdset_destroy (r); |
310 | } | 313 | } |
311 | 314 | ||
@@ -418,11 +421,13 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched, | |||
418 | { | 421 | { |
419 | r = GNUNET_NETWORK_fdset_create (); | 422 | r = GNUNET_NETWORK_fdset_create (); |
420 | GNUNET_NETWORK_fdset_set (r, ret->listen_socket); | 423 | GNUNET_NETWORK_fdset_set (r, ret->listen_socket); |
421 | ret->listen_task = GNUNET_SCHEDULER_add_select (sched, | 424 | ret->listen_task = GNUNET_SCHEDULER_add_select (sched, |
422 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 425 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
423 | GNUNET_SCHEDULER_NO_TASK, | 426 | GNUNET_SCHEDULER_NO_TASK, |
424 | GNUNET_TIME_UNIT_FOREVER_REL, r, NULL, | 427 | GNUNET_TIME_UNIT_FOREVER_REL, |
425 | &process_listen_socket, ret); | 428 | r, NULL, |
429 | &process_listen_socket, | ||
430 | ret); | ||
426 | GNUNET_NETWORK_fdset_destroy (r); | 431 | GNUNET_NETWORK_fdset_destroy (r); |
427 | } | 432 | } |
428 | return ret; | 433 | return ret; |
@@ -444,12 +449,10 @@ GNUNET_SERVER_destroy (struct GNUNET_SERVER_Handle *s) | |||
444 | #endif | 449 | #endif |
445 | if (GNUNET_SCHEDULER_NO_TASK != s->listen_task) | 450 | if (GNUNET_SCHEDULER_NO_TASK != s->listen_task) |
446 | { | 451 | { |
447 | GNUNET_SCHEDULER_cancel (s->sched, | 452 | GNUNET_SCHEDULER_cancel (s->sched, s->listen_task); |
448 | s->listen_task); | ||
449 | s->listen_task = GNUNET_SCHEDULER_NO_TASK; | 453 | s->listen_task = GNUNET_SCHEDULER_NO_TASK; |
450 | } | 454 | } |
451 | GNUNET_break (GNUNET_OK == | 455 | GNUNET_break (GNUNET_OK == GNUNET_NETWORK_socket_close (s->listen_socket)); |
452 | GNUNET_NETWORK_socket_close (s->listen_socket)); | ||
453 | s->listen_socket = NULL; | 456 | s->listen_socket = NULL; |
454 | while (s->clients != NULL) | 457 | while (s->clients != NULL) |
455 | { | 458 | { |
diff --git a/src/util/service.c b/src/util/service.c index 60da8788f..2c84e91f4 100644 --- a/src/util/service.c +++ b/src/util/service.c | |||
@@ -799,8 +799,7 @@ setup_service (struct GNUNET_SERVICE_Context *sctx) | |||
799 | { | 799 | { |
800 | if (GNUNET_SYSERR == | 800 | if (GNUNET_SYSERR == |
801 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, | 801 | (disablev6 = GNUNET_CONFIGURATION_get_value_yesno (sctx->cfg, |
802 | sctx-> | 802 | sctx->serviceName, |
803 | serviceName, | ||
804 | "DISABLEV6"))) | 803 | "DISABLEV6"))) |
805 | return GNUNET_SYSERR; | 804 | return GNUNET_SYSERR; |
806 | } | 805 | } |
@@ -1079,8 +1078,7 @@ write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid) | |||
1079 | * @param tc unused | 1078 | * @param tc unused |
1080 | */ | 1079 | */ |
1081 | static void | 1080 | static void |
1082 | shutdown_task (void *cls, | 1081 | shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
1083 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
1084 | { | 1082 | { |
1085 | struct GNUNET_SERVER_Handle *server = cls; | 1083 | struct GNUNET_SERVER_Handle *server = cls; |
1086 | 1084 | ||
@@ -1116,11 +1114,10 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1116 | if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN)) | 1114 | if (0 == (sctx->options & GNUNET_SERVICE_OPTION_MANUAL_SHUTDOWN)) |
1117 | { | 1115 | { |
1118 | /* install a task that will kill the server | 1116 | /* install a task that will kill the server |
1119 | process if the scheduler ever gets a shutdown signal */ | 1117 | process if the scheduler ever gets a shutdown signal */ |
1120 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 1118 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
1121 | GNUNET_TIME_UNIT_FOREVER_REL, | 1119 | GNUNET_TIME_UNIT_FOREVER_REL, |
1122 | &shutdown_task, | 1120 | &shutdown_task, sctx->server); |
1123 | sctx->server); | ||
1124 | } | 1121 | } |
1125 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); | 1122 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); |
1126 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); | 1123 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); |
@@ -1297,9 +1294,8 @@ int | |||
1297 | GNUNET_SERVICE_run (int argc, | 1294 | GNUNET_SERVICE_run (int argc, |
1298 | char *const *argv, | 1295 | char *const *argv, |
1299 | const char *serviceName, | 1296 | const char *serviceName, |
1300 | enum GNUNET_SERVICE_Options opt, | 1297 | enum GNUNET_SERVICE_Options opt, |
1301 | GNUNET_SERVICE_Main task, | 1298 | GNUNET_SERVICE_Main task, void *task_cls) |
1302 | void *task_cls) | ||
1303 | { | 1299 | { |
1304 | char *cfg_fn; | 1300 | char *cfg_fn; |
1305 | char *loglev; | 1301 | char *loglev; |
diff --git a/src/util/test_bio.c b/src/util/test_bio.c index 883424207..06dcfacc8 100644 --- a/src/util/test_bio.c +++ b/src/util/test_bio.c | |||
@@ -31,282 +31,326 @@ | |||
31 | #define TESTNUMBER64 100000L | 31 | #define TESTNUMBER64 100000L |
32 | 32 | ||
33 | static int | 33 | static int |
34 | test_normal_rw(void){ | 34 | test_normal_rw (void) |
35 | char *msg; | 35 | { |
36 | int64_t testNum; | 36 | char *msg; |
37 | char *readResultString; | 37 | int64_t testNum; |
38 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 38 | char *readResultString; |
39 | struct GNUNET_BIO_WriteHandle *fileW; | 39 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
40 | struct GNUNET_BIO_ReadHandle *fileR; | 40 | struct GNUNET_BIO_WriteHandle *fileW; |
41 | struct GNUNET_CONTAINER_MetaData *metaDataW; | 41 | struct GNUNET_BIO_ReadHandle *fileR; |
42 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 42 | struct GNUNET_CONTAINER_MetaData *metaDataW; |
43 | metaDataW = GNUNET_CONTAINER_meta_data_create (); | 43 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
44 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 44 | metaDataW = GNUNET_CONTAINER_meta_data_create (); |
45 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | 45 | metaDataR = GNUNET_CONTAINER_meta_data_create (); |
46 | 46 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | |
47 | fileW = GNUNET_BIO_write_open (fileName); | 47 | |
48 | GNUNET_assert (NULL != fileW); | 48 | fileW = GNUNET_BIO_write_open (fileName); |
49 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); | 49 | GNUNET_assert (NULL != fileW); |
50 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); | 50 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); |
51 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int64 (fileW, (int64_t)TESTNUMBER64)); | 51 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); |
52 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 52 | GNUNET_assert (GNUNET_OK == |
53 | 53 | GNUNET_BIO_write_int64 (fileW, (int64_t) TESTNUMBER64)); | |
54 | fileR = GNUNET_BIO_read_open (fileName); | 54 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
55 | GNUNET_assert (NULL != fileR); | 55 | |
56 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | 56 | fileR = GNUNET_BIO_read_open (fileName); |
57 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); | 57 | GNUNET_assert (NULL != fileR); |
58 | GNUNET_assert (GNUNET_YES == GNUNET_CONTAINER_meta_data_test_equal (metaDataR, metaDataW)); | 58 | GNUNET_assert (GNUNET_OK == |
59 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); | 59 | GNUNET_BIO_read_string (fileR, "Read string error", |
60 | GNUNET_BIO_read_close (fileR, &msg); | 60 | &readResultString, 200)); |
61 | GNUNET_CONTAINER_meta_data_destroy (metaDataW); | 61 | GNUNET_assert (GNUNET_OK == |
62 | GNUNET_CONTAINER_meta_data_destroy (metaDataR); | 62 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", |
63 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 63 | &metaDataR)); |
64 | GNUNET_free (fileName); | 64 | GNUNET_assert (GNUNET_YES == |
65 | return 0; | 65 | GNUNET_CONTAINER_meta_data_test_equal (metaDataR, |
66 | metaDataW)); | ||
67 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_int64 (fileR, &testNum)); | ||
68 | GNUNET_BIO_read_close (fileR, &msg); | ||
69 | GNUNET_CONTAINER_meta_data_destroy (metaDataW); | ||
70 | GNUNET_CONTAINER_meta_data_destroy (metaDataR); | ||
71 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
72 | GNUNET_free (fileName); | ||
73 | return 0; | ||
66 | } | 74 | } |
67 | 75 | ||
68 | static int | 76 | static int |
69 | test_nullstring_rw(){ | 77 | test_nullstring_rw () |
70 | char *msg; | 78 | { |
71 | char *readResultString = (char*) "not null"; | 79 | char *msg; |
72 | struct GNUNET_BIO_WriteHandle *fileW; | 80 | char *readResultString = (char *) "not null"; |
73 | struct GNUNET_BIO_ReadHandle *fileR; | 81 | struct GNUNET_BIO_WriteHandle *fileW; |
74 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 82 | struct GNUNET_BIO_ReadHandle *fileR; |
75 | 83 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | |
76 | fileW = GNUNET_BIO_write_open (fileName); | 84 | |
77 | GNUNET_assert (NULL != fileW); | 85 | fileW = GNUNET_BIO_write_open (fileName); |
78 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL)); | 86 | GNUNET_assert (NULL != fileW); |
79 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 87 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, NULL)); |
80 | 88 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
81 | fileR = GNUNET_BIO_read_open (fileName); | 89 | |
82 | GNUNET_assert (NULL != fileR); | 90 | fileR = GNUNET_BIO_read_open (fileName); |
83 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | 91 | GNUNET_assert (NULL != fileR); |
84 | GNUNET_assert (NULL == readResultString); | 92 | GNUNET_assert (GNUNET_OK == |
85 | GNUNET_BIO_read_close (fileR, &msg); | 93 | GNUNET_BIO_read_string (fileR, "Read string error", |
86 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 94 | &readResultString, 200)); |
87 | GNUNET_free (fileName); | 95 | GNUNET_assert (NULL == readResultString); |
88 | 96 | GNUNET_BIO_read_close (fileR, &msg); | |
89 | return 0; | 97 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); |
98 | GNUNET_free (fileName); | ||
99 | |||
100 | return 0; | ||
90 | } | 101 | } |
91 | 102 | ||
92 | static int | 103 | static int |
93 | test_emptystring_rw(void){ | 104 | test_emptystring_rw (void) |
94 | char *msg; | 105 | { |
95 | char *readResultString; | 106 | char *msg; |
96 | struct GNUNET_BIO_WriteHandle *fileW; | 107 | char *readResultString; |
97 | struct GNUNET_BIO_ReadHandle *fileR; | 108 | struct GNUNET_BIO_WriteHandle *fileW; |
98 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 109 | struct GNUNET_BIO_ReadHandle *fileR; |
99 | 110 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | |
100 | fileW = GNUNET_BIO_write_open (fileName); | 111 | |
101 | GNUNET_assert (NULL != fileW); | 112 | fileW = GNUNET_BIO_write_open (fileName); |
102 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, "")); | 113 | GNUNET_assert (NULL != fileW); |
103 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 114 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, "")); |
104 | 115 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
105 | fileR = GNUNET_BIO_read_open (fileName); | 116 | |
106 | GNUNET_assert (NULL != fileR); | 117 | fileR = GNUNET_BIO_read_open (fileName); |
107 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | 118 | GNUNET_assert (NULL != fileR); |
108 | GNUNET_BIO_read_close (fileR, &msg); | 119 | GNUNET_assert (GNUNET_OK == |
109 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 120 | GNUNET_BIO_read_string (fileR, "Read string error", |
110 | GNUNET_free (fileName); | 121 | &readResultString, 200)); |
111 | return 0; | 122 | GNUNET_BIO_read_close (fileR, &msg); |
123 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
124 | GNUNET_free (fileName); | ||
125 | return 0; | ||
112 | } | 126 | } |
113 | 127 | ||
114 | static int | 128 | static int |
115 | test_bigstring_rw(void){ | 129 | test_bigstring_rw (void) |
116 | char *msg; | 130 | { |
117 | char *readResultString; | 131 | char *msg; |
118 | struct GNUNET_BIO_WriteHandle *fileW; | 132 | char *readResultString; |
119 | struct GNUNET_BIO_ReadHandle *fileR; | 133 | struct GNUNET_BIO_WriteHandle *fileW; |
120 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 134 | struct GNUNET_BIO_ReadHandle *fileR; |
121 | 135 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | |
122 | fileW = GNUNET_BIO_write_open (fileName); | 136 | |
123 | GNUNET_assert (NULL != fileW); | 137 | fileW = GNUNET_BIO_write_open (fileName); |
124 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); | 138 | GNUNET_assert (NULL != fileW); |
125 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 139 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_string (fileW, TESTSTRING)); |
126 | 140 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
127 | fileR = GNUNET_BIO_read_open (fileName); | 141 | |
128 | GNUNET_assert (NULL != fileR); | 142 | fileR = GNUNET_BIO_read_open (fileName); |
129 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 1)); | 143 | GNUNET_assert (NULL != fileR); |
130 | GNUNET_BIO_read_close (fileR, &msg); | 144 | GNUNET_assert (GNUNET_SYSERR == |
131 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 145 | GNUNET_BIO_read_string (fileR, "Read string error", |
132 | GNUNET_free (fileName); | 146 | &readResultString, 1)); |
133 | return 0; | 147 | GNUNET_BIO_read_close (fileR, &msg); |
148 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
149 | GNUNET_free (fileName); | ||
150 | return 0; | ||
134 | } | 151 | } |
135 | 152 | ||
136 | static int | 153 | static int |
137 | test_bigmeta_rw(){ | 154 | test_bigmeta_rw () |
138 | char *msg; | 155 | { |
139 | static char meta[1024 * 1024 * 10]; | 156 | char *msg; |
140 | memset(meta,'b',sizeof(meta)); | 157 | static char meta[1024 * 1024 * 10]; |
141 | meta[sizeof(meta)-1]='\0'; | 158 | memset (meta, 'b', sizeof (meta)); |
142 | struct GNUNET_BIO_WriteHandle *fileW; | 159 | meta[sizeof (meta) - 1] = '\0'; |
143 | struct GNUNET_BIO_ReadHandle *fileR; | 160 | struct GNUNET_BIO_WriteHandle *fileW; |
144 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 161 | struct GNUNET_BIO_ReadHandle *fileR; |
145 | struct GNUNET_CONTAINER_MetaData *metaDataW; | 162 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
146 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 163 | struct GNUNET_CONTAINER_MetaData *metaDataW; |
147 | metaDataW = GNUNET_CONTAINER_meta_data_create (); | 164 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
148 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 165 | metaDataW = GNUNET_CONTAINER_meta_data_create (); |
149 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | 166 | metaDataR = GNUNET_CONTAINER_meta_data_create (); |
150 | GNUNET_assert (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (metaDataW, EXTRACTOR_COMMENT, meta)); | 167 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); |
151 | 168 | GNUNET_assert (GNUNET_OK == | |
152 | fileW = GNUNET_BIO_write_open (fileName); | 169 | GNUNET_CONTAINER_meta_data_insert (metaDataW, |
153 | GNUNET_assert (NULL != fileW); | 170 | EXTRACTOR_COMMENT, meta)); |
154 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); | 171 | |
155 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 172 | fileW = GNUNET_BIO_write_open (fileName); |
156 | 173 | GNUNET_assert (NULL != fileW); | |
157 | fileR = GNUNET_BIO_read_open (fileName); | 174 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_meta_data (fileW, metaDataW)); |
158 | GNUNET_assert (NULL != fileR); | 175 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); |
159 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); | 176 | |
160 | GNUNET_BIO_read_close (fileR, &msg); | 177 | fileR = GNUNET_BIO_read_open (fileName); |
161 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 178 | GNUNET_assert (NULL != fileR); |
162 | GNUNET_free (fileName); | 179 | GNUNET_assert (GNUNET_SYSERR == |
163 | return 0; | 180 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", |
181 | &metaDataR)); | ||
182 | GNUNET_BIO_read_close (fileR, &msg); | ||
183 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
184 | GNUNET_free (fileName); | ||
185 | return 0; | ||
164 | } | 186 | } |
165 | 187 | ||
166 | static int | 188 | static int |
167 | test_nullfile_rw(void){ | 189 | test_nullfile_rw (void) |
168 | char *msg; | 190 | { |
169 | int64_t testNum; | 191 | char *msg; |
170 | char *readResultString; | 192 | int64_t testNum; |
171 | static char fileNameNO[102401]; | 193 | char *readResultString; |
172 | char readResult[200]; | 194 | static char fileNameNO[102401]; |
173 | memset(fileNameNO,'a',sizeof(fileNameNO)); | 195 | char readResult[200]; |
174 | fileNameNO[sizeof(fileNameNO)-1] = '\0'; | 196 | memset (fileNameNO, 'a', sizeof (fileNameNO)); |
175 | const char *fileName = "/dev/full"; | 197 | fileNameNO[sizeof (fileNameNO) - 1] = '\0'; |
176 | const char *fileNameR = "/dev/null"; | 198 | const char *fileName = "/dev/full"; |
177 | struct GNUNET_BIO_WriteHandle *fileW,*fileWNO; | 199 | const char *fileNameR = "/dev/null"; |
178 | struct GNUNET_BIO_ReadHandle *fileR,*fileRNO; | 200 | struct GNUNET_BIO_WriteHandle *fileW, *fileWNO; |
179 | struct GNUNET_CONTAINER_MetaData *metaDataW; | 201 | struct GNUNET_BIO_ReadHandle *fileR, *fileRNO; |
180 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 202 | struct GNUNET_CONTAINER_MetaData *metaDataW; |
181 | metaDataW = GNUNET_CONTAINER_meta_data_create (); | 203 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
182 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 204 | metaDataW = GNUNET_CONTAINER_meta_data_create (); |
183 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | 205 | metaDataR = GNUNET_CONTAINER_meta_data_create (); |
184 | 206 | GNUNET_CONTAINER_meta_data_add_publication_date (metaDataW); | |
185 | fileWNO = GNUNET_BIO_write_open(fileNameNO); | 207 | |
186 | GNUNET_assert (NULL == fileWNO); | 208 | fileWNO = GNUNET_BIO_write_open (fileNameNO); |
187 | 209 | GNUNET_assert (NULL == fileWNO); | |
188 | fileRNO = GNUNET_BIO_read_open (fileNameNO); | 210 | |
189 | GNUNET_assert (NULL == fileRNO); | 211 | fileRNO = GNUNET_BIO_read_open (fileNameNO); |
190 | 212 | GNUNET_assert (NULL == fileRNO); | |
191 | fileW = GNUNET_BIO_write_open (fileName); | 213 | |
192 | GNUNET_assert (NULL != fileW); | 214 | fileW = GNUNET_BIO_write_open (fileName); |
193 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write (fileW, TESTSTRING, 65537)); | 215 | GNUNET_assert (NULL != fileW); |
194 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_string (fileW, TESTSTRING)); | 216 | GNUNET_assert (GNUNET_SYSERR == |
195 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_meta_data (fileW, metaDataW)); | 217 | GNUNET_BIO_write (fileW, TESTSTRING, 65537)); |
196 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); | 218 | GNUNET_assert (GNUNET_SYSERR == |
197 | fileW = GNUNET_BIO_write_open (fileName); | 219 | GNUNET_BIO_write_string (fileW, TESTSTRING)); |
198 | GNUNET_assert (NULL != fileW); | 220 | GNUNET_assert (GNUNET_SYSERR == |
199 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); | 221 | GNUNET_BIO_write_meta_data (fileW, metaDataW)); |
200 | 222 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); | |
201 | fileR = GNUNET_BIO_read_open (fileNameR); | 223 | fileW = GNUNET_BIO_write_open (fileName); |
202 | GNUNET_assert (NULL != fileR); | 224 | GNUNET_assert (NULL != fileW); |
203 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read (fileR, "Read error", readResult, 65537)); | 225 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_write_close (fileW)); |
204 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string (fileR, "Read string error", &readResultString, 200)); | 226 | |
205 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum)); | 227 | fileR = GNUNET_BIO_read_open (fileNameR); |
206 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data (fileR, "Read meta error", &metaDataR)); | 228 | GNUNET_assert (NULL != fileR); |
207 | GNUNET_BIO_read_close (fileR, &msg); | 229 | GNUNET_assert (GNUNET_SYSERR == |
208 | return 0; | 230 | GNUNET_BIO_read (fileR, "Read error", readResult, 65537)); |
231 | GNUNET_assert (GNUNET_SYSERR == | ||
232 | GNUNET_BIO_read_string (fileR, "Read string error", | ||
233 | &readResultString, 200)); | ||
234 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_int64 (fileR, &testNum)); | ||
235 | GNUNET_assert (GNUNET_SYSERR == | ||
236 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", | ||
237 | &metaDataR)); | ||
238 | GNUNET_BIO_read_close (fileR, &msg); | ||
239 | return 0; | ||
209 | } | 240 | } |
210 | 241 | ||
211 | static int | 242 | static int |
212 | test_fakestring_rw(void){ | 243 | test_fakestring_rw (void) |
213 | char *msg; | 244 | { |
214 | int32_t tmpInt = 2; | 245 | char *msg; |
215 | char *readResult; | 246 | int32_t tmpInt = 2; |
216 | struct GNUNET_BIO_WriteHandle *fileW; | 247 | char *readResult; |
217 | struct GNUNET_BIO_ReadHandle *fileR; | 248 | struct GNUNET_BIO_WriteHandle *fileW; |
218 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 249 | struct GNUNET_BIO_ReadHandle *fileR; |
219 | 250 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | |
220 | fileW = GNUNET_BIO_write_open (fileName); | 251 | |
221 | GNUNET_assert (NULL != fileW); | 252 | fileW = GNUNET_BIO_write_open (fileName); |
222 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); | 253 | GNUNET_assert (NULL != fileW); |
223 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 254 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); |
224 | 255 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
225 | fileR = GNUNET_BIO_read_open (fileName); | 256 | |
226 | GNUNET_assert (NULL != fileR); | 257 | fileR = GNUNET_BIO_read_open (fileName); |
227 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_string(fileR, "Read string error", &readResult, 200)); | 258 | GNUNET_assert (NULL != fileR); |
228 | GNUNET_BIO_read_close (fileR, &msg); | 259 | GNUNET_assert (GNUNET_SYSERR == |
229 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 260 | GNUNET_BIO_read_string (fileR, "Read string error", |
230 | GNUNET_free (fileName); | 261 | &readResult, 200)); |
231 | return 0; | 262 | GNUNET_BIO_read_close (fileR, &msg); |
263 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
264 | GNUNET_free (fileName); | ||
265 | return 0; | ||
232 | } | 266 | } |
233 | 267 | ||
234 | static int | 268 | static int |
235 | test_fakemeta_rw(void){ | 269 | test_fakemeta_rw (void) |
236 | char *msg; | 270 | { |
237 | int32_t tmpInt = 2; | 271 | char *msg; |
238 | struct GNUNET_BIO_WriteHandle *fileW; | 272 | int32_t tmpInt = 2; |
239 | struct GNUNET_BIO_ReadHandle *fileR; | 273 | struct GNUNET_BIO_WriteHandle *fileW; |
240 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 274 | struct GNUNET_BIO_ReadHandle *fileR; |
241 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 275 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
242 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 276 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
243 | 277 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | |
244 | fileW = GNUNET_BIO_write_open (fileName); | 278 | |
245 | GNUNET_assert (NULL != fileW); | 279 | fileW = GNUNET_BIO_write_open (fileName); |
246 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW,tmpInt)); | 280 | GNUNET_assert (NULL != fileW); |
247 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 281 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); |
248 | 282 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
249 | fileR = GNUNET_BIO_read_open (fileName); | 283 | |
250 | GNUNET_assert (NULL != fileR); | 284 | fileR = GNUNET_BIO_read_open (fileName); |
251 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); | 285 | GNUNET_assert (NULL != fileR); |
252 | GNUNET_BIO_read_close (fileR, &msg); | 286 | GNUNET_assert (GNUNET_SYSERR == |
253 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 287 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", |
254 | GNUNET_free (fileName); | 288 | &metaDataR)); |
255 | return 0; | 289 | GNUNET_BIO_read_close (fileR, &msg); |
290 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
291 | GNUNET_free (fileName); | ||
292 | return 0; | ||
256 | } | 293 | } |
257 | 294 | ||
258 | static int | 295 | static int |
259 | test_fakebigmeta_rw(void){ | 296 | test_fakebigmeta_rw (void) |
260 | char *msg; | 297 | { |
261 | int32_t tmpInt = 1024*1024*10; | 298 | char *msg; |
262 | struct GNUNET_BIO_WriteHandle *fileW; | 299 | int32_t tmpInt = 1024 * 1024 * 10; |
263 | struct GNUNET_BIO_ReadHandle *fileR; | 300 | struct GNUNET_BIO_WriteHandle *fileW; |
264 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); | 301 | struct GNUNET_BIO_ReadHandle *fileR; |
265 | struct GNUNET_CONTAINER_MetaData *metaDataR; | 302 | char *fileName = GNUNET_DISK_mktemp ("gnunet_bio"); |
266 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | 303 | struct GNUNET_CONTAINER_MetaData *metaDataR; |
267 | 304 | metaDataR = GNUNET_CONTAINER_meta_data_create (); | |
268 | fileW = GNUNET_BIO_write_open (fileName); | 305 | |
269 | GNUNET_assert (NULL != fileW); | 306 | fileW = GNUNET_BIO_write_open (fileName); |
270 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32(fileW, tmpInt)); | 307 | GNUNET_assert (NULL != fileW); |
271 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | 308 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_int32 (fileW, tmpInt)); |
272 | 309 | GNUNET_assert (GNUNET_OK == GNUNET_BIO_write_close (fileW)); | |
273 | fileR = GNUNET_BIO_read_open (fileName); | 310 | |
274 | GNUNET_assert (NULL != fileR); | 311 | fileR = GNUNET_BIO_read_open (fileName); |
275 | GNUNET_assert (GNUNET_SYSERR == GNUNET_BIO_read_meta_data(fileR, "Read meta error", &metaDataR)); | 312 | GNUNET_assert (NULL != fileR); |
276 | GNUNET_BIO_read_close (fileR, &msg); | 313 | GNUNET_assert (GNUNET_SYSERR == |
277 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | 314 | GNUNET_BIO_read_meta_data (fileR, "Read meta error", |
278 | GNUNET_free (fileName); | 315 | &metaDataR)); |
279 | return 0; | 316 | GNUNET_BIO_read_close (fileR, &msg); |
317 | GNUNET_assert (GNUNET_OK == GNUNET_DISK_directory_remove (fileName)); | ||
318 | GNUNET_free (fileName); | ||
319 | return 0; | ||
280 | } | 320 | } |
281 | 321 | ||
282 | static int | 322 | static int |
283 | check_string_rw(void){ | 323 | check_string_rw (void) |
284 | GNUNET_assert (0 == test_nullstring_rw()); | 324 | { |
285 | GNUNET_assert (0 == test_emptystring_rw()); | 325 | GNUNET_assert (0 == test_nullstring_rw ()); |
286 | GNUNET_assert (0 == test_bigstring_rw()); | 326 | GNUNET_assert (0 == test_emptystring_rw ()); |
287 | GNUNET_assert (0 == test_fakestring_rw()); | 327 | GNUNET_assert (0 == test_bigstring_rw ()); |
288 | return 0; | 328 | GNUNET_assert (0 == test_fakestring_rw ()); |
329 | return 0; | ||
289 | } | 330 | } |
290 | 331 | ||
291 | static int | 332 | static int |
292 | check_metadata_rw(void){ | 333 | check_metadata_rw (void) |
293 | GNUNET_assert (0 == test_fakebigmeta_rw()); | 334 | { |
294 | GNUNET_assert (0 == test_fakemeta_rw()); | 335 | GNUNET_assert (0 == test_fakebigmeta_rw ()); |
295 | GNUNET_assert (0 == test_bigmeta_rw()); | 336 | GNUNET_assert (0 == test_fakemeta_rw ()); |
296 | return 0; | 337 | GNUNET_assert (0 == test_bigmeta_rw ()); |
338 | return 0; | ||
297 | } | 339 | } |
298 | 340 | ||
299 | static int | 341 | static int |
300 | check_file_rw(void){ | 342 | check_file_rw (void) |
301 | GNUNET_assert (0 == test_normal_rw()); | 343 | { |
302 | GNUNET_assert (0 == test_nullfile_rw()); | 344 | GNUNET_assert (0 == test_normal_rw ()); |
303 | return 0; | 345 | GNUNET_assert (0 == test_nullfile_rw ()); |
346 | return 0; | ||
304 | } | 347 | } |
305 | 348 | ||
306 | int | 349 | int |
307 | main (int argc, char *argv[]){ | 350 | main (int argc, char *argv[]) |
308 | GNUNET_assert (0 == check_file_rw()); | 351 | { |
309 | GNUNET_assert (0 == check_metadata_rw()); | 352 | GNUNET_assert (0 == check_file_rw ()); |
310 | GNUNET_assert (0 == check_string_rw()); | 353 | GNUNET_assert (0 == check_metadata_rw ()); |
311 | return 0; | 354 | GNUNET_assert (0 == check_string_rw ()); |
355 | return 0; | ||
312 | } /* end of main */ | 356 | } /* end of main */ |
diff --git a/src/util/test_crypto_rsa.c b/src/util/test_crypto_rsa.c index b3663662e..a321e0cc5 100644 --- a/src/util/test_crypto_rsa.c +++ b/src/util/test_crypto_rsa.c | |||
@@ -273,8 +273,8 @@ testSignPerformance () | |||
273 | } | 273 | } |
274 | } | 274 | } |
275 | printf ("%d RSA sign operations %llu ms\n", ITER, | 275 | printf ("%d RSA sign operations %llu ms\n", ITER, |
276 | (unsigned long long) GNUNET_TIME_absolute_get_duration (start). | 276 | (unsigned long long) |
277 | value); | 277 | GNUNET_TIME_absolute_get_duration (start).value); |
278 | GNUNET_CRYPTO_rsa_key_free (hostkey); | 278 | GNUNET_CRYPTO_rsa_key_free (hostkey); |
279 | return ok; | 279 | return ok; |
280 | } | 280 | } |
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c index 3021dce19..74be05654 100644 --- a/src/util/test_scheduler.c +++ b/src/util/test_scheduler.c | |||
@@ -48,9 +48,9 @@ task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
48 | GNUNET_assert (2 == *ok); | 48 | GNUNET_assert (2 == *ok); |
49 | (*ok) = 3; | 49 | (*ok) = 3; |
50 | /* t3 will go before t4: higher priority */ | 50 | /* t3 will go before t4: higher priority */ |
51 | GNUNET_SCHEDULER_add_with_priority (tc->sched, | 51 | GNUNET_SCHEDULER_add_with_priority (tc->sched, |
52 | GNUNET_SCHEDULER_PRIORITY_UI, | 52 | GNUNET_SCHEDULER_PRIORITY_UI, |
53 | &task3, cls); | 53 | &task3, cls); |
54 | } | 54 | } |
55 | 55 | ||
56 | static void | 56 | static void |
@@ -102,8 +102,8 @@ taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
102 | GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1)); | 102 | GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1)); |
103 | (*ok) = 8; | 103 | (*ok) = 8; |
104 | GNUNET_SCHEDULER_add_with_priority (tc->sched, | 104 | GNUNET_SCHEDULER_add_with_priority (tc->sched, |
105 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 105 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
106 | &taskLast, cls); | 106 | &taskLast, cls); |
107 | GNUNET_SCHEDULER_shutdown (tc->sched); | 107 | GNUNET_SCHEDULER_shutdown (tc->sched); |
108 | } | 108 | } |
109 | 109 | ||
@@ -140,11 +140,9 @@ task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
140 | t2 = GNUNET_SCHEDULER_add_after (tc->sched, | 140 | t2 = GNUNET_SCHEDULER_add_after (tc->sched, |
141 | GNUNET_SCHEDULER_NO_TASK, &task2, cls); | 141 | GNUNET_SCHEDULER_NO_TASK, &task2, cls); |
142 | /* t4 will go after t2 ('add after') and after t3 (priority) */ | 142 | /* t4 will go after t2 ('add after') and after t3 (priority) */ |
143 | t4 = GNUNET_SCHEDULER_add_after (tc->sched, | 143 | t4 = GNUNET_SCHEDULER_add_after (tc->sched, t2, &task4, cls); |
144 | t2, &task4, cls); | ||
145 | /* t5 will go last (after p4) */ | 144 | /* t5 will go last (after p4) */ |
146 | GNUNET_SCHEDULER_add_after (tc->sched, | 145 | GNUNET_SCHEDULER_add_after (tc->sched, t4, &task5, cls); |
147 | t4, &task5, cls); | ||
148 | } | 146 | } |
149 | 147 | ||
150 | 148 | ||
@@ -171,8 +169,7 @@ taskShutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
171 | GNUNET_assert (1 == *ok); | 169 | GNUNET_assert (1 == *ok); |
172 | *ok = 8; | 170 | *ok = 8; |
173 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 171 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
174 | GNUNET_TIME_UNIT_FOREVER_REL, | 172 | GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls); |
175 | &taskLast, cls); | ||
176 | GNUNET_SCHEDULER_shutdown (tc->sched); | 173 | GNUNET_SCHEDULER_shutdown (tc->sched); |
177 | } | 174 | } |
178 | 175 | ||
@@ -199,8 +196,7 @@ taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
199 | GNUNET_assert (1 == *ok); | 196 | GNUNET_assert (1 == *ok); |
200 | *ok = 8; | 197 | *ok = 8; |
201 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 198 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
202 | GNUNET_TIME_UNIT_FOREVER_REL, | 199 | GNUNET_TIME_UNIT_FOREVER_REL, &taskLast, cls); |
203 | &taskLast, cls); | ||
204 | #ifndef MINGW | 200 | #ifndef MINGW |
205 | GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM)); | 201 | GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM)); |
206 | #else | 202 | #else |
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c index 52b0addfa..453ae5ed4 100644 --- a/src/util/test_server_with_client.c +++ b/src/util/test_server_with_client.c | |||
@@ -126,8 +126,7 @@ notify_disconnect (void *cls, struct GNUNET_SERVER_Client *client) | |||
126 | GNUNET_assert (ok == 5); | 126 | GNUNET_assert (ok == 5); |
127 | ok = 0; | 127 | ok = 0; |
128 | GNUNET_SCHEDULER_add_delayed (sched, | 128 | GNUNET_SCHEDULER_add_delayed (sched, |
129 | GNUNET_TIME_UNIT_ZERO, | 129 | GNUNET_TIME_UNIT_ZERO, &clean_up, NULL); |
130 | &clean_up, NULL); | ||
131 | } | 130 | } |
132 | 131 | ||
133 | 132 | ||
diff --git a/src/util/test_service.c b/src/util/test_service.c index ab7011526..1d42f3407 100644 --- a/src/util/test_service.c +++ b/src/util/test_service.c | |||
@@ -51,7 +51,7 @@ end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
51 | 51 | ||
52 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n"); | 52 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n"); |
53 | GNUNET_CLIENT_service_shutdown (client); | 53 | GNUNET_CLIENT_service_shutdown (client); |
54 | if (sctx != NULL) | 54 | if (sctx != NULL) |
55 | GNUNET_SERVICE_stop (sctx); | 55 | GNUNET_SERVICE_stop (sctx); |
56 | else | 56 | else |
57 | GNUNET_SCHEDULER_shutdown (sched); | 57 | GNUNET_SCHEDULER_shutdown (sched); |
@@ -152,13 +152,13 @@ check () | |||
152 | GNUNET_SERVICE_run (5, | 152 | GNUNET_SERVICE_run (5, |
153 | argv, | 153 | argv, |
154 | "test_service", | 154 | "test_service", |
155 | GNUNET_SERVICE_OPTION_NONE, | 155 | GNUNET_SERVICE_OPTION_NONE, |
156 | &runner, &ok)); | 156 | &runner, &ok)); |
157 | GNUNET_assert (0 == ok); | 157 | GNUNET_assert (0 == ok); |
158 | return ok; | 158 | return ok; |
159 | } | 159 | } |
160 | 160 | ||
161 | static void | 161 | static void |
162 | ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 162 | ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
163 | { | 163 | { |
164 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; | 164 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; |
@@ -214,7 +214,7 @@ check6 () | |||
214 | GNUNET_SERVICE_run (5, | 214 | GNUNET_SERVICE_run (5, |
215 | argv, | 215 | argv, |
216 | "test_service6", | 216 | "test_service6", |
217 | GNUNET_SERVICE_OPTION_NONE, | 217 | GNUNET_SERVICE_OPTION_NONE, |
218 | &runner6, &ok)); | 218 | &runner6, &ok)); |
219 | GNUNET_assert (0 == ok); | 219 | GNUNET_assert (0 == ok); |
220 | return ok; | 220 | return ok; |
@@ -247,7 +247,7 @@ check6d () | |||
247 | GNUNET_SERVICE_run (6, | 247 | GNUNET_SERVICE_run (6, |
248 | argv, | 248 | argv, |
249 | "test_service6", | 249 | "test_service6", |
250 | GNUNET_SERVICE_OPTION_NONE, | 250 | GNUNET_SERVICE_OPTION_NONE, |
251 | &runner6, &ok)); | 251 | &runner6, &ok)); |
252 | GNUNET_break (0 == ok); | 252 | GNUNET_break (0 == ok); |
253 | return ok; | 253 | return ok; |