aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/util/client.c41
-rw-r--r--src/util/connection.c36
-rw-r--r--src/util/container_heap.c8
-rw-r--r--src/util/disk.c4
-rw-r--r--src/util/disk.h4
-rw-r--r--src/util/gnunet-service-resolver.c2
-rw-r--r--src/util/perf_crypto_hash.c4
-rw-r--r--src/util/scheduler.c125
-rw-r--r--src/util/server.c43
-rw-r--r--src/util/service.c18
-rw-r--r--src/util/test_bio.c528
-rw-r--r--src/util/test_crypto_rsa.c4
-rw-r--r--src/util/test_scheduler.c22
-rw-r--r--src/util/test_server_with_client.c3
-rw-r--r--src/util/test_service.c10
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);
1349RETRY: 1349RETRY:
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,
755GNUNET_SCHEDULER_TaskIdentifier 755GNUNET_SCHEDULER_TaskIdentifier
756GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, 756GNUNET_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 */
779GNUNET_SCHEDULER_TaskIdentifier 778GNUNET_SCHEDULER_TaskIdentifier
780GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched, 779GNUNET_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 */
807GNUNET_SCHEDULER_TaskIdentifier 806GNUNET_SCHEDULER_TaskIdentifier
808GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, 807GNUNET_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 */
837GNUNET_SCHEDULER_TaskIdentifier 835GNUNET_SCHEDULER_TaskIdentifier
838GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, 836GNUNET_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 */
877GNUNET_SCHEDULER_TaskIdentifier 873GNUNET_SCHEDULER_TaskIdentifier
878GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, 874GNUNET_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 */
916GNUNET_SCHEDULER_TaskIdentifier 911GNUNET_SCHEDULER_TaskIdentifier
917GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, 912GNUNET_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 */
955GNUNET_SCHEDULER_TaskIdentifier 949GNUNET_SCHEDULER_TaskIdentifier
956GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, 950GNUNET_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 */
1012GNUNET_SCHEDULER_TaskIdentifier 1004GNUNET_SCHEDULER_TaskIdentifier
1013GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched, 1005GNUNET_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 */
1081static void 1080static void
1082shutdown_task (void *cls, 1081shutdown_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
1297GNUNET_SERVICE_run (int argc, 1294GNUNET_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
33static int 33static int
34test_normal_rw(void){ 34test_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
68static int 76static int
69test_nullstring_rw(){ 77test_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
92static int 103static int
93test_emptystring_rw(void){ 104test_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
114static int 128static int
115test_bigstring_rw(void){ 129test_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
136static int 153static int
137test_bigmeta_rw(){ 154test_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
166static int 188static int
167test_nullfile_rw(void){ 189test_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
211static int 242static int
212test_fakestring_rw(void){ 243test_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
234static int 268static int
235test_fakemeta_rw(void){ 269test_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
258static int 295static int
259test_fakebigmeta_rw(void){ 296test_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
282static int 322static int
283check_string_rw(void){ 323check_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
291static int 332static int
292check_metadata_rw(void){ 333check_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
299static int 341static int
300check_file_rw(void){ 342check_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
306int 349int
307main (int argc, char *argv[]){ 350main (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
56static void 56static 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
161static void 161static void
162ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 162ready6 (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;
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 22:56:11 +0000