aboutsummaryrefslogtreecommitdiff
path: root/src/testbed
diff options
context:
space:
mode:
Diffstat (limited to 'src/testbed')
-rw-r--r--src/testbed/gnunet-daemon-latency-logger.c4
-rw-r--r--src/testbed/gnunet-daemon-testbed-blacklist.c2
-rw-r--r--src/testbed/gnunet-daemon-testbed-underlay.c2
-rw-r--r--src/testbed/gnunet-helper-testbed.c30
-rw-r--r--src/testbed/gnunet-service-testbed-logger.c6
-rw-r--r--src/testbed/gnunet-service-testbed.c6
-rw-r--r--src/testbed/gnunet-service-testbed.h2
-rw-r--r--src/testbed/gnunet-service-testbed_barriers.c2
-rw-r--r--src/testbed/gnunet-service-testbed_connectionpool.c30
-rw-r--r--src/testbed/gnunet-service-testbed_cpustatus.c8
-rw-r--r--src/testbed/gnunet-service-testbed_links.c48
-rw-r--r--src/testbed/gnunet-service-testbed_oc.c70
-rw-r--r--src/testbed/gnunet-testbed-profiler.c18
-rw-r--r--src/testbed/gnunet_testbed_mpi_spawn.c12
-rw-r--r--src/testbed/test_gnunet_helper_testbed.c12
-rw-r--r--src/testbed/test_testbed_api.c10
-rw-r--r--src/testbed/test_testbed_api_2peers_1controller.c16
-rw-r--r--src/testbed/test_testbed_api_3peers_3controllers.c20
-rw-r--r--src/testbed/test_testbed_api_barriers.c4
-rw-r--r--src/testbed/test_testbed_api_controllerlink.c22
-rw-r--r--src/testbed/test_testbed_api_hosts.c2
-rw-r--r--src/testbed/test_testbed_api_operations.c20
-rw-r--r--src/testbed/test_testbed_api_peer_reconfiguration.c8
-rw-r--r--src/testbed/test_testbed_api_peers_manage_services.c8
-rw-r--r--src/testbed/test_testbed_api_statistics.c6
-rw-r--r--src/testbed/test_testbed_api_test.c18
-rw-r--r--src/testbed/test_testbed_api_testbed_run.c10
-rw-r--r--src/testbed/test_testbed_api_topology.c4
-rw-r--r--src/testbed/test_testbed_api_topology_clique.c4
-rw-r--r--src/testbed/test_testbed_logger_api.c12
-rw-r--r--src/testbed/testbed_api_hosts.c4
-rw-r--r--src/testbed/testbed_api_operations.c10
-rw-r--r--src/testbed/testbed_api_statistics.c14
-rw-r--r--src/testbed/testbed_api_testbed.c24
-rw-r--r--src/testbed/testbed_logger_api.c28
35 files changed, 248 insertions, 248 deletions
diff --git a/src/testbed/gnunet-daemon-latency-logger.c b/src/testbed/gnunet-daemon-latency-logger.c
index fb9364c28..945cf42f4 100644
--- a/src/testbed/gnunet-daemon-latency-logger.c
+++ b/src/testbed/gnunet-daemon-latency-logger.c
@@ -98,7 +98,7 @@ struct sqlite3_stmt *stmt_insert;
98/** 98/**
99 * Shutdown task identifier 99 * Shutdown task identifier
100 */ 100 */
101GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 101struct GNUNET_SCHEDULER_Task * shutdown_task;
102 102
103 103
104/** 104/**
@@ -136,7 +136,7 @@ free_iterator (void *cls,
136static void 136static void
137do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 137do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
138{ 138{
139 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 139 shutdown_task = NULL;
140 GNUNET_ATS_performance_done (ats); 140 GNUNET_ATS_performance_done (ats);
141 ats = NULL; 141 ats = NULL;
142 if (NULL != stmt_insert) 142 if (NULL != stmt_insert)
diff --git a/src/testbed/gnunet-daemon-testbed-blacklist.c b/src/testbed/gnunet-daemon-testbed-blacklist.c
index 95cdda8bd..d437c8c05 100644
--- a/src/testbed/gnunet-daemon-testbed-blacklist.c
+++ b/src/testbed/gnunet-daemon-testbed-blacklist.c
@@ -72,7 +72,7 @@ struct GNUNET_TRANSPORT_Blacklist *bh;
72/** 72/**
73 * Task for shutdown 73 * Task for shutdown
74 */ 74 */
75static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 75static struct GNUNET_SCHEDULER_Task * shutdown_task;
76 76
77/** 77/**
78 * Are we allowing or denying access from peers 78 * Are we allowing or denying access from peers
diff --git a/src/testbed/gnunet-daemon-testbed-underlay.c b/src/testbed/gnunet-daemon-testbed-underlay.c
index 59c9331e1..f41419231 100644
--- a/src/testbed/gnunet-daemon-testbed-underlay.c
+++ b/src/testbed/gnunet-daemon-testbed-underlay.c
@@ -104,7 +104,7 @@ static unsigned int num_hostkeys;
104/** 104/**
105 * Task for shutdown 105 * Task for shutdown
106 */ 106 */
107static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 107static struct GNUNET_SCHEDULER_Task * shutdown_task;
108 108
109 109
110/** 110/**
diff --git a/src/testbed/gnunet-helper-testbed.c b/src/testbed/gnunet-helper-testbed.c
index 6937d7262..ccb868e8b 100644
--- a/src/testbed/gnunet-helper-testbed.c
+++ b/src/testbed/gnunet-helper-testbed.c
@@ -124,22 +124,22 @@ static struct GNUNET_DISK_PipeHandle *sigpipe;
124/** 124/**
125 * Task identifier for the read task 125 * Task identifier for the read task
126 */ 126 */
127static GNUNET_SCHEDULER_TaskIdentifier read_task_id; 127static struct GNUNET_SCHEDULER_Task * read_task_id;
128 128
129/** 129/**
130 * Task identifier for the write task 130 * Task identifier for the write task
131 */ 131 */
132static GNUNET_SCHEDULER_TaskIdentifier write_task_id; 132static struct GNUNET_SCHEDULER_Task * write_task_id;
133 133
134/** 134/**
135 * Task to kill the child 135 * Task to kill the child
136 */ 136 */
137static GNUNET_SCHEDULER_TaskIdentifier child_death_task_id; 137static struct GNUNET_SCHEDULER_Task * child_death_task_id;
138 138
139/** 139/**
140 * shutdown task id 140 * shutdown task id
141 */ 141 */
142static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; 142static struct GNUNET_SCHEDULER_Task * shutdown_task_id;
143 143
144/** 144/**
145 * Are we done reading messages from stdin? 145 * Are we done reading messages from stdin?
@@ -162,26 +162,26 @@ static void
162shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 162shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
163{ 163{
164 LOG_DEBUG ("Shutting down\n"); 164 LOG_DEBUG ("Shutting down\n");
165 shutdown_task_id = GNUNET_SCHEDULER_NO_TASK; 165 shutdown_task_id = NULL;
166 if (NULL != testbed) 166 if (NULL != testbed)
167 { 167 {
168 LOG_DEBUG ("Killing testbed\n"); 168 LOG_DEBUG ("Killing testbed\n");
169 GNUNET_break (0 == GNUNET_OS_process_kill (testbed, GNUNET_TERM_SIG)); 169 GNUNET_break (0 == GNUNET_OS_process_kill (testbed, GNUNET_TERM_SIG));
170 } 170 }
171 if (GNUNET_SCHEDULER_NO_TASK != read_task_id) 171 if (NULL != read_task_id)
172 { 172 {
173 GNUNET_SCHEDULER_cancel (read_task_id); 173 GNUNET_SCHEDULER_cancel (read_task_id);
174 read_task_id = GNUNET_SCHEDULER_NO_TASK; 174 read_task_id = NULL;
175 } 175 }
176 if (GNUNET_SCHEDULER_NO_TASK != write_task_id) 176 if (NULL != write_task_id)
177 { 177 {
178 GNUNET_SCHEDULER_cancel (write_task_id); 178 GNUNET_SCHEDULER_cancel (write_task_id);
179 write_task_id = GNUNET_SCHEDULER_NO_TASK; 179 write_task_id = NULL;
180 } 180 }
181 if (GNUNET_SCHEDULER_NO_TASK != child_death_task_id) 181 if (NULL != child_death_task_id)
182 { 182 {
183 GNUNET_SCHEDULER_cancel (child_death_task_id); 183 GNUNET_SCHEDULER_cancel (child_death_task_id);
184 child_death_task_id = GNUNET_SCHEDULER_NO_TASK; 184 child_death_task_id = NULL;
185 } 185 }
186 if (NULL != stdin_fd) 186 if (NULL != stdin_fd)
187 (void) GNUNET_DISK_file_close (stdin_fd); 187 (void) GNUNET_DISK_file_close (stdin_fd);
@@ -209,7 +209,7 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
209static void 209static void
210shutdown_now (void) 210shutdown_now (void)
211{ 211{
212 if (GNUNET_SCHEDULER_NO_TASK != shutdown_task_id) 212 if (NULL != shutdown_task_id)
213 GNUNET_SCHEDULER_cancel (shutdown_task_id); 213 GNUNET_SCHEDULER_cancel (shutdown_task_id);
214 shutdown_task_id = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); 214 shutdown_task_id = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
215} 215}
@@ -228,7 +228,7 @@ write_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
228 ssize_t bytes_wrote; 228 ssize_t bytes_wrote;
229 229
230 GNUNET_assert (NULL != wc); 230 GNUNET_assert (NULL != wc);
231 write_task_id = GNUNET_SCHEDULER_NO_TASK; 231 write_task_id = NULL;
232 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) 232 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
233 { 233 {
234 GNUNET_free (wc->data); 234 GNUNET_free (wc->data);
@@ -275,7 +275,7 @@ child_death_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
275 int ret; 275 int ret;
276 276
277 pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); 277 pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
278 child_death_task_id = GNUNET_SCHEDULER_NO_TASK; 278 child_death_task_id = NULL;
279 if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) 279 if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
280 { 280 {
281 child_death_task_id = 281 child_death_task_id =
@@ -518,7 +518,7 @@ read_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
518 char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE]; 518 char buf[GNUNET_SERVER_MAX_MESSAGE_SIZE];
519 ssize_t sread; 519 ssize_t sread;
520 520
521 read_task_id = GNUNET_SCHEDULER_NO_TASK; 521 read_task_id = NULL;
522 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) 522 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
523 return; 523 return;
524 sread = GNUNET_DISK_file_read (stdin_fd, buf, sizeof (buf)); 524 sread = GNUNET_DISK_file_read (stdin_fd, buf, sizeof (buf));
diff --git a/src/testbed/gnunet-service-testbed-logger.c b/src/testbed/gnunet-service-testbed-logger.c
index 6bf33e681..7d3c834e2 100644
--- a/src/testbed/gnunet-service-testbed-logger.c
+++ b/src/testbed/gnunet-service-testbed-logger.c
@@ -83,7 +83,7 @@ struct GNUNET_BIO_WriteHandle *bio;
83/** 83/**
84 * The shutdown task handle 84 * The shutdown task handle
85 */ 85 */
86static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; 86static struct GNUNET_SCHEDULER_Task * shutdown_task_id;
87 87
88/** 88/**
89 * The number of connections we have 89 * The number of connections we have
@@ -126,7 +126,7 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
126{ 126{
127 struct MessageQueue *mq_entry; 127 struct MessageQueue *mq_entry;
128 128
129 shutdown_task_id = GNUNET_SCHEDULER_NO_TASK; 129 shutdown_task_id = NULL;
130 in_shutdown = GNUNET_YES; 130 in_shutdown = GNUNET_YES;
131 if (0 != nconn) 131 if (0 != nconn)
132 { 132 {
@@ -166,7 +166,7 @@ client_disconnected (void *cls, struct GNUNET_SERVER_Client *client)
166 nconn--; 166 nconn--;
167 if (GNUNET_YES != in_shutdown) 167 if (GNUNET_YES != in_shutdown)
168 return; 168 return;
169 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != shutdown_task_id); 169 GNUNET_assert (NULL != shutdown_task_id);
170 GNUNET_SCHEDULER_cancel (shutdown_task_id); 170 GNUNET_SCHEDULER_cancel (shutdown_task_id);
171 shutdown_task_id = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL); 171 shutdown_task_id = GNUNET_SCHEDULER_add_now (&shutdown_task, NULL);
172} 172}
diff --git a/src/testbed/gnunet-service-testbed.c b/src/testbed/gnunet-service-testbed.c
index a1d6aed09..039e0d346 100644
--- a/src/testbed/gnunet-service-testbed.c
+++ b/src/testbed/gnunet-service-testbed.c
@@ -132,7 +132,7 @@ static struct MessageQueue *mq_tail;
132/** 132/**
133 * The shutdown task handle 133 * The shutdown task handle
134 */ 134 */
135static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; 135static struct GNUNET_SCHEDULER_Task * shutdown_task_id;
136 136
137 137
138/** 138/**
@@ -736,7 +736,7 @@ GST_clear_fopcq ()
736 { 736 {
737 GNUNET_CONTAINER_DLL_remove (fopcq_head, fopcq_tail, fopc); 737 GNUNET_CONTAINER_DLL_remove (fopcq_head, fopcq_tail, fopc);
738 GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc); 738 GNUNET_TESTBED_forward_operation_msg_cancel_ (fopc->opc);
739 if (GNUNET_SCHEDULER_NO_TASK != fopc->timeout_task) 739 if (NULL != fopc->timeout_task)
740 GNUNET_SCHEDULER_cancel (fopc->timeout_task); 740 GNUNET_SCHEDULER_cancel (fopc->timeout_task);
741 GNUNET_SERVER_client_drop (fopc->client); 741 GNUNET_SERVER_client_drop (fopc->client);
742 switch (fopc->type) 742 switch (fopc->type)
@@ -784,7 +784,7 @@ shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
784 struct MessageQueue *mq_entry; 784 struct MessageQueue *mq_entry;
785 uint32_t id; 785 uint32_t id;
786 786
787 shutdown_task_id = GNUNET_SCHEDULER_NO_TASK; 787 shutdown_task_id = NULL;
788 LOG_DEBUG ("Shutting down testbed service\n"); 788 LOG_DEBUG ("Shutting down testbed service\n");
789 /* cleanup any remaining forwarded operations */ 789 /* cleanup any remaining forwarded operations */
790 GST_clear_fopcq (); 790 GST_clear_fopcq ();
diff --git a/src/testbed/gnunet-service-testbed.h b/src/testbed/gnunet-service-testbed.h
index 7966864b6..a4eb8e7e8 100644
--- a/src/testbed/gnunet-service-testbed.h
+++ b/src/testbed/gnunet-service-testbed.h
@@ -106,7 +106,7 @@ struct ForwardedOperationContext
106 /** 106 /**
107 * Task ID for the timeout task 107 * Task ID for the timeout task
108 */ 108 */
109 GNUNET_SCHEDULER_TaskIdentifier timeout_task; 109 struct GNUNET_SCHEDULER_Task * timeout_task;
110 110
111 /** 111 /**
112 * The id of the operation that has been forwarded 112 * The id of the operation that has been forwarded
diff --git a/src/testbed/gnunet-service-testbed_barriers.c b/src/testbed/gnunet-service-testbed_barriers.c
index de2c175f1..5e6e391ac 100644
--- a/src/testbed/gnunet-service-testbed_barriers.c
+++ b/src/testbed/gnunet-service-testbed_barriers.c
@@ -199,7 +199,7 @@ struct Barrier
199 /** 199 /**
200 * Identifier for the timeout task 200 * Identifier for the timeout task
201 */ 201 */
202 GNUNET_SCHEDULER_TaskIdentifier tout_task; 202 struct GNUNET_SCHEDULER_Task * tout_task;
203 203
204 /** 204 /**
205 * The status of this barrier 205 * The status of this barrier
diff --git a/src/testbed/gnunet-service-testbed_connectionpool.c b/src/testbed/gnunet-service-testbed_connectionpool.c
index 6d9a27972..51909ae3e 100644
--- a/src/testbed/gnunet-service-testbed_connectionpool.c
+++ b/src/testbed/gnunet-service-testbed_connectionpool.c
@@ -126,12 +126,12 @@ struct PooledConnection
126 /** 126 /**
127 * The task to expire this connection from the connection pool 127 * The task to expire this connection from the connection pool
128 */ 128 */
129 GNUNET_SCHEDULER_TaskIdentifier expire_task; 129 struct GNUNET_SCHEDULER_Task * expire_task;
130 130
131 /** 131 /**
132 * The task to notify a waiting #GST_ConnectionPool_GetHandle object 132 * The task to notify a waiting #GST_ConnectionPool_GetHandle object
133 */ 133 */
134 GNUNET_SCHEDULER_TaskIdentifier notify_task; 134 struct GNUNET_SCHEDULER_Task * notify_task;
135 135
136 /** 136 /**
137 * Number of active requests using this pooled connection 137 * Number of active requests using this pooled connection
@@ -286,10 +286,10 @@ destroy_pooled_connection (struct PooledConnection *entry)
286 GNUNET_CONTAINER_multihashmap32_remove (map, 286 GNUNET_CONTAINER_multihashmap32_remove (map,
287 entry->index, 287 entry->index,
288 entry)); 288 entry));
289 if (GNUNET_SCHEDULER_NO_TASK != entry->notify_task) 289 if (NULL != entry->notify_task)
290 { 290 {
291 GNUNET_SCHEDULER_cancel (entry->notify_task); 291 GNUNET_SCHEDULER_cancel (entry->notify_task);
292 entry->notify_task = GNUNET_SCHEDULER_NO_TASK; 292 entry->notify_task = NULL;
293 } 293 }
294 LOG_DEBUG ("Cleaning up handles of a pooled connection\n"); 294 LOG_DEBUG ("Cleaning up handles of a pooled connection\n");
295 if (NULL != entry->handle_transport) 295 if (NULL != entry->handle_transport)
@@ -322,7 +322,7 @@ expire (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
322{ 322{
323 struct PooledConnection *entry = cls; 323 struct PooledConnection *entry = cls;
324 324
325 entry->expire_task = GNUNET_SCHEDULER_NO_TASK; 325 entry->expire_task = NULL;
326 destroy_pooled_connection (entry); 326 destroy_pooled_connection (entry);
327} 327}
328 328
@@ -335,10 +335,10 @@ expire (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
335static void 335static void
336expire_task_cancel (struct PooledConnection *entry) 336expire_task_cancel (struct PooledConnection *entry)
337{ 337{
338 if (GNUNET_SCHEDULER_NO_TASK != entry->expire_task) 338 if (NULL != entry->expire_task)
339 { 339 {
340 GNUNET_SCHEDULER_cancel (entry->expire_task); 340 GNUNET_SCHEDULER_cancel (entry->expire_task);
341 entry->expire_task = GNUNET_SCHEDULER_NO_TASK; 341 entry->expire_task = NULL;
342 } 342 }
343} 343}
344 344
@@ -355,7 +355,7 @@ add_to_lru (struct PooledConnection *entry)
355 GNUNET_assert (!entry->in_lru); 355 GNUNET_assert (!entry->in_lru);
356 GNUNET_CONTAINER_DLL_insert_tail (head_lru, tail_lru, entry); 356 GNUNET_CONTAINER_DLL_insert_tail (head_lru, tail_lru, entry);
357 entry->in_lru = GNUNET_YES; 357 entry->in_lru = GNUNET_YES;
358 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == entry->expire_task); 358 GNUNET_assert (NULL == entry->expire_task);
359 entry->expire_task = GNUNET_SCHEDULER_add_delayed (CACHE_EXPIRY, 359 entry->expire_task = GNUNET_SCHEDULER_add_delayed (CACHE_EXPIRY,
360 &expire, entry); 360 &expire, entry);
361} 361}
@@ -415,8 +415,8 @@ connection_ready (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
415 struct GST_ConnectionPool_GetHandle *gh; 415 struct GST_ConnectionPool_GetHandle *gh;
416 struct GST_ConnectionPool_GetHandle *gh_next; 416 struct GST_ConnectionPool_GetHandle *gh_next;
417 417
418 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != entry->notify_task); 418 GNUNET_assert (NULL != entry->notify_task);
419 entry->notify_task = GNUNET_SCHEDULER_NO_TASK; 419 entry->notify_task = NULL;
420 gh = search_waiting (entry, entry->head_waiting); 420 gh = search_waiting (entry, entry->head_waiting);
421 GNUNET_assert (NULL != gh); 421 GNUNET_assert (NULL != gh);
422 gh_next = NULL; 422 gh_next = NULL;
@@ -524,7 +524,7 @@ opstart_get_handle_transport (void *cls)
524 } 524 }
525 if (0 == entry->demand) 525 if (0 == entry->demand)
526 return; 526 return;
527 if (GNUNET_SCHEDULER_NO_TASK != entry->notify_task) 527 if (NULL != entry->notify_task)
528 return; 528 return;
529 if (NULL != search_waiting (entry, entry->head_waiting)) 529 if (NULL != search_waiting (entry, entry->head_waiting))
530 { 530 {
@@ -597,7 +597,7 @@ core_startup_cb (void *cls,
597 sizeof (struct GNUNET_PeerIdentity)); 597 sizeof (struct GNUNET_PeerIdentity));
598 if (0 == entry->demand) 598 if (0 == entry->demand)
599 return; 599 return;
600 if (GNUNET_SCHEDULER_NO_TASK != entry->notify_task) 600 if (NULL != entry->notify_task)
601 return; 601 return;
602 if (NULL != search_waiting (entry, entry->head_waiting)) 602 if (NULL != search_waiting (entry, entry->head_waiting))
603 { 603 {
@@ -832,7 +832,7 @@ GST_connection_pool_get_handle (unsigned int peer_id,
832 GNUNET_CONTAINER_DLL_insert (entry->head_waiting, entry->tail_waiting, gh); 832 GNUNET_CONTAINER_DLL_insert (entry->head_waiting, entry->tail_waiting, gh);
833 if (NULL != handle) 833 if (NULL != handle)
834 { 834 {
835 if (GNUNET_SCHEDULER_NO_TASK == entry->notify_task) 835 if (NULL == entry->notify_task)
836 { 836 {
837 if (NULL != search_waiting (entry, entry->head_waiting)) 837 if (NULL != search_waiting (entry, entry->head_waiting))
838 entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry); 838 entry->notify_task = GNUNET_SCHEDULER_add_now (&connection_ready, entry);
@@ -888,10 +888,10 @@ GST_connection_pool_get_handle_done (struct GST_ConnectionPool_GetHandle *gh)
888 { 888 {
889 GNUNET_CONTAINER_DLL_remove (entry->head_waiting, entry->tail_waiting, gh); 889 GNUNET_CONTAINER_DLL_remove (entry->head_waiting, entry->tail_waiting, gh);
890 if ( (NULL == search_waiting (entry, entry->head_waiting)) 890 if ( (NULL == search_waiting (entry, entry->head_waiting))
891 && (GNUNET_SCHEDULER_NO_TASK != entry->notify_task) ) 891 && (NULL != entry->notify_task) )
892 { 892 {
893 GNUNET_SCHEDULER_cancel (entry->notify_task); 893 GNUNET_SCHEDULER_cancel (entry->notify_task);
894 entry->notify_task = GNUNET_SCHEDULER_NO_TASK; 894 entry->notify_task = NULL;
895 } 895 }
896 } 896 }
897 if (gh->notify_waiting) 897 if (gh->notify_waiting)
diff --git a/src/testbed/gnunet-service-testbed_cpustatus.c b/src/testbed/gnunet-service-testbed_cpustatus.c
index 712df48b3..fa0ee52c0 100644
--- a/src/testbed/gnunet-service-testbed_cpustatus.c
+++ b/src/testbed/gnunet-service-testbed_cpustatus.c
@@ -85,7 +85,7 @@ static double agedIOLoad = -1;
85 */ 85 */
86struct GNUNET_BIO_WriteHandle *bw; 86struct GNUNET_BIO_WriteHandle *bw;
87 87
88GNUNET_SCHEDULER_TaskIdentifier sample_load_task_id; 88struct GNUNET_SCHEDULER_Task * sample_load_task_id;
89 89
90 90
91#ifdef OSX 91#ifdef OSX
@@ -656,7 +656,7 @@ sample_load_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
656 unsigned int mem_usage; 656 unsigned int mem_usage;
657 unsigned int nproc; 657 unsigned int nproc;
658 658
659 sample_load_task_id = GNUNET_SCHEDULER_NO_TASK; 659 sample_load_task_id = NULL;
660 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) 660 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
661 return; 661 return;
662 ld_cpu = cpu_get_load (); 662 ld_cpu = cpu_get_load ();
@@ -767,10 +767,10 @@ GST_stats_destroy ()
767#elif OSX 767#elif OSX
768 GNUNET_free_non_null (prev_cpu_load); 768 GNUNET_free_non_null (prev_cpu_load);
769#endif 769#endif
770 if (GNUNET_SCHEDULER_NO_TASK != sample_load_task_id) 770 if (NULL != sample_load_task_id)
771 { 771 {
772 GNUNET_SCHEDULER_cancel (sample_load_task_id); 772 GNUNET_SCHEDULER_cancel (sample_load_task_id);
773 sample_load_task_id = GNUNET_SCHEDULER_NO_TASK; 773 sample_load_task_id = NULL;
774 } 774 }
775 GNUNET_break (GNUNET_OK == GNUNET_BIO_write_close (bw)); 775 GNUNET_break (GNUNET_OK == GNUNET_BIO_write_close (bw));
776 bw = NULL; 776 bw = NULL;
diff --git a/src/testbed/gnunet-service-testbed_links.c b/src/testbed/gnunet-service-testbed_links.c
index cb908f12b..4c2e6c58a 100644
--- a/src/testbed/gnunet-service-testbed_links.c
+++ b/src/testbed/gnunet-service-testbed_links.c
@@ -92,7 +92,7 @@ struct LCFContext
92 /** 92 /**
93 * The timeout task 93 * The timeout task
94 */ 94 */
95 GNUNET_SCHEDULER_TaskIdentifier timeout_task; 95 struct GNUNET_SCHEDULER_Task * timeout_task;
96 96
97 /** 97 /**
98 * The id of the operation which created this context 98 * The id of the operation which created this context
@@ -206,7 +206,7 @@ struct Neighbour
206 /** 206 /**
207 * Task id for the task to call notifications from the notification list 207 * Task id for the task to call notifications from the notification list
208 */ 208 */
209 GNUNET_SCHEDULER_TaskIdentifier notify_task; 209 struct GNUNET_SCHEDULER_Task * notify_task;
210 210
211 /** 211 /**
212 * How many references are present currently to this neighbour's connection 212 * How many references are present currently to this neighbour's connection
@@ -265,7 +265,7 @@ struct NeighbourConnectCtxt
265 /** 265 /**
266 * Task to be run upon timeout 266 * Task to be run upon timeout
267 */ 267 */
268 GNUNET_SCHEDULER_TaskIdentifier timeout_task; 268 struct GNUNET_SCHEDULER_Task * timeout_task;
269 269
270 /** 270 /**
271 * The notification handle associated with the neighbour's connection request 271 * The notification handle associated with the neighbour's connection request
@@ -317,7 +317,7 @@ static struct LCFContextQueue *lcfq_tail;
317/** 317/**
318 * The lcf_task handle 318 * The lcf_task handle
319 */ 319 */
320static GNUNET_SCHEDULER_TaskIdentifier lcf_proc_task_id; 320static struct GNUNET_SCHEDULER_Task * lcf_proc_task_id;
321 321
322/** 322/**
323 * The size of the route list 323 * The size of the route list
@@ -602,7 +602,7 @@ lcf_proc_cc (void *cls, const char *emsg)
602{ 602{
603 struct LCFContext *lcf = cls; 603 struct LCFContext *lcf = cls;
604 604
605 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id); 605 GNUNET_assert (NULL == lcf_proc_task_id);
606 switch (lcf->state) 606 switch (lcf->state)
607 { 607 {
608 case INIT: 608 case INIT:
@@ -652,14 +652,14 @@ lcf_forwarded_operation_timeout (void *cls,
652{ 652{
653 struct LCFContext *lcf = cls; 653 struct LCFContext *lcf = cls;
654 654
655 lcf->timeout_task = GNUNET_SCHEDULER_NO_TASK; 655 lcf->timeout_task = NULL;
656 // GST_forwarded_operation_timeout (lcf->fopc, tc); 656 // GST_forwarded_operation_timeout (lcf->fopc, tc);
657 LOG (GNUNET_ERROR_TYPE_WARNING, 657 LOG (GNUNET_ERROR_TYPE_WARNING,
658 "A forwarded controller link operation has timed out\n"); 658 "A forwarded controller link operation has timed out\n");
659 send_controller_link_response (lcf->client, lcf->operation_id, NULL, 659 send_controller_link_response (lcf->client, lcf->operation_id, NULL,
660 "A forwarded controller link operation has " 660 "A forwarded controller link operation has "
661 "timed out\n"); 661 "timed out\n");
662 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id); 662 GNUNET_assert (NULL == lcf_proc_task_id);
663 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf); 663 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
664} 664}
665 665
@@ -676,7 +676,7 @@ lcf_proc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
676 struct LCFContext *lcf = cls; 676 struct LCFContext *lcf = cls;
677 struct LCFContextQueue *lcfq; 677 struct LCFContextQueue *lcfq;
678 678
679 lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK; 679 lcf_proc_task_id = NULL;
680 switch (lcf->state) 680 switch (lcf->state)
681 { 681 {
682 case INIT: 682 case INIT:
@@ -753,7 +753,7 @@ slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
753 GNUNET_TESTBED_operation_done (lcf->op); 753 GNUNET_TESTBED_operation_done (lcf->op);
754 lcf->op = NULL; 754 lcf->op = NULL;
755 GNUNET_assert (FINISHED == lcf->state); 755 GNUNET_assert (FINISHED == lcf->state);
756 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task); 756 GNUNET_assert (NULL != lcf->timeout_task);
757 GNUNET_SCHEDULER_cancel (lcf->timeout_task); 757 GNUNET_SCHEDULER_cancel (lcf->timeout_task);
758 if (NULL == event->details.operation_finished.emsg) 758 if (NULL == event->details.operation_finished.emsg)
759 send_controller_link_response (lcf->client, lcf->operation_id, 759 send_controller_link_response (lcf->client, lcf->operation_id,
@@ -764,7 +764,7 @@ slave_event_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
764 send_controller_link_response (lcf->client, lcf->operation_id, 764 send_controller_link_response (lcf->client, lcf->operation_id,
765 NULL, 765 NULL,
766 event->details.operation_finished.emsg); 766 event->details.operation_finished.emsg);
767 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id); 767 GNUNET_assert (NULL == lcf_proc_task_id);
768 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf); 768 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcf);
769 return; 769 return;
770} 770}
@@ -862,8 +862,8 @@ neighbour_connect_notify_task (void *cls,
862 struct NeighbourConnectNotification *h; 862 struct NeighbourConnectNotification *h;
863 863
864 GNUNET_assert (NULL != (h = n->nl_head)); 864 GNUNET_assert (NULL != (h = n->nl_head));
865 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != n->notify_task); 865 GNUNET_assert (NULL != n->notify_task);
866 n->notify_task = GNUNET_SCHEDULER_NO_TASK; 866 n->notify_task = NULL;
867 GNUNET_assert (NULL != n->controller); 867 GNUNET_assert (NULL != n->controller);
868 GNUNET_CONTAINER_DLL_remove (n->nl_head, n->nl_tail, h); 868 GNUNET_CONTAINER_DLL_remove (n->nl_head, n->nl_tail, h);
869 trigger_notifications (n); 869 trigger_notifications (n);
@@ -888,7 +888,7 @@ trigger_notifications (struct Neighbour *n)
888 return; 888 return;
889 if (NULL == n->controller) 889 if (NULL == n->controller)
890 return; 890 return;
891 if (GNUNET_SCHEDULER_NO_TASK != n->notify_task) 891 if (NULL != n->notify_task)
892 return; 892 return;
893 if (1 == n->inactive) 893 if (1 == n->inactive)
894 { 894 {
@@ -936,7 +936,7 @@ oprelease_neighbour_conn (void *cls)
936 struct Neighbour *n = cls; 936 struct Neighbour *n = cls;
937 937
938 GNUNET_assert (0 == n->reference_cnt); 938 GNUNET_assert (0 == n->reference_cnt);
939 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == n->notify_task); 939 GNUNET_assert (NULL == n->notify_task);
940 GNUNET_assert (NULL == n->nl_head); 940 GNUNET_assert (NULL == n->nl_head);
941 if (NULL != n->controller) 941 if (NULL != n->controller)
942 { 942 {
@@ -1006,12 +1006,12 @@ GST_neighbour_get_connection_cancel (struct NeighbourConnectNotification *h)
1006 GNUNET_free (h); 1006 GNUNET_free (h);
1007 if (GNUNET_NO == cleanup_task) 1007 if (GNUNET_NO == cleanup_task)
1008 return; 1008 return;
1009 if (GNUNET_SCHEDULER_NO_TASK == n->notify_task) 1009 if (NULL == n->notify_task)
1010 return; 1010 return;
1011 GNUNET_assert (0 < n->reference_cnt); 1011 GNUNET_assert (0 < n->reference_cnt);
1012 n->reference_cnt--; 1012 n->reference_cnt--;
1013 GNUNET_SCHEDULER_cancel (n->notify_task); 1013 GNUNET_SCHEDULER_cancel (n->notify_task);
1014 n->notify_task = GNUNET_SCHEDULER_NO_TASK; 1014 n->notify_task = NULL;
1015 if (NULL == n->nl_head) 1015 if (NULL == n->nl_head)
1016 { 1016 {
1017 if ( (0 == n->reference_cnt) && (0 == n->inactive) ) 1017 if ( (0 == n->reference_cnt) && (0 == n->inactive) )
@@ -1056,7 +1056,7 @@ cleanup_ncc (struct NeighbourConnectCtxt *ncc)
1056{ 1056{
1057 if (NULL != ncc->nh) 1057 if (NULL != ncc->nh)
1058 GST_neighbour_get_connection_cancel (ncc->nh); 1058 GST_neighbour_get_connection_cancel (ncc->nh);
1059 if (GNUNET_SCHEDULER_NO_TASK != ncc->timeout_task) 1059 if (NULL != ncc->timeout_task)
1060 GNUNET_SCHEDULER_cancel (ncc->timeout_task); 1060 GNUNET_SCHEDULER_cancel (ncc->timeout_task);
1061 GNUNET_SERVER_client_drop (ncc->client); 1061 GNUNET_SERVER_client_drop (ncc->client);
1062 GNUNET_CONTAINER_DLL_remove (ncc_head, ncc_tail, ncc); 1062 GNUNET_CONTAINER_DLL_remove (ncc_head, ncc_tail, ncc);
@@ -1126,7 +1126,7 @@ timeout_neighbour_connect (void *cls,
1126{ 1126{
1127 struct NeighbourConnectCtxt *ncc = cls; 1127 struct NeighbourConnectCtxt *ncc = cls;
1128 1128
1129 ncc->timeout_task = GNUNET_SCHEDULER_NO_TASK; 1129 ncc->timeout_task = NULL;
1130 send_controller_link_response (ncc->client, ncc->op_id, NULL, 1130 send_controller_link_response (ncc->client, ncc->op_id, NULL,
1131 "Could not connect to delegated controller"); 1131 "Could not connect to delegated controller");
1132 cleanup_ncc (ncc); 1132 cleanup_ncc (ncc);
@@ -1145,7 +1145,7 @@ neighbour_connect_cb (void *cls, struct GNUNET_TESTBED_Controller *c)
1145 struct NeighbourConnectCtxt *ncc = cls; 1145 struct NeighbourConnectCtxt *ncc = cls;
1146 1146
1147 GNUNET_SCHEDULER_cancel (ncc->timeout_task); 1147 GNUNET_SCHEDULER_cancel (ncc->timeout_task);
1148 ncc->timeout_task = GNUNET_SCHEDULER_NO_TASK; 1148 ncc->timeout_task = NULL;
1149 ncc->nh = NULL; 1149 ncc->nh = NULL;
1150 GST_neighbour_release_connection (ncc->n); 1150 GST_neighbour_release_connection (ncc->n);
1151 send_controller_link_response (ncc->client, ncc->op_id, NULL, NULL); 1151 send_controller_link_response (ncc->client, ncc->op_id, NULL, NULL);
@@ -1314,7 +1314,7 @@ GST_handle_link_controllers (void *cls, struct GNUNET_SERVER_Client *client,
1314 lcfq->lcf->client = client; 1314 lcfq->lcf->client = client;
1315 if (NULL == lcfq_head) 1315 if (NULL == lcfq_head)
1316 { 1316 {
1317 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id); 1317 GNUNET_assert (NULL == lcf_proc_task_id);
1318 GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq); 1318 GNUNET_CONTAINER_DLL_insert_tail (lcfq_head, lcfq_tail, lcfq);
1319 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq->lcf); 1319 lcf_proc_task_id = GNUNET_SCHEDULER_add_now (&lcf_proc_task, lcfq->lcf);
1320 } 1320 }
@@ -1354,20 +1354,20 @@ GST_free_lcfq ()
1354 1354
1355 if (NULL != lcfq_head) 1355 if (NULL != lcfq_head)
1356 { 1356 {
1357 if (GNUNET_SCHEDULER_NO_TASK != lcf_proc_task_id) 1357 if (NULL != lcf_proc_task_id)
1358 { 1358 {
1359 GNUNET_SCHEDULER_cancel (lcf_proc_task_id); 1359 GNUNET_SCHEDULER_cancel (lcf_proc_task_id);
1360 lcf_proc_task_id = GNUNET_SCHEDULER_NO_TASK; 1360 lcf_proc_task_id = NULL;
1361 } 1361 }
1362 } 1362 }
1363 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == lcf_proc_task_id); 1363 GNUNET_assert (NULL == lcf_proc_task_id);
1364 for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head) 1364 for (lcfq = lcfq_head; NULL != lcfq; lcfq = lcfq_head)
1365 { 1365 {
1366 lcf = lcfq->lcf; 1366 lcf = lcfq->lcf;
1367 GNUNET_SERVER_client_drop (lcf->client); 1367 GNUNET_SERVER_client_drop (lcf->client);
1368 if (NULL != lcf->op) 1368 if (NULL != lcf->op)
1369 GNUNET_TESTBED_operation_done (lcf->op); 1369 GNUNET_TESTBED_operation_done (lcf->op);
1370 if (GNUNET_SCHEDULER_NO_TASK != lcf->timeout_task) 1370 if (NULL != lcf->timeout_task)
1371 GNUNET_SCHEDULER_cancel (lcf->timeout_task); 1371 GNUNET_SCHEDULER_cancel (lcf->timeout_task);
1372 GNUNET_free (lcf); 1372 GNUNET_free (lcf);
1373 GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq); 1373 GNUNET_CONTAINER_DLL_remove (lcfq_head, lcfq_tail, lcfq);
diff --git a/src/testbed/gnunet-service-testbed_oc.c b/src/testbed/gnunet-service-testbed_oc.c
index c2978728c..c331fb8f0 100644
--- a/src/testbed/gnunet-service-testbed_oc.c
+++ b/src/testbed/gnunet-service-testbed_oc.c
@@ -65,7 +65,7 @@ struct TryConnectContext
65 /** 65 /**
66 * The task handle 66 * The task handle
67 */ 67 */
68 GNUNET_SCHEDULER_TaskIdentifier task; 68 struct GNUNET_SCHEDULER_Task * task;
69 69
70 /** 70 /**
71 * The id of the operation which is resposible for this context 71 * The id of the operation which is resposible for this context
@@ -250,17 +250,17 @@ struct OverlayConnectContext
250 * The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to 250 * The id of the task for sending HELLO of peer 2 to peer 1 and ask peer 1 to
251 * connect to peer 2 251 * connect to peer 2
252 */ 252 */
253 GNUNET_SCHEDULER_TaskIdentifier send_hello_task; 253 struct GNUNET_SCHEDULER_Task * send_hello_task;
254 254
255 /** 255 /**
256 * The id of the overlay connect timeout task 256 * The id of the overlay connect timeout task
257 */ 257 */
258 GNUNET_SCHEDULER_TaskIdentifier timeout_task; 258 struct GNUNET_SCHEDULER_Task * timeout_task;
259 259
260 /** 260 /**
261 * The id of the cleanup task 261 * The id of the cleanup task
262 */ 262 */
263 GNUNET_SCHEDULER_TaskIdentifier cleanup_task; 263 struct GNUNET_SCHEDULER_Task * cleanup_task;
264 264
265 /** 265 /**
266 * The type of this context information 266 * The type of this context information
@@ -321,12 +321,12 @@ struct RemoteOverlayConnectCtx
321 /** 321 /**
322 * Task for offering HELLO of A to B and doing try_connect 322 * Task for offering HELLO of A to B and doing try_connect
323 */ 323 */
324 GNUNET_SCHEDULER_TaskIdentifier attempt_connect_task_id; 324 struct GNUNET_SCHEDULER_Task * attempt_connect_task_id;
325 325
326 /** 326 /**
327 * Task to timeout RequestOverlayConnect 327 * Task to timeout RequestOverlayConnect
328 */ 328 */
329 GNUNET_SCHEDULER_TaskIdentifier timeout_rocc_task_id; 329 struct GNUNET_SCHEDULER_Task * timeout_rocc_task_id;
330 330
331 /** 331 /**
332 * The id of the operation responsible for creating this context 332 * The id of the operation responsible for creating this context
@@ -478,7 +478,7 @@ cleanup_occ_lp2c (struct LocalPeer2Context *lp2c)
478 GST_connection_pool_get_handle_done (lp2c->tcc.cgh_th); 478 GST_connection_pool_get_handle_done (lp2c->tcc.cgh_th);
479 if (NULL != lp2c->tcc.tch) 479 if (NULL != lp2c->tcc.tch)
480 GNUNET_TRANSPORT_try_connect_cancel (lp2c->tcc.tch); 480 GNUNET_TRANSPORT_try_connect_cancel (lp2c->tcc.tch);
481 if (GNUNET_SCHEDULER_NO_TASK != lp2c->tcc.task) 481 if (NULL != lp2c->tcc.task)
482 GNUNET_SCHEDULER_cancel (lp2c->tcc.task); 482 GNUNET_SCHEDULER_cancel (lp2c->tcc.task);
483} 483}
484 484
@@ -523,11 +523,11 @@ cleanup_occ (struct OverlayConnectContext *occ)
523 GNUNET_free_non_null (occ->emsg); 523 GNUNET_free_non_null (occ->emsg);
524 GNUNET_free_non_null (occ->hello); 524 GNUNET_free_non_null (occ->hello);
525 GNUNET_SERVER_client_drop (occ->client); 525 GNUNET_SERVER_client_drop (occ->client);
526 if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task) 526 if (NULL != occ->send_hello_task)
527 GNUNET_SCHEDULER_cancel (occ->send_hello_task); 527 GNUNET_SCHEDULER_cancel (occ->send_hello_task);
528 if (GNUNET_SCHEDULER_NO_TASK != occ->cleanup_task) 528 if (NULL != occ->cleanup_task)
529 GNUNET_SCHEDULER_cancel (occ->cleanup_task); 529 GNUNET_SCHEDULER_cancel (occ->cleanup_task);
530 if (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task) 530 if (NULL != occ->timeout_task)
531 GNUNET_SCHEDULER_cancel (occ->timeout_task); 531 GNUNET_SCHEDULER_cancel (occ->timeout_task);
532 if (NULL != occ->cgh_ch) 532 if (NULL != occ->cgh_ch)
533 GST_connection_pool_get_handle_done (occ->cgh_ch); 533 GST_connection_pool_get_handle_done (occ->cgh_ch);
@@ -571,7 +571,7 @@ do_cleanup_occ (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
571{ 571{
572 struct OverlayConnectContext *occ = cls; 572 struct OverlayConnectContext *occ = cls;
573 573
574 occ->cleanup_task = GNUNET_SCHEDULER_NO_TASK; 574 occ->cleanup_task = NULL;
575 cleanup_occ (occ); 575 cleanup_occ (occ);
576} 576}
577 577
@@ -588,8 +588,8 @@ timeout_overlay_connect (void *cls,
588{ 588{
589 struct OverlayConnectContext *occ = cls; 589 struct OverlayConnectContext *occ = cls;
590 590
591 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); 591 GNUNET_assert (NULL != occ->timeout_task);
592 occ->timeout_task = GNUNET_SCHEDULER_NO_TASK; 592 occ->timeout_task = NULL;
593 /* LOG (GNUNET_ERROR_TYPE_WARNING, */ 593 /* LOG (GNUNET_ERROR_TYPE_WARNING, */
594 /* "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */ 594 /* "0x%llx: Timeout while connecting peers %u and %u: %s\n", occ->op_id, */
595 /* occ->peer->id, occ->other_peer_id, occ->emsg); */ 595 /* occ->peer->id, occ->other_peer_id, occ->emsg); */
@@ -653,21 +653,21 @@ overlay_connect_notify (void *cls, const struct GNUNET_PeerIdentity *new_peer)
653 LOG_DEBUG ("0x%llx: Peer %4s connected to peer %4s\n", occ->op_id, 653 LOG_DEBUG ("0x%llx: Peer %4s connected to peer %4s\n", occ->op_id,
654 other_peer_str, GNUNET_i2s (&occ->peer_identity)); 654 other_peer_str, GNUNET_i2s (&occ->peer_identity));
655 GNUNET_free (other_peer_str); 655 GNUNET_free (other_peer_str);
656 if (GNUNET_SCHEDULER_NO_TASK != occ->send_hello_task) 656 if (NULL != occ->send_hello_task)
657 { 657 {
658 GNUNET_SCHEDULER_cancel (occ->send_hello_task); 658 GNUNET_SCHEDULER_cancel (occ->send_hello_task);
659 occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK; 659 occ->send_hello_task = NULL;
660 } 660 }
661 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); 661 GNUNET_assert (NULL != occ->timeout_task);
662 GNUNET_SCHEDULER_cancel (occ->timeout_task); 662 GNUNET_SCHEDULER_cancel (occ->timeout_task);
663 occ->timeout_task = GNUNET_SCHEDULER_NO_TASK; 663 occ->timeout_task = NULL;
664 if (OCC_TYPE_LOCAL == occ->type) 664 if (OCC_TYPE_LOCAL == occ->type)
665 { 665 {
666 lp2c = &occ->p2ctx.local; 666 lp2c = &occ->p2ctx.local;
667 if (GNUNET_SCHEDULER_NO_TASK != lp2c->tcc.task) 667 if (NULL != lp2c->tcc.task)
668 { 668 {
669 GNUNET_SCHEDULER_cancel (lp2c->tcc.task); 669 GNUNET_SCHEDULER_cancel (lp2c->tcc.task);
670 lp2c->tcc.task = GNUNET_SCHEDULER_NO_TASK; 670 lp2c->tcc.task = NULL;
671 } 671 }
672 } 672 }
673 GNUNET_free_non_null (occ->emsg); 673 GNUNET_free_non_null (occ->emsg);
@@ -700,7 +700,7 @@ try_connect_cb (void *cls, const int result)
700 struct TryConnectContext *tcc = cls; 700 struct TryConnectContext *tcc = cls;
701 701
702 tcc->tch = NULL; 702 tcc->tch = NULL;
703 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == tcc->task); 703 GNUNET_assert (NULL == tcc->task);
704 tcc->task = 704 tcc->task =
705 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply 705 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
706 (GNUNET_TIME_UNIT_MILLISECONDS, 706 (GNUNET_TIME_UNIT_MILLISECONDS,
@@ -720,7 +720,7 @@ try_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
720{ 720{
721 struct TryConnectContext *tcc = cls; 721 struct TryConnectContext *tcc = cls;
722 722
723 tcc->task = GNUNET_SCHEDULER_NO_TASK; 723 tcc->task = NULL;
724 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason)) 724 if (0 != (GNUNET_SCHEDULER_REASON_SHUTDOWN & tc->reason))
725 return; 725 return;
726 GNUNET_assert (NULL == tcc->tch); 726 GNUNET_assert (NULL == tcc->tch);
@@ -762,7 +762,7 @@ occ_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
762 GNUNET_assert (OCC_TYPE_LOCAL == occ->type); 762 GNUNET_assert (OCC_TYPE_LOCAL == occ->type);
763 lp2c = &occ->p2ctx.local; 763 lp2c = &occ->p2ctx.local;
764 lp2c->ohh = NULL; 764 lp2c->ohh = NULL;
765 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->send_hello_task); 765 GNUNET_assert (NULL == occ->send_hello_task);
766 if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason) 766 if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason)
767 { 767 {
768 GNUNET_free_non_null (occ->emsg); 768 GNUNET_free_non_null (occ->emsg);
@@ -839,7 +839,7 @@ send_hello (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
839 struct LocalPeer2Context *lp2c; 839 struct LocalPeer2Context *lp2c;
840 char *other_peer_str; 840 char *other_peer_str;
841 841
842 occ->send_hello_task = GNUNET_SCHEDULER_NO_TASK; 842 occ->send_hello_task = NULL;
843 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) 843 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
844 return; 844 return;
845 GNUNET_assert (NULL != occ->hello); 845 GNUNET_assert (NULL != occ->hello);
@@ -1048,7 +1048,7 @@ occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch,
1048 struct OverlayConnectContext *occ = cls; 1048 struct OverlayConnectContext *occ = cls;
1049 const struct GNUNET_MessageHeader *hello; 1049 const struct GNUNET_MessageHeader *hello;
1050 1050
1051 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); 1051 GNUNET_assert (NULL != occ->timeout_task);
1052 GNUNET_free_non_null (occ->emsg); 1052 GNUNET_free_non_null (occ->emsg);
1053 if ((NULL == ch) || (NULL == my_identity)) 1053 if ((NULL == ch) || (NULL == my_identity))
1054 { 1054 {
@@ -1066,7 +1066,7 @@ occ_cache_get_handle_core_cb (void *cls, struct GNUNET_CORE_Handle *ch,
1066 { 1066 {
1067 LOG_DEBUG ("0x%llx: Target peer already connected\n", occ->op_id); 1067 LOG_DEBUG ("0x%llx: Target peer already connected\n", occ->op_id);
1068 GNUNET_SCHEDULER_cancel (occ->timeout_task); 1068 GNUNET_SCHEDULER_cancel (occ->timeout_task);
1069 occ->timeout_task = GNUNET_SCHEDULER_NO_TASK; 1069 occ->timeout_task = NULL;
1070 send_overlay_connect_success_msg (occ); 1070 send_overlay_connect_success_msg (occ);
1071 occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ); 1071 occ->cleanup_task = GNUNET_SCHEDULER_add_now (&do_cleanup_occ, occ);
1072 return; 1072 return;
@@ -1114,7 +1114,7 @@ overlay_connect_get_config (void *cls, const struct GNUNET_MessageHeader *msg)
1114 GNUNET_assert (OCC_TYPE_LOCAL != occ->type); 1114 GNUNET_assert (OCC_TYPE_LOCAL != occ->type);
1115 rp2c = &occ->p2ctx.remote; 1115 rp2c = &occ->p2ctx.remote;
1116 rp2c->opc = NULL; 1116 rp2c->opc = NULL;
1117 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != occ->timeout_task); 1117 GNUNET_assert (NULL != occ->timeout_task);
1118 if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION != ntohs (msg->type)) 1118 if (GNUNET_MESSAGE_TYPE_TESTBED_PEER_INFORMATION != ntohs (msg->type))
1119 { 1119 {
1120 GNUNET_SCHEDULER_cancel (occ->timeout_task); 1120 GNUNET_SCHEDULER_cancel (occ->timeout_task);
@@ -1462,7 +1462,7 @@ GST_handle_overlay_connect (void *cls, struct GNUNET_SERVER_Client *client,
1462 GST_peer_list[p1]->reference_cnt++; 1462 GST_peer_list[p1]->reference_cnt++;
1463 occ->peer = GST_peer_list[p1]; 1463 occ->peer = GST_peer_list[p1];
1464 occ->op_id = operation_id; 1464 occ->op_id = operation_id;
1465 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == occ->timeout_task); 1465 GNUNET_assert (NULL == occ->timeout_task);
1466 occ->timeout_task = 1466 occ->timeout_task =
1467 GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_overlay_connect, occ); 1467 GNUNET_SCHEDULER_add_delayed (GST_timeout, &timeout_overlay_connect, occ);
1468 switch (occ->type) 1468 switch (occ->type)
@@ -1508,15 +1508,15 @@ static void
1508cleanup_rocc (struct RemoteOverlayConnectCtx *rocc) 1508cleanup_rocc (struct RemoteOverlayConnectCtx *rocc)
1509{ 1509{
1510 LOG_DEBUG ("0x%llx: Cleaning up rocc\n", rocc->op_id); 1510 LOG_DEBUG ("0x%llx: Cleaning up rocc\n", rocc->op_id);
1511 if (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id) 1511 if (NULL != rocc->attempt_connect_task_id)
1512 GNUNET_SCHEDULER_cancel (rocc->attempt_connect_task_id); 1512 GNUNET_SCHEDULER_cancel (rocc->attempt_connect_task_id);
1513 if (GNUNET_SCHEDULER_NO_TASK != rocc->timeout_rocc_task_id) 1513 if (NULL != rocc->timeout_rocc_task_id)
1514 GNUNET_SCHEDULER_cancel (rocc->timeout_rocc_task_id); 1514 GNUNET_SCHEDULER_cancel (rocc->timeout_rocc_task_id);
1515 if (NULL != rocc->ohh) 1515 if (NULL != rocc->ohh)
1516 GNUNET_TRANSPORT_offer_hello_cancel (rocc->ohh); 1516 GNUNET_TRANSPORT_offer_hello_cancel (rocc->ohh);
1517 if (NULL != rocc->tcc.tch) 1517 if (NULL != rocc->tcc.tch)
1518 GNUNET_TRANSPORT_try_connect_cancel (rocc->tcc.tch); 1518 GNUNET_TRANSPORT_try_connect_cancel (rocc->tcc.tch);
1519 if (GNUNET_SCHEDULER_NO_TASK != rocc->tcc.task) 1519 if (NULL != rocc->tcc.task)
1520 GNUNET_SCHEDULER_cancel (rocc->tcc.task); 1520 GNUNET_SCHEDULER_cancel (rocc->tcc.task);
1521 GST_connection_pool_get_handle_done (rocc->tcc.cgh_th); 1521 GST_connection_pool_get_handle_done (rocc->tcc.cgh_th);
1522 GNUNET_assert (rocc->peer->reference_cnt > 0); 1522 GNUNET_assert (rocc->peer->reference_cnt > 0);
@@ -1541,8 +1541,8 @@ timeout_rocc_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1541{ 1541{
1542 struct RemoteOverlayConnectCtx *rocc = cls; 1542 struct RemoteOverlayConnectCtx *rocc = cls;
1543 1543
1544 GNUNET_assert (rocc->timeout_rocc_task_id != GNUNET_SCHEDULER_NO_TASK); 1544 GNUNET_assert (rocc->timeout_rocc_task_id != NULL);
1545 rocc->timeout_rocc_task_id = GNUNET_SCHEDULER_NO_TASK; 1545 rocc->timeout_rocc_task_id = NULL;
1546 LOG_DEBUG ("0x%llx: rocc timed out\n", rocc->op_id); 1546 LOG_DEBUG ("0x%llx: rocc timed out\n", rocc->op_id);
1547 cleanup_rocc (rocc); 1547 cleanup_rocc (rocc);
1548} 1548}
@@ -1596,7 +1596,7 @@ rocc_hello_sent_cb (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1596 struct RemoteOverlayConnectCtx *rocc = cls; 1596 struct RemoteOverlayConnectCtx *rocc = cls;
1597 1597
1598 rocc->ohh = NULL; 1598 rocc->ohh = NULL;
1599 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rocc->attempt_connect_task_id); 1599 GNUNET_assert (NULL == rocc->attempt_connect_task_id);
1600 LOG_DEBUG ("0x%llx: HELLO of peer %4s sent to local peer with id: %u\n", 1600 LOG_DEBUG ("0x%llx: HELLO of peer %4s sent to local peer with id: %u\n",
1601 rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id); 1601 rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id);
1602 if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason) 1602 if (GNUNET_SCHEDULER_REASON_TIMEOUT == tc->reason)
@@ -1627,8 +1627,8 @@ attempt_connect_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1627{ 1627{
1628 struct RemoteOverlayConnectCtx *rocc = cls; 1628 struct RemoteOverlayConnectCtx *rocc = cls;
1629 1629
1630 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != rocc->attempt_connect_task_id); 1630 GNUNET_assert (NULL != rocc->attempt_connect_task_id);
1631 rocc->attempt_connect_task_id = GNUNET_SCHEDULER_NO_TASK; 1631 rocc->attempt_connect_task_id = NULL;
1632 LOG_DEBUG ("0x%llx: Offering HELLO of peer %4s to local peer with id: %u\n", 1632 LOG_DEBUG ("0x%llx: Offering HELLO of peer %4s to local peer with id: %u\n",
1633 rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id); 1633 rocc->op_id, GNUNET_i2s (&rocc->a_id), rocc->peer->id);
1634 rocc->ohh = 1634 rocc->ohh =
diff --git a/src/testbed/gnunet-testbed-profiler.c b/src/testbed/gnunet-testbed-profiler.c
index 17f1d6ba9..c45a6b0e2 100644
--- a/src/testbed/gnunet-testbed-profiler.c
+++ b/src/testbed/gnunet-testbed-profiler.c
@@ -55,12 +55,12 @@ static char *hosts_file;
55/** 55/**
56 * Abort task identifier 56 * Abort task identifier
57 */ 57 */
58static GNUNET_SCHEDULER_TaskIdentifier abort_task; 58static struct GNUNET_SCHEDULER_Task * abort_task;
59 59
60/** 60/**
61 * Shutdown task identifier 61 * Shutdown task identifier
62 */ 62 */
63static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 63static struct GNUNET_SCHEDULER_Task * shutdown_task;
64 64
65/** 65/**
66 * Global event mask for all testbed events 66 * Global event mask for all testbed events
@@ -112,11 +112,11 @@ static int noninteractive;
112static void 112static void
113do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 113do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
114{ 114{
115 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 115 shutdown_task = NULL;
116 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 116 if (NULL != abort_task)
117 { 117 {
118 GNUNET_SCHEDULER_cancel (abort_task); 118 GNUNET_SCHEDULER_cancel (abort_task);
119 abort_task = GNUNET_SCHEDULER_NO_TASK; 119 abort_task = NULL;
120 } 120 }
121 if (NULL != cfg) 121 if (NULL != cfg)
122 { 122 {
@@ -137,9 +137,9 @@ static void
137do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 137do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
138{ 138{
139 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n"); 139 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n");
140 abort_task = GNUNET_SCHEDULER_NO_TASK; 140 abort_task = NULL;
141 result = GNUNET_SYSERR; 141 result = GNUNET_SYSERR;
142 if (GNUNET_SCHEDULER_NO_TASK != shutdown_task) 142 if (NULL != shutdown_task)
143 GNUNET_SCHEDULER_cancel (shutdown_task); 143 GNUNET_SCHEDULER_cancel (shutdown_task);
144 shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 144 shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
145} 145}
@@ -185,7 +185,7 @@ controller_event_cb (void *cls,
185 { 185 {
186 printf ("\nAborting due to very high failure rate\n"); 186 printf ("\nAborting due to very high failure rate\n");
187 print_overlay_links_summary (); 187 print_overlay_links_summary ();
188 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 188 if (NULL != abort_task)
189 GNUNET_SCHEDULER_cancel (abort_task); 189 GNUNET_SCHEDULER_cancel (abort_task);
190 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); 190 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
191 return; 191 return;
@@ -233,7 +233,7 @@ test_run (void *cls,
233 if (noninteractive) 233 if (noninteractive)
234 { 234 {
235 GNUNET_SCHEDULER_cancel (abort_task); 235 GNUNET_SCHEDULER_cancel (abort_task);
236 abort_task = GNUNET_SCHEDULER_NO_TASK; 236 abort_task = NULL;
237 shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, 237 shutdown_task = GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
238 &do_shutdown, NULL); 238 &do_shutdown, NULL);
239 return; 239 return;
diff --git a/src/testbed/gnunet_testbed_mpi_spawn.c b/src/testbed/gnunet_testbed_mpi_spawn.c
index 41d805471..3fb50cb8f 100644
--- a/src/testbed/gnunet_testbed_mpi_spawn.c
+++ b/src/testbed/gnunet_testbed_mpi_spawn.c
@@ -58,17 +58,17 @@ static enum GNUNET_OS_ProcessStatusType child_status;
58/** 58/**
59 * The shutdown task 59 * The shutdown task
60 */ 60 */
61static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; 61static struct GNUNET_SCHEDULER_Task * shutdown_task_id;
62 62
63/** 63/**
64 * Task to kill the child 64 * Task to kill the child
65 */ 65 */
66static GNUNET_SCHEDULER_TaskIdentifier terminate_task_id; 66static struct GNUNET_SCHEDULER_Task * terminate_task_id;
67 67
68/** 68/**
69 * Task to kill the child 69 * Task to kill the child
70 */ 70 */
71static GNUNET_SCHEDULER_TaskIdentifier child_death_task_id; 71static struct GNUNET_SCHEDULER_Task * child_death_task_id;
72 72
73/** 73/**
74 * The shutdown task 74 * The shutdown task
@@ -76,7 +76,7 @@ static GNUNET_SCHEDULER_TaskIdentifier child_death_task_id;
76static void 76static void
77shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 77shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
78{ 78{
79 shutdown_task_id = GNUNET_SCHEDULER_NO_TASK; 79 shutdown_task_id = NULL;
80 if (0 != child_exit_code) 80 if (0 != child_exit_code)
81 { 81 {
82 LOG (GNUNET_ERROR_TYPE_WARNING, "Child exited with error code: %lu\n", 82 LOG (GNUNET_ERROR_TYPE_WARNING, "Child exited with error code: %lu\n",
@@ -140,7 +140,7 @@ child_death_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
140 char c[16]; 140 char c[16];
141 141
142 pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); 142 pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ);
143 child_death_task_id = GNUNET_SCHEDULER_NO_TASK; 143 child_death_task_id = NULL;
144 if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) 144 if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY))
145 { 145 {
146 child_death_task_id = 146 child_death_task_id =
@@ -152,7 +152,7 @@ child_death_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
152 GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c))); 152 GNUNET_break (0 < GNUNET_DISK_file_read (pr, &c, sizeof (c)));
153 LOG_DEBUG ("Child died\n"); 153 LOG_DEBUG ("Child died\n");
154 GNUNET_SCHEDULER_cancel (terminate_task_id); 154 GNUNET_SCHEDULER_cancel (terminate_task_id);
155 terminate_task_id = GNUNET_SCHEDULER_NO_TASK; 155 terminate_task_id = NULL;
156 GNUNET_assert (GNUNET_OK == GNUNET_OS_process_status (child, &child_status, 156 GNUNET_assert (GNUNET_OK == GNUNET_OS_process_status (child, &child_status,
157 &child_exit_code)); 157 &child_exit_code));
158 GNUNET_OS_process_destroy (child); 158 GNUNET_OS_process_destroy (child);
diff --git a/src/testbed/test_gnunet_helper_testbed.c b/src/testbed/test_gnunet_helper_testbed.c
index cf4559c26..43177c894 100644
--- a/src/testbed/test_gnunet_helper_testbed.c
+++ b/src/testbed/test_gnunet_helper_testbed.c
@@ -58,12 +58,12 @@ static struct GNUNET_HELPER_SendHandle *shandle;
58/** 58/**
59 * Abort task identifier 59 * Abort task identifier
60 */ 60 */
61static GNUNET_SCHEDULER_TaskIdentifier abort_task; 61static struct GNUNET_SCHEDULER_Task * abort_task;
62 62
63/** 63/**
64 * Shutdown task identifier 64 * Shutdown task identifier
65 */ 65 */
66static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 66static struct GNUNET_SCHEDULER_Task * shutdown_task;
67 67
68/** 68/**
69 * Configuratin handler 69 * Configuratin handler
@@ -85,7 +85,7 @@ static int result;
85static void 85static void
86do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 86do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
87{ 87{
88 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 88 if (NULL != abort_task)
89 GNUNET_SCHEDULER_cancel (abort_task); 89 GNUNET_SCHEDULER_cancel (abort_task);
90 if (NULL != helper) 90 if (NULL != helper)
91 GNUNET_HELPER_stop (helper, GNUNET_NO); 91 GNUNET_HELPER_stop (helper, GNUNET_NO);
@@ -104,12 +104,12 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
104static void 104static void
105do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 105do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
106{ 106{
107 abort_task = GNUNET_SCHEDULER_NO_TASK; 107 abort_task = NULL;
108 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 108 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
109 result = GNUNET_SYSERR; 109 result = GNUNET_SYSERR;
110 if (NULL != shandle) 110 if (NULL != shandle)
111 GNUNET_HELPER_send_cancel (shandle); 111 GNUNET_HELPER_send_cancel (shandle);
112 if (GNUNET_SCHEDULER_NO_TASK == shutdown_task) 112 if (NULL == shutdown_task)
113 shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 113 shutdown_task = GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
114} 114}
115 115
@@ -167,7 +167,7 @@ mst_cb (void *cls, void *client, const struct GNUNET_MessageHeader *message)
167 uncompress ((Bytef *) config, &config_size, 167 uncompress ((Bytef *) config, &config_size,
168 (const Bytef *) &msg[1], xconfig_size)); 168 (const Bytef *) &msg[1], xconfig_size));
169 GNUNET_free (config); 169 GNUNET_free (config);
170 if (GNUNET_SCHEDULER_NO_TASK == shutdown_task) 170 if (NULL == shutdown_task)
171 shutdown_task = 171 shutdown_task =
172 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply 172 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
173 (GNUNET_TIME_UNIT_SECONDS, 1), 173 (GNUNET_TIME_UNIT_SECONDS, 1),
diff --git a/src/testbed/test_testbed_api.c b/src/testbed/test_testbed_api.c
index 47caa06f3..980b3725f 100644
--- a/src/testbed/test_testbed_api.c
+++ b/src/testbed/test_testbed_api.c
@@ -90,7 +90,7 @@ static struct GNUNET_ARM_Handle *arm_handle;
90/** 90/**
91 * Abort task identifier 91 * Abort task identifier
92 */ 92 */
93static GNUNET_SCHEDULER_TaskIdentifier abort_task; 93static struct GNUNET_SCHEDULER_Task * abort_task;
94 94
95/** 95/**
96 * The testing result 96 * The testing result
@@ -139,7 +139,7 @@ static void
139do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 139do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
140{ 140{
141 LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down...\n"); 141 LOG (GNUNET_ERROR_TYPE_DEBUG, "Shutting down...\n");
142 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 142 if (NULL != abort_task)
143 GNUNET_SCHEDULER_cancel (abort_task); 143 GNUNET_SCHEDULER_cancel (abort_task);
144 if (NULL != reg_handle) 144 if (NULL != reg_handle)
145 GNUNET_TESTBED_cancel_registration (reg_handle); 145 GNUNET_TESTBED_cancel_registration (reg_handle);
@@ -162,9 +162,9 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
162#define FAIL_TEST(cond, ret) do { \ 162#define FAIL_TEST(cond, ret) do { \
163 if (!(cond)) { \ 163 if (!(cond)) { \
164 GNUNET_break(0); \ 164 GNUNET_break(0); \
165 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 165 if (NULL != abort_task) \
166 GNUNET_SCHEDULER_cancel (abort_task); \ 166 GNUNET_SCHEDULER_cancel (abort_task); \
167 abort_task = GNUNET_SCHEDULER_NO_TASK; \ 167 abort_task = NULL; \
168 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \ 168 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \
169 ret; \ 169 ret; \
170 } \ 170 } \
@@ -181,7 +181,7 @@ static void
181do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 181do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
182{ 182{
183 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 183 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
184 abort_task = GNUNET_SCHEDULER_NO_TASK; 184 abort_task = NULL;
185 do_shutdown (cls, tc); 185 do_shutdown (cls, tc);
186} 186}
187 187
diff --git a/src/testbed/test_testbed_api_2peers_1controller.c b/src/testbed/test_testbed_api_2peers_1controller.c
index 18bff91e9..64963c1a7 100644
--- a/src/testbed/test_testbed_api_2peers_1controller.c
+++ b/src/testbed/test_testbed_api_2peers_1controller.c
@@ -112,12 +112,12 @@ static struct GNUNET_TESTBED_Operation *common_operation;
112/** 112/**
113 * Abort task identifier 113 * Abort task identifier
114 */ 114 */
115static GNUNET_SCHEDULER_TaskIdentifier abort_task; 115static struct GNUNET_SCHEDULER_Task * abort_task;
116 116
117/** 117/**
118 * Delayed connect job identifier 118 * Delayed connect job identifier
119 */ 119 */
120static GNUNET_SCHEDULER_TaskIdentifier delayed_connect_task; 120static struct GNUNET_SCHEDULER_Task * delayed_connect_task;
121 121
122/** 122/**
123 * Different stages in testing 123 * Different stages in testing
@@ -173,9 +173,9 @@ static enum Stage result;
173#define FAIL_TEST(cond) do { \ 173#define FAIL_TEST(cond) do { \
174 if (!(cond)) { \ 174 if (!(cond)) { \
175 GNUNET_break(0); \ 175 GNUNET_break(0); \
176 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 176 if (NULL != abort_task) \
177 GNUNET_SCHEDULER_cancel (abort_task); \ 177 GNUNET_SCHEDULER_cancel (abort_task); \
178 abort_task = GNUNET_SCHEDULER_NO_TASK; \ 178 abort_task = NULL; \
179 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \ 179 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \
180 return; \ 180 return; \
181 } \ 181 } \
@@ -191,9 +191,9 @@ static enum Stage result;
191static void 191static void
192do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 192do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
193{ 193{
194 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 194 if (NULL != abort_task)
195 GNUNET_SCHEDULER_cancel (abort_task); 195 GNUNET_SCHEDULER_cancel (abort_task);
196 if (GNUNET_SCHEDULER_NO_TASK != delayed_connect_task) 196 if (NULL != delayed_connect_task)
197 GNUNET_SCHEDULER_cancel (delayed_connect_task); 197 GNUNET_SCHEDULER_cancel (delayed_connect_task);
198 if (NULL != reg_handle) 198 if (NULL != reg_handle)
199 GNUNET_TESTBED_cancel_registration (reg_handle); 199 GNUNET_TESTBED_cancel_registration (reg_handle);
@@ -216,7 +216,7 @@ static void
216do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 216do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
217{ 217{
218 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 218 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
219 abort_task = GNUNET_SCHEDULER_NO_TASK; 219 abort_task = NULL;
220 do_shutdown (cls, tc); 220 do_shutdown (cls, tc);
221} 221}
222 222
@@ -242,7 +242,7 @@ op_comp_cb (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg);
242static void 242static void
243do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 243do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
244{ 244{
245 delayed_connect_task = GNUNET_SCHEDULER_NO_TASK; 245 delayed_connect_task = NULL;
246 FAIL_TEST (NULL == common_operation); 246 FAIL_TEST (NULL == common_operation);
247 common_operation = 247 common_operation =
248 GNUNET_TESTBED_overlay_connect (NULL, &op_comp_cb, NULL, peer1.peer, 248 GNUNET_TESTBED_overlay_connect (NULL, &op_comp_cb, NULL, peer1.peer,
diff --git a/src/testbed/test_testbed_api_3peers_3controllers.c b/src/testbed/test_testbed_api_3peers_3controllers.c
index 6d88490c1..8a44029d4 100644
--- a/src/testbed/test_testbed_api_3peers_3controllers.c
+++ b/src/testbed/test_testbed_api_3peers_3controllers.c
@@ -151,12 +151,12 @@ struct GNUNET_TESTBED_HostHabitableCheckHandle *hc_handle;
151/** 151/**
152 * Abort task identifier 152 * Abort task identifier
153 */ 153 */
154static GNUNET_SCHEDULER_TaskIdentifier abort_task; 154static struct GNUNET_SCHEDULER_Task * abort_task;
155 155
156/** 156/**
157 * Delayed connect job identifier 157 * Delayed connect job identifier
158 */ 158 */
159static GNUNET_SCHEDULER_TaskIdentifier delayed_connect_task; 159static struct GNUNET_SCHEDULER_Task * delayed_connect_task;
160 160
161/** 161/**
162 * Different stages in testing 162 * Different stages in testing
@@ -259,11 +259,11 @@ static enum Stage result;
259static void 259static void
260do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 260do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
261{ 261{
262 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 262 if (NULL != abort_task)
263 GNUNET_SCHEDULER_cancel (abort_task); 263 GNUNET_SCHEDULER_cancel (abort_task);
264 if (NULL != hc_handle) 264 if (NULL != hc_handle)
265 GNUNET_TESTBED_is_host_habitable_cancel (hc_handle); 265 GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
266 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == delayed_connect_task); 266 GNUNET_assert (NULL == delayed_connect_task);
267 if (NULL != common_operation) 267 if (NULL != common_operation)
268 GNUNET_TESTBED_operation_done (common_operation); 268 GNUNET_TESTBED_operation_done (common_operation);
269 if (NULL != reg_handle) 269 if (NULL != reg_handle)
@@ -294,11 +294,11 @@ static void
294do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 294do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
295{ 295{
296 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 296 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
297 abort_task = GNUNET_SCHEDULER_NO_TASK; 297 abort_task = NULL;
298 if (GNUNET_SCHEDULER_NO_TASK != delayed_connect_task) 298 if (NULL != delayed_connect_task)
299 { 299 {
300 GNUNET_SCHEDULER_cancel (delayed_connect_task); 300 GNUNET_SCHEDULER_cancel (delayed_connect_task);
301 delayed_connect_task = GNUNET_SCHEDULER_NO_TASK; 301 delayed_connect_task = NULL;
302 } 302 }
303 do_shutdown (cls, tc); 303 do_shutdown (cls, tc);
304} 304}
@@ -306,7 +306,7 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
306static void 306static void
307abort_test () 307abort_test ()
308{ 308{
309 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 309 if (NULL != abort_task)
310 GNUNET_SCHEDULER_cancel (abort_task); 310 GNUNET_SCHEDULER_cancel (abort_task);
311 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); 311 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
312} 312}
@@ -333,7 +333,7 @@ op_comp_cb (void *cls, struct GNUNET_TESTBED_Operation *op, const char *emsg);
333static void 333static void
334do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 334do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
335{ 335{
336 delayed_connect_task = GNUNET_SCHEDULER_NO_TASK; 336 delayed_connect_task = NULL;
337 if (NULL != common_operation) 337 if (NULL != common_operation)
338 { 338 {
339 GNUNET_break (0); 339 GNUNET_break (0);
@@ -859,7 +859,7 @@ host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *_host,
859 "to use password less SSH logins to localhost.\n" 859 "to use password less SSH logins to localhost.\n"
860 "Skipping test\n"); 860 "Skipping test\n");
861 GNUNET_SCHEDULER_cancel (abort_task); 861 GNUNET_SCHEDULER_cancel (abort_task);
862 abort_task = GNUNET_SCHEDULER_NO_TASK; 862 abort_task = NULL;
863 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 863 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
864 result = SKIP; 864 result = SKIP;
865 return; 865 return;
diff --git a/src/testbed/test_testbed_api_barriers.c b/src/testbed/test_testbed_api_barriers.c
index 648af792b..dec1b3898 100644
--- a/src/testbed/test_testbed_api_barriers.c
+++ b/src/testbed/test_testbed_api_barriers.c
@@ -50,7 +50,7 @@ struct GNUNET_TESTBED_Barrier *barrier;
50/** 50/**
51 * Identifier for the shutdown task 51 * Identifier for the shutdown task
52 */ 52 */
53static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 53static struct GNUNET_SCHEDULER_Task * shutdown_task;
54 54
55/** 55/**
56 * Result of this test case 56 * Result of this test case
@@ -67,7 +67,7 @@ static int result;
67static void 67static void
68do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 68do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
69{ 69{
70 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 70 shutdown_task = NULL;
71 if (NULL != barrier) 71 if (NULL != barrier)
72 { 72 {
73 GNUNET_TESTBED_barrier_cancel (barrier); 73 GNUNET_TESTBED_barrier_cancel (barrier);
diff --git a/src/testbed/test_testbed_api_controllerlink.c b/src/testbed/test_testbed_api_controllerlink.c
index 471ab3a94..2834ea713 100644
--- a/src/testbed/test_testbed_api_controllerlink.c
+++ b/src/testbed/test_testbed_api_controllerlink.c
@@ -244,7 +244,7 @@ static struct GNUNET_CONFIGURATION_Handle *cfg3;
244/** 244/**
245 * Abort task 245 * Abort task
246 */ 246 */
247static GNUNET_SCHEDULER_TaskIdentifier abort_task; 247static struct GNUNET_SCHEDULER_Task * abort_task;
248 248
249/** 249/**
250 * Operation handle for linking controllers 250 * Operation handle for linking controllers
@@ -279,7 +279,7 @@ struct GNUNET_TESTBED_HostHabitableCheckHandle *hc_handle;
279/** 279/**
280 * The task handle for the delay task 280 * The task handle for the delay task
281 */ 281 */
282GNUNET_SCHEDULER_TaskIdentifier delay_task_id; 282struct GNUNET_SCHEDULER_Task * delay_task_id;
283 283
284/** 284/**
285 * Event mask 285 * Event mask
@@ -297,9 +297,9 @@ static enum Stage result;
297#define FAIL_TEST(cond) do { \ 297#define FAIL_TEST(cond) do { \
298 if (!(cond)) { \ 298 if (!(cond)) { \
299 GNUNET_break(0); \ 299 GNUNET_break(0); \
300 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 300 if (NULL != abort_task) \
301 GNUNET_SCHEDULER_cancel (abort_task); \ 301 GNUNET_SCHEDULER_cancel (abort_task); \
302 abort_task = GNUNET_SCHEDULER_NO_TASK; \ 302 abort_task = NULL; \
303 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \ 303 GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \
304 return; \ 304 return; \
305 } \ 305 } \
@@ -315,12 +315,12 @@ static enum Stage result;
315static void 315static void
316do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 316do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
317{ 317{
318 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 318 if (NULL != abort_task)
319 GNUNET_SCHEDULER_cancel (abort_task); 319 GNUNET_SCHEDULER_cancel (abort_task);
320 if (GNUNET_SCHEDULER_NO_TASK != delay_task_id) 320 if (NULL != delay_task_id)
321 { 321 {
322 GNUNET_SCHEDULER_cancel (delay_task_id); 322 GNUNET_SCHEDULER_cancel (delay_task_id);
323 delay_task_id = GNUNET_SCHEDULER_NO_TASK; 323 delay_task_id = NULL;
324 } 324 }
325 if (NULL != hc_handle) 325 if (NULL != hc_handle)
326 GNUNET_TESTBED_is_host_habitable_cancel (hc_handle); 326 GNUNET_TESTBED_is_host_habitable_cancel (hc_handle);
@@ -355,7 +355,7 @@ static void
355do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 355do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
356{ 356{
357 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n"); 357 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n");
358 abort_task = GNUNET_SCHEDULER_NO_TASK; 358 abort_task = NULL;
359 do_shutdown (cls, tc); 359 do_shutdown (cls, tc);
360} 360}
361 361
@@ -369,7 +369,7 @@ do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
369static void 369static void
370do_abort_now (void *cls) 370do_abort_now (void *cls)
371{ 371{
372 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 372 if (NULL != abort_task)
373 GNUNET_SCHEDULER_cancel (abort_task); 373 GNUNET_SCHEDULER_cancel (abort_task);
374 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); 374 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL);
375} 375}
@@ -394,7 +394,7 @@ registration_cont (void *cls, const char *emsg);
394static void 394static void
395delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 395delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
396{ 396{
397 delay_task_id = GNUNET_SCHEDULER_NO_TASK; 397 delay_task_id = NULL;
398 switch (result) 398 switch (result)
399 { 399 {
400 case SLAVE2_PEER_CREATE_SUCCESS: 400 case SLAVE2_PEER_CREATE_SUCCESS:
@@ -756,7 +756,7 @@ host_habitable_cb (void *cls, const struct GNUNET_TESTBED_Host *_host,
756 "to use password less SSH logins to localhost.\n" 756 "to use password less SSH logins to localhost.\n"
757 "Skipping test\n"); 757 "Skipping test\n");
758 GNUNET_SCHEDULER_cancel (abort_task); 758 GNUNET_SCHEDULER_cancel (abort_task);
759 abort_task = GNUNET_SCHEDULER_NO_TASK; 759 abort_task = NULL;
760 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 760 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
761 result = SKIP; 761 result = SKIP;
762 return; 762 return;
diff --git a/src/testbed/test_testbed_api_hosts.c b/src/testbed/test_testbed_api_hosts.c
index 4d96b2303..6a589e0e8 100644
--- a/src/testbed/test_testbed_api_hosts.c
+++ b/src/testbed/test_testbed_api_hosts.c
@@ -61,7 +61,7 @@ static int status;
61/** 61/**
62 * Shutdown task identifier 62 * Shutdown task identifier
63 */ 63 */
64GNUNET_SCHEDULER_TaskIdentifier shutdown_id; 64struct GNUNET_SCHEDULER_Task * shutdown_id;
65 65
66/** 66/**
67 * The shutdown task 67 * The shutdown task
diff --git a/src/testbed/test_testbed_api_operations.c b/src/testbed/test_testbed_api_operations.c
index ceae76cd4..b3402868a 100644
--- a/src/testbed/test_testbed_api_operations.c
+++ b/src/testbed/test_testbed_api_operations.c
@@ -115,7 +115,7 @@ struct GNUNET_TESTBED_Operation *op9;
115/** 115/**
116 * The delay task identifier 116 * The delay task identifier
117 */ 117 */
118GNUNET_SCHEDULER_TaskIdentifier step_task; 118struct GNUNET_SCHEDULER_Task * step_task;
119 119
120 120
121/** 121/**
@@ -267,8 +267,8 @@ release_cb (void *cls);
267static void 267static void
268step (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 268step (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
269{ 269{
270 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != step_task); 270 GNUNET_assert (NULL != step_task);
271 step_task = GNUNET_SCHEDULER_NO_TASK; 271 step_task = NULL;
272 switch (result) 272 switch (result)
273 { 273 {
274 case TEST_OP1_STARTED: 274 case TEST_OP1_STARTED:
@@ -344,28 +344,28 @@ start_cb (void *cls)
344 case TEST_INIT: 344 case TEST_INIT:
345 GNUNET_assert (&op1 == cls); 345 GNUNET_assert (&op1 == cls);
346 result = TEST_OP1_STARTED; 346 result = TEST_OP1_STARTED;
347 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 347 GNUNET_assert (NULL == step_task);
348 step_task = 348 step_task =
349 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); 349 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
350 break; 350 break;
351 case TEST_PAUSE: 351 case TEST_PAUSE:
352 GNUNET_assert (&op2 == cls); 352 GNUNET_assert (&op2 == cls);
353 result = TEST_OP2_STARTED; 353 result = TEST_OP2_STARTED;
354 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 354 GNUNET_assert (NULL == step_task);
355 step_task = 355 step_task =
356 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); 356 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
357 break; 357 break;
358 case TEST_OP2_RELEASED: 358 case TEST_OP2_RELEASED:
359 GNUNET_assert (&op3 == cls); 359 GNUNET_assert (&op3 == cls);
360 result = TEST_OP3_STARTED; 360 result = TEST_OP3_STARTED;
361 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 361 GNUNET_assert (NULL == step_task);
362 step_task = 362 step_task =
363 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); 363 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
364 break; 364 break;
365 case TEST_OP3_RELEASED: 365 case TEST_OP3_RELEASED:
366 GNUNET_assert (&op4 == cls); 366 GNUNET_assert (&op4 == cls);
367 result = TEST_OP4_STARTED; 367 result = TEST_OP4_STARTED;
368 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 368 GNUNET_assert (NULL == step_task);
369 step_task = 369 step_task =
370 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL); 370 GNUNET_SCHEDULER_add_delayed (STEP_DELAY, &step, NULL);
371 break; 371 break;
@@ -422,17 +422,17 @@ release_cb (void *cls)
422 case TEST_OP2_STARTED: 422 case TEST_OP2_STARTED:
423 GNUNET_assert (&op2 == cls); 423 GNUNET_assert (&op2 == cls);
424 result = TEST_OP2_RELEASED; 424 result = TEST_OP2_RELEASED;
425 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 425 GNUNET_assert (NULL == step_task);
426 break; 426 break;
427 case TEST_OP3_STARTED: 427 case TEST_OP3_STARTED:
428 GNUNET_assert (&op3 == cls); 428 GNUNET_assert (&op3 == cls);
429 result = TEST_OP3_RELEASED; 429 result = TEST_OP3_RELEASED;
430 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 430 GNUNET_assert (NULL == step_task);
431 break; 431 break;
432 case TEST_OP4_STARTED: 432 case TEST_OP4_STARTED:
433 GNUNET_assert (&op4 == cls); 433 GNUNET_assert (&op4 == cls);
434 result = TEST_OP4_RELEASED; 434 result = TEST_OP4_RELEASED;
435 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == step_task); 435 GNUNET_assert (NULL == step_task);
436 op5 = GNUNET_TESTBED_operation_create_ (&op5, &start_cb, &release_cb); 436 op5 = GNUNET_TESTBED_operation_create_ (&op5, &start_cb, &release_cb);
437 GNUNET_TESTBED_operation_queue_insert2_ (q1, op5, 1); 437 GNUNET_TESTBED_operation_queue_insert2_ (q1, op5, 1);
438 GNUNET_TESTBED_operation_begin_wait_ (op5); 438 GNUNET_TESTBED_operation_begin_wait_ (op5);
diff --git a/src/testbed/test_testbed_api_peer_reconfiguration.c b/src/testbed/test_testbed_api_peer_reconfiguration.c
index 6b5f3e117..3928274de 100644
--- a/src/testbed/test_testbed_api_peer_reconfiguration.c
+++ b/src/testbed/test_testbed_api_peer_reconfiguration.c
@@ -47,7 +47,7 @@ static struct GNUNET_TESTBED_Operation *op;
47/** 47/**
48 * Abort task identifier 48 * Abort task identifier
49 */ 49 */
50static GNUNET_SCHEDULER_TaskIdentifier abort_task; 50static struct GNUNET_SCHEDULER_Task * abort_task;
51 51
52/** 52/**
53 * States in this test 53 * States in this test
@@ -77,7 +77,7 @@ enum {
77#define FAIL_TEST(cond, ret) do { \ 77#define FAIL_TEST(cond, ret) do { \
78 if (!(cond)) { \ 78 if (!(cond)) { \
79 GNUNET_break(0); \ 79 GNUNET_break(0); \
80 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 80 if (NULL != abort_task) \
81 GNUNET_SCHEDULER_cancel (abort_task); \ 81 GNUNET_SCHEDULER_cancel (abort_task); \
82 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \ 82 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \
83 ret; \ 83 ret; \
@@ -95,7 +95,7 @@ static void
95do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 95do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
96{ 96{
97 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting\n"); 97 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting\n");
98 abort_task = GNUNET_SCHEDULER_NO_TASK; 98 abort_task = NULL;
99 if (NULL != op) 99 if (NULL != op)
100 { 100 {
101 GNUNET_TESTBED_operation_done (op); 101 GNUNET_TESTBED_operation_done (op);
@@ -134,7 +134,7 @@ controller_cb (void *cls, const struct GNUNET_TESTBED_EventInformation *event)
134 GNUNET_TESTBED_operation_done (op); 134 GNUNET_TESTBED_operation_done (op);
135 state = STATE_PEER_RECONFIGURED; 135 state = STATE_PEER_RECONFIGURED;
136 GNUNET_SCHEDULER_cancel (abort_task); 136 GNUNET_SCHEDULER_cancel (abort_task);
137 abort_task = GNUNET_SCHEDULER_NO_TASK; 137 abort_task = NULL;
138 GNUNET_SCHEDULER_shutdown (); 138 GNUNET_SCHEDULER_shutdown ();
139} 139}
140 140
diff --git a/src/testbed/test_testbed_api_peers_manage_services.c b/src/testbed/test_testbed_api_peers_manage_services.c
index 63c089e19..fedaae295 100644
--- a/src/testbed/test_testbed_api_peers_manage_services.c
+++ b/src/testbed/test_testbed_api_peers_manage_services.c
@@ -52,7 +52,7 @@ static void *dummy_cls = (void *) 0xDEAD0001;
52/** 52/**
53 * Abort task identifier 53 * Abort task identifier
54 */ 54 */
55static GNUNET_SCHEDULER_TaskIdentifier abort_task; 55static struct GNUNET_SCHEDULER_Task * abort_task;
56 56
57/** 57/**
58 * States in this test 58 * States in this test
@@ -91,7 +91,7 @@ enum {
91#define FAIL_TEST(cond, ret) do { \ 91#define FAIL_TEST(cond, ret) do { \
92 if (!(cond)) { \ 92 if (!(cond)) { \
93 GNUNET_break(0); \ 93 GNUNET_break(0); \
94 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 94 if (NULL != abort_task) \
95 GNUNET_SCHEDULER_cancel (abort_task); \ 95 GNUNET_SCHEDULER_cancel (abort_task); \
96 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \ 96 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \
97 ret; \ 97 ret; \
@@ -109,7 +109,7 @@ static void
109do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 109do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
110{ 110{
111 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting\n"); 111 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Aborting\n");
112 abort_task = GNUNET_SCHEDULER_NO_TASK; 112 abort_task = NULL;
113 if (NULL != op) 113 if (NULL != op)
114 { 114 {
115 GNUNET_TESTBED_operation_done (op); 115 GNUNET_TESTBED_operation_done (op);
@@ -151,7 +151,7 @@ op_comp_cb (void *cls,
151 case STATE_SERVICE_DOWN: 151 case STATE_SERVICE_DOWN:
152 state = STATE_SERVICE_UP; 152 state = STATE_SERVICE_UP;
153 GNUNET_SCHEDULER_cancel (abort_task); 153 GNUNET_SCHEDULER_cancel (abort_task);
154 abort_task = GNUNET_SCHEDULER_NO_TASK; 154 abort_task = NULL;
155 state = STATE_OK; 155 state = STATE_OK;
156 GNUNET_SCHEDULER_shutdown (); 156 GNUNET_SCHEDULER_shutdown ();
157 break; 157 break;
diff --git a/src/testbed/test_testbed_api_statistics.c b/src/testbed/test_testbed_api_statistics.c
index 73c7f9734..158f21e07 100644
--- a/src/testbed/test_testbed_api_statistics.c
+++ b/src/testbed/test_testbed_api_statistics.c
@@ -51,7 +51,7 @@ static void *dummy_cls = (void *) 0xDEAD0001;
51/** 51/**
52 * Abort task identifier 52 * Abort task identifier
53 */ 53 */
54static GNUNET_SCHEDULER_TaskIdentifier abort_task; 54static struct GNUNET_SCHEDULER_Task * abort_task;
55 55
56/** 56/**
57 * Global testing result 57 * Global testing result
@@ -75,7 +75,7 @@ static unsigned int num_seen_peers;
75#define FAIL_TEST(cond, ret) do { \ 75#define FAIL_TEST(cond, ret) do { \
76 if (!(cond)) { \ 76 if (!(cond)) { \
77 GNUNET_break(0); \ 77 GNUNET_break(0); \
78 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 78 if (NULL != abort_task) \
79 GNUNET_SCHEDULER_cancel (abort_task); \ 79 GNUNET_SCHEDULER_cancel (abort_task); \
80 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \ 80 abort_task = GNUNET_SCHEDULER_add_now (&do_abort, NULL); \
81 ret; \ 81 ret; \
@@ -93,7 +93,7 @@ static void
93do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 93do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
94{ 94{
95 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test timed out -- Aborting\n"); 95 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Test timed out -- Aborting\n");
96 abort_task = GNUNET_SCHEDULER_NO_TASK; 96 abort_task = NULL;
97 if (NULL != op) 97 if (NULL != op)
98 { 98 {
99 GNUNET_TESTBED_operation_done (op); 99 GNUNET_TESTBED_operation_done (op);
diff --git a/src/testbed/test_testbed_api_test.c b/src/testbed/test_testbed_api_test.c
index 7016ad843..4f52d6638 100644
--- a/src/testbed/test_testbed_api_test.c
+++ b/src/testbed/test_testbed_api_test.c
@@ -53,12 +53,12 @@ static struct GNUNET_TESTBED_Operation *op;
53/** 53/**
54 * Abort task identifier 54 * Abort task identifier
55 */ 55 */
56static GNUNET_SCHEDULER_TaskIdentifier abort_task; 56static struct GNUNET_SCHEDULER_Task * abort_task;
57 57
58/** 58/**
59 * shutdown task identifier 59 * shutdown task identifier
60 */ 60 */
61static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 61static struct GNUNET_SCHEDULER_Task * shutdown_task;
62 62
63/** 63/**
64 * Testing result 64 * Testing result
@@ -75,8 +75,8 @@ static int result;
75static void 75static void
76do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 76do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
77{ 77{
78 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 78 shutdown_task = NULL;
79 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 79 if (NULL != abort_task)
80 GNUNET_SCHEDULER_cancel (abort_task); 80 GNUNET_SCHEDULER_cancel (abort_task);
81 if (NULL != op) 81 if (NULL != op)
82 GNUNET_TESTBED_operation_done (op); 82 GNUNET_TESTBED_operation_done (op);
@@ -89,10 +89,10 @@ do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
89#define FAIL_TEST(cond) do { \ 89#define FAIL_TEST(cond) do { \
90 if (!(cond)) { \ 90 if (!(cond)) { \
91 GNUNET_break(0); \ 91 GNUNET_break(0); \
92 if (GNUNET_SCHEDULER_NO_TASK != abort_task) \ 92 if (NULL != abort_task) \
93 GNUNET_SCHEDULER_cancel (abort_task); \ 93 GNUNET_SCHEDULER_cancel (abort_task); \
94 abort_task = GNUNET_SCHEDULER_NO_TASK; \ 94 abort_task = NULL; \
95 if (GNUNET_SCHEDULER_NO_TASK == shutdown_task) \ 95 if (NULL == shutdown_task) \
96 shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \ 96 shutdown_task = GNUNET_SCHEDULER_add_now (do_shutdown, NULL); \
97 return; \ 97 return; \
98 } \ 98 } \
@@ -109,8 +109,8 @@ static void
109do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 109do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
110{ 110{
111 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 111 LOG (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
112 abort_task = GNUNET_SCHEDULER_NO_TASK; 112 abort_task = NULL;
113 if (GNUNET_SCHEDULER_NO_TASK != shutdown_task) 113 if (NULL != shutdown_task)
114 GNUNET_SCHEDULER_cancel (shutdown_task); 114 GNUNET_SCHEDULER_cancel (shutdown_task);
115 do_shutdown (cls, tc); 115 do_shutdown (cls, tc);
116} 116}
diff --git a/src/testbed/test_testbed_api_testbed_run.c b/src/testbed/test_testbed_api_testbed_run.c
index dd8a249e9..14e0d4fa4 100644
--- a/src/testbed/test_testbed_api_testbed_run.c
+++ b/src/testbed/test_testbed_api_testbed_run.c
@@ -46,7 +46,7 @@ static struct GNUNET_TESTBED_Operation *op;
46/** 46/**
47 * Abort task identifier 47 * Abort task identifier
48 */ 48 */
49static GNUNET_SCHEDULER_TaskIdentifier abort_task; 49static struct GNUNET_SCHEDULER_Task * abort_task;
50 50
51/** 51/**
52 * Current peer id 52 * Current peer id
@@ -73,7 +73,7 @@ static int wait_forever;
73static void 73static void
74do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 74do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
75{ 75{
76 if (GNUNET_SCHEDULER_NO_TASK != abort_task) 76 if (NULL != abort_task)
77 GNUNET_SCHEDULER_cancel (abort_task); 77 GNUNET_SCHEDULER_cancel (abort_task);
78 GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */ 78 GNUNET_SCHEDULER_shutdown (); /* Stop scheduler to shutdown testbed run */
79} 79}
@@ -89,7 +89,7 @@ static void
89do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 89do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
90{ 90{
91 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n"); 91 GNUNET_log (GNUNET_ERROR_TYPE_WARNING, "Test timedout -- Aborting\n");
92 abort_task = GNUNET_SCHEDULER_NO_TASK; 92 abort_task = NULL;
93 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL); 93 (void) GNUNET_SCHEDULER_add_now (&do_shutdown, NULL);
94} 94}
95 95
@@ -117,10 +117,10 @@ test_master (void *cls,
117 result = GNUNET_OK; 117 result = GNUNET_OK;
118 if (GNUNET_YES == wait_forever) 118 if (GNUNET_YES == wait_forever)
119 { 119 {
120 if (GNUNET_SCHEDULER_NO_TASK == abort_task) 120 if (NULL == abort_task)
121 return; /* abort already scheduled */ 121 return; /* abort already scheduled */
122 GNUNET_SCHEDULER_cancel (abort_task); 122 GNUNET_SCHEDULER_cancel (abort_task);
123 abort_task = GNUNET_SCHEDULER_NO_TASK; 123 abort_task = NULL;
124 (void) GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL, 124 (void) GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
125 &do_shutdown, NULL); 125 &do_shutdown, NULL);
126 return; 126 return;
diff --git a/src/testbed/test_testbed_api_topology.c b/src/testbed/test_testbed_api_topology.c
index bdd29bfbf..9c3e1c7a8 100644
--- a/src/testbed/test_testbed_api_topology.c
+++ b/src/testbed/test_testbed_api_topology.c
@@ -46,7 +46,7 @@ static struct GNUNET_TESTBED_Operation *op;
46/** 46/**
47 * Shutdown task 47 * Shutdown task
48 */ 48 */
49static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 49static struct GNUNET_SCHEDULER_Task * shutdown_task;
50 50
51/** 51/**
52 * Testing result 52 * Testing result
@@ -68,7 +68,7 @@ static unsigned int overlay_connects;
68static void 68static void
69do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 69do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
70{ 70{
71 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 71 shutdown_task = NULL;
72 if (NULL != op) 72 if (NULL != op)
73 { 73 {
74 GNUNET_TESTBED_operation_done (op); 74 GNUNET_TESTBED_operation_done (op);
diff --git a/src/testbed/test_testbed_api_topology_clique.c b/src/testbed/test_testbed_api_topology_clique.c
index 658e33ab9..d08efcc97 100644
--- a/src/testbed/test_testbed_api_topology_clique.c
+++ b/src/testbed/test_testbed_api_topology_clique.c
@@ -46,7 +46,7 @@ static struct GNUNET_TESTBED_Operation *op;
46/** 46/**
47 * Shutdown task 47 * Shutdown task
48 */ 48 */
49static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; 49static struct GNUNET_SCHEDULER_Task * shutdown_task;
50 50
51/** 51/**
52 * Testing result 52 * Testing result
@@ -68,7 +68,7 @@ static unsigned int overlay_connects;
68static void 68static void
69do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 69do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
70{ 70{
71 shutdown_task = GNUNET_SCHEDULER_NO_TASK; 71 shutdown_task = NULL;
72 if (NULL != op) 72 if (NULL != op)
73 { 73 {
74 GNUNET_TESTBED_operation_done (op); 74 GNUNET_TESTBED_operation_done (op);
diff --git a/src/testbed/test_testbed_logger_api.c b/src/testbed/test_testbed_logger_api.c
index 11ba7270b..0a6b31426 100644
--- a/src/testbed/test_testbed_logger_api.c
+++ b/src/testbed/test_testbed_logger_api.c
@@ -53,16 +53,16 @@ static char *search_dir;
53/** 53/**
54 * Abort task identifier 54 * Abort task identifier
55 */ 55 */
56static GNUNET_SCHEDULER_TaskIdentifier abort_task; 56static struct GNUNET_SCHEDULER_Task * abort_task;
57static GNUNET_SCHEDULER_TaskIdentifier write_task; 57static struct GNUNET_SCHEDULER_Task * write_task;
58 58
59static int result; 59static int result;
60 60
61#define CANCEL_TASK(task) do { \ 61#define CANCEL_TASK(task) do { \
62 if (GNUNET_SCHEDULER_NO_TASK != task) \ 62 if (NULL != task) \
63 { \ 63 { \
64 GNUNET_SCHEDULER_cancel (task); \ 64 GNUNET_SCHEDULER_cancel (task); \
65 task = GNUNET_SCHEDULER_NO_TASK; \ 65 task = NULL; \
66 } \ 66 } \
67 } while (0) 67 } while (0)
68 68
@@ -100,7 +100,7 @@ static void
100do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) 100do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
101{ 101{
102 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n"); 102 LOG (GNUNET_ERROR_TYPE_WARNING, "Aborting\n");
103 abort_task = GNUNET_SCHEDULER_NO_TASK; 103 abort_task = NULL;
104 shutdown_now (); 104 shutdown_now ();
105} 105}
106 106
@@ -178,7 +178,7 @@ do_write (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
178 static int i; 178 static int i;
179 char buf[BSIZE]; 179 char buf[BSIZE];
180 180
181 write_task = GNUNET_SCHEDULER_NO_TASK; 181 write_task = NULL;
182 if (0 == i) 182 if (0 == i)
183 write_task = GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS(1), &do_write, NULL); 183 write_task = GNUNET_SCHEDULER_add_delayed (TIME_REL_SECS(1), &do_write, NULL);
184 (void) memset (buf, i, BSIZE); 184 (void) memset (buf, i, BSIZE);
diff --git a/src/testbed/testbed_api_hosts.c b/src/testbed/testbed_api_hosts.c
index ed3379d88..292dafadf 100644
--- a/src/testbed/testbed_api_hosts.c
+++ b/src/testbed/testbed_api_hosts.c
@@ -1239,7 +1239,7 @@ struct GNUNET_TESTBED_HostHabitableCheckHandle
1239 /** 1239 /**
1240 * Task id for the habitability check task 1240 * Task id for the habitability check task
1241 */ 1241 */
1242 GNUNET_SCHEDULER_TaskIdentifier habitability_check_task; 1242 struct GNUNET_SCHEDULER_Task * habitability_check_task;
1243 1243
1244 /** 1244 /**
1245 * How long we wait before checking the process status. Should grow 1245 * How long we wait before checking the process status. Should grow
@@ -1267,7 +1267,7 @@ habitability_check (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1267 enum GNUNET_OS_ProcessStatusType type; 1267 enum GNUNET_OS_ProcessStatusType type;
1268 int ret; 1268 int ret;
1269 1269
1270 h->habitability_check_task = GNUNET_SCHEDULER_NO_TASK; 1270 h->habitability_check_task = NULL;
1271 ret = GNUNET_OS_process_status (h->auxp, &type, &code); 1271 ret = GNUNET_OS_process_status (h->auxp, &type, &code);
1272 if (GNUNET_SYSERR == ret) 1272 if (GNUNET_SYSERR == ret)
1273 { 1273 {
diff --git a/src/testbed/testbed_api_operations.c b/src/testbed/testbed_api_operations.c
index 8bc38747c..469d44fe5 100644
--- a/src/testbed/testbed_api_operations.c
+++ b/src/testbed/testbed_api_operations.c
@@ -400,7 +400,7 @@ static unsigned int n_expired_opqs;
400/** 400/**
401 * The id of the task to process the ready queue 401 * The id of the task to process the ready queue
402 */ 402 */
403GNUNET_SCHEDULER_TaskIdentifier process_rq_task_id; 403struct GNUNET_SCHEDULER_Task * process_rq_task_id;
404 404
405 405
406/** 406/**
@@ -534,10 +534,10 @@ rq_remove (struct GNUNET_TESTBED_Operation *op)
534 GNUNET_CONTAINER_DLL_remove (rq_head, rq_tail, op->rq_entry); 534 GNUNET_CONTAINER_DLL_remove (rq_head, rq_tail, op->rq_entry);
535 GNUNET_free (op->rq_entry); 535 GNUNET_free (op->rq_entry);
536 op->rq_entry = NULL; 536 op->rq_entry = NULL;
537 if ( (NULL == rq_head) && (GNUNET_SCHEDULER_NO_TASK != process_rq_task_id) ) 537 if ( (NULL == rq_head) && (NULL != process_rq_task_id) )
538 { 538 {
539 GNUNET_SCHEDULER_cancel (process_rq_task_id); 539 GNUNET_SCHEDULER_cancel (process_rq_task_id);
540 process_rq_task_id = GNUNET_SCHEDULER_NO_TASK; 540 process_rq_task_id = NULL;
541 } 541 }
542} 542}
543 543
@@ -558,7 +558,7 @@ process_rq_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
558 struct OperationQueue *queue; 558 struct OperationQueue *queue;
559 unsigned int cnt; 559 unsigned int cnt;
560 560
561 process_rq_task_id = GNUNET_SCHEDULER_NO_TASK; 561 process_rq_task_id = NULL;
562 GNUNET_assert (NULL != rq_head); 562 GNUNET_assert (NULL != rq_head);
563 GNUNET_assert (NULL != (op = rq_head->op)); 563 GNUNET_assert (NULL != (op = rq_head->op));
564 rq_remove (op); 564 rq_remove (op);
@@ -592,7 +592,7 @@ rq_add (struct GNUNET_TESTBED_Operation *op)
592 rq_entry->op = op; 592 rq_entry->op = op;
593 GNUNET_CONTAINER_DLL_insert_tail (rq_head, rq_tail, rq_entry); 593 GNUNET_CONTAINER_DLL_insert_tail (rq_head, rq_tail, rq_entry);
594 op->rq_entry = rq_entry; 594 op->rq_entry = rq_entry;
595 if (GNUNET_SCHEDULER_NO_TASK == process_rq_task_id) 595 if (NULL == process_rq_task_id)
596 process_rq_task_id = GNUNET_SCHEDULER_add_now (&process_rq_task, NULL); 596 process_rq_task_id = GNUNET_SCHEDULER_add_now (&process_rq_task, NULL);
597} 597}
598 598
diff --git a/src/testbed/testbed_api_statistics.c b/src/testbed/testbed_api_statistics.c
index e6efc1fb0..6087a0c14 100644
--- a/src/testbed/testbed_api_statistics.c
+++ b/src/testbed/testbed_api_statistics.c
@@ -94,7 +94,7 @@ struct GetStatsContext
94 /** 94 /**
95 * The task for calling the continuation callback 95 * The task for calling the continuation callback
96 */ 96 */
97 GNUNET_SCHEDULER_TaskIdentifier call_completion_task_id; 97 struct GNUNET_SCHEDULER_Task * call_completion_task_id;
98 98
99 /** 99 /**
100 * The number of peers present in the peers array. This number also 100 * The number of peers present in the peers array. This number also
@@ -128,7 +128,7 @@ struct PeerGetStatsContext
128 /** 128 /**
129 * Task to mark the statistics service connect operation as done 129 * Task to mark the statistics service connect operation as done
130 */ 130 */
131 GNUNET_SCHEDULER_TaskIdentifier op_done_task_id; 131 struct GNUNET_SCHEDULER_Task * op_done_task_id;
132 132
133 /** 133 /**
134 * The index of this peer in the peers array of GetStatsContext 134 * The index of this peer in the peers array of GetStatsContext
@@ -157,8 +157,8 @@ call_completion_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
157{ 157{
158 struct GetStatsContext *sc = cls; 158 struct GetStatsContext *sc = cls;
159 159
160 GNUNET_assert (sc->call_completion_task_id != GNUNET_SCHEDULER_NO_TASK); 160 GNUNET_assert (sc->call_completion_task_id != NULL);
161 sc->call_completion_task_id = GNUNET_SCHEDULER_NO_TASK; 161 sc->call_completion_task_id = NULL;
162 LOG_DEBUG ("Calling get_statistics() continuation callback\n"); 162 LOG_DEBUG ("Calling get_statistics() continuation callback\n");
163 sc->cont (sc->cb_cls, sc->main_op, NULL); 163 sc->cont (sc->cb_cls, sc->main_op, NULL);
164} 164}
@@ -179,7 +179,7 @@ op_done_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
179 struct GNUNET_TESTBED_Operation **op; 179 struct GNUNET_TESTBED_Operation **op;
180 180
181 sc = peer_sc->sc; 181 sc = peer_sc->sc;
182 peer_sc->op_done_task_id = GNUNET_SCHEDULER_NO_TASK; 182 peer_sc->op_done_task_id = NULL;
183 op = &sc->ops[peer_sc->peer_index]; 183 op = &sc->ops[peer_sc->peer_index];
184 GNUNET_assert (NULL != *op); 184 GNUNET_assert (NULL != *op);
185 GNUNET_TESTBED_operation_done (*op); 185 GNUNET_TESTBED_operation_done (*op);
@@ -312,7 +312,7 @@ statistics_da (void *cls, void *op_result)
312 peer_sc->get_handle = NULL; 312 peer_sc->get_handle = NULL;
313 } 313 }
314 GNUNET_STATISTICS_destroy (sh, GNUNET_NO); 314 GNUNET_STATISTICS_destroy (sh, GNUNET_NO);
315 if (GNUNET_SCHEDULER_NO_TASK != peer_sc->op_done_task_id) 315 if (NULL != peer_sc->op_done_task_id)
316 GNUNET_SCHEDULER_cancel (peer_sc->op_done_task_id); 316 GNUNET_SCHEDULER_cancel (peer_sc->op_done_task_id);
317 GNUNET_free (peer_sc); 317 GNUNET_free (peer_sc);
318} 318}
@@ -366,7 +366,7 @@ oprelease_get_stats (void *cls)
366 unsigned int peer; 366 unsigned int peer;
367 367
368 LOG_DEBUG ("Cleaning up get_statistics operation\n"); 368 LOG_DEBUG ("Cleaning up get_statistics operation\n");
369 if (GNUNET_SCHEDULER_NO_TASK != sc->call_completion_task_id) 369 if (NULL != sc->call_completion_task_id)
370 GNUNET_SCHEDULER_cancel (sc->call_completion_task_id); 370 GNUNET_SCHEDULER_cancel (sc->call_completion_task_id);
371 if (NULL != sc->ops) 371 if (NULL != sc->ops)
372 { 372 {
diff --git a/src/testbed/testbed_api_testbed.c b/src/testbed/testbed_api_testbed.c
index 2be565e63..981a6a9e5 100644
--- a/src/testbed/testbed_api_testbed.c
+++ b/src/testbed/testbed_api_testbed.c
@@ -253,17 +253,17 @@ struct GNUNET_TESTBED_RunHandle
253 /** 253 /**
254 * Host registration task 254 * Host registration task
255 */ 255 */
256 GNUNET_SCHEDULER_TaskIdentifier register_hosts_task; 256 struct GNUNET_SCHEDULER_Task * register_hosts_task;
257 257
258 /** 258 /**
259 * Task to be run of a timeout 259 * Task to be run of a timeout
260 */ 260 */
261 GNUNET_SCHEDULER_TaskIdentifier timeout_task; 261 struct GNUNET_SCHEDULER_Task * timeout_task;
262 262
263 /** 263 /**
264 * Task run upon shutdown interrupts 264 * Task run upon shutdown interrupts
265 */ 265 */
266 GNUNET_SCHEDULER_TaskIdentifier interrupt_task; 266 struct GNUNET_SCHEDULER_Task * interrupt_task;
267 267
268 /** 268 /**
269 * The event mask for the controller 269 * The event mask for the controller
@@ -455,7 +455,7 @@ cleanup (struct GNUNET_TESTBED_RunHandle *rc)
455{ 455{
456 unsigned int hid; 456 unsigned int hid;
457 457
458 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == rc->register_hosts_task); 458 GNUNET_assert (NULL == rc->register_hosts_task);
459 GNUNET_assert (NULL == rc->reg_handle); 459 GNUNET_assert (NULL == rc->reg_handle);
460 GNUNET_assert (NULL == rc->peers); 460 GNUNET_assert (NULL == rc->peers);
461 GNUNET_assert (NULL == rc->hclist); 461 GNUNET_assert (NULL == rc->hclist);
@@ -524,15 +524,15 @@ rc_cleanup_operations (struct GNUNET_TESTBED_RunHandle *rc)
524 rc->hclist = NULL; 524 rc->hclist = NULL;
525 } 525 }
526 /* Stop register hosts task if it is running */ 526 /* Stop register hosts task if it is running */
527 if (GNUNET_SCHEDULER_NO_TASK != rc->register_hosts_task) 527 if (NULL != rc->register_hosts_task)
528 { 528 {
529 GNUNET_SCHEDULER_cancel (rc->register_hosts_task); 529 GNUNET_SCHEDULER_cancel (rc->register_hosts_task);
530 rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK; 530 rc->register_hosts_task = NULL;
531 } 531 }
532 if (GNUNET_SCHEDULER_NO_TASK != rc->timeout_task) 532 if (NULL != rc->timeout_task)
533 { 533 {
534 GNUNET_SCHEDULER_cancel (rc->timeout_task); 534 GNUNET_SCHEDULER_cancel (rc->timeout_task);
535 rc->timeout_task = GNUNET_SCHEDULER_NO_TASK; 535 rc->timeout_task = NULL;
536 } 536 }
537 if (NULL != rc->reg_handle) 537 if (NULL != rc->reg_handle)
538 { 538 {
@@ -561,7 +561,7 @@ static void
561cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc) 561cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc)
562{ 562{
563 GNUNET_SCHEDULER_cancel (rc->interrupt_task); 563 GNUNET_SCHEDULER_cancel (rc->interrupt_task);
564 rc->interrupt_task = GNUNET_SCHEDULER_NO_TASK; 564 rc->interrupt_task = NULL;
565} 565}
566 566
567 567
@@ -730,7 +730,7 @@ static void
730call_master (struct GNUNET_TESTBED_RunHandle *rc) 730call_master (struct GNUNET_TESTBED_RunHandle *rc)
731{ 731{
732 GNUNET_SCHEDULER_cancel (rc->timeout_task); 732 GNUNET_SCHEDULER_cancel (rc->timeout_task);
733 rc->timeout_task = GNUNET_SCHEDULER_NO_TASK; 733 rc->timeout_task = NULL;
734 if (NULL != rc->test_master) 734 if (NULL != rc->test_master)
735 rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers, 735 rc->test_master (rc->test_master_cls, rc, rc->num_peers, rc->peers,
736 rc->links_succeeded, rc->links_failed); 736 rc->links_succeeded, rc->links_failed);
@@ -1006,7 +1006,7 @@ register_hosts (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1006 struct RunContextOperation *rcop; 1006 struct RunContextOperation *rcop;
1007 unsigned int slave; 1007 unsigned int slave;
1008 1008
1009 rc->register_hosts_task = GNUNET_SCHEDULER_NO_TASK; 1009 rc->register_hosts_task = NULL;
1010 if (rc->reg_hosts == rc->num_hosts) 1010 if (rc->reg_hosts == rc->num_hosts)
1011 { 1011 {
1012 DEBUG ("All hosts successfully registered\n"); 1012 DEBUG ("All hosts successfully registered\n");
@@ -1199,7 +1199,7 @@ timeout_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1199{ 1199{
1200 struct GNUNET_TESTBED_RunHandle *rc = cls; 1200 struct GNUNET_TESTBED_RunHandle *rc = cls;
1201 1201
1202 rc->timeout_task = GNUNET_SCHEDULER_NO_TASK; 1202 rc->timeout_task = NULL;
1203 LOG (GNUNET_ERROR_TYPE_ERROR, _("Shutting down testbed due to timeout while setup.\n")); 1203 LOG (GNUNET_ERROR_TYPE_ERROR, _("Shutting down testbed due to timeout while setup.\n"));
1204 GNUNET_SCHEDULER_shutdown (); 1204 GNUNET_SCHEDULER_shutdown ();
1205 if (NULL != rc->test_master) 1205 if (NULL != rc->test_master)
diff --git a/src/testbed/testbed_logger_api.c b/src/testbed/testbed_logger_api.c
index dab9d6600..091645de3 100644
--- a/src/testbed/testbed_logger_api.c
+++ b/src/testbed/testbed_logger_api.c
@@ -144,12 +144,12 @@ struct GNUNET_TESTBED_LOGGER_Handle
144 /** 144 /**
145 * Task to call the flush completion callback 145 * Task to call the flush completion callback
146 */ 146 */
147 GNUNET_SCHEDULER_TaskIdentifier flush_completion_task; 147 struct GNUNET_SCHEDULER_Task * flush_completion_task;
148 148
149 /** 149 /**
150 * Task to be executed when flushing takes too long 150 * Task to be executed when flushing takes too long
151 */ 151 */
152 GNUNET_SCHEDULER_TaskIdentifier timeout_flush_task; 152 struct GNUNET_SCHEDULER_Task * timeout_flush_task;
153}; 153};
154 154
155 155
@@ -162,7 +162,7 @@ static void
162cancel_timeout_flush (struct GNUNET_TESTBED_LOGGER_Handle *h) 162cancel_timeout_flush (struct GNUNET_TESTBED_LOGGER_Handle *h)
163{ 163{
164 GNUNET_SCHEDULER_cancel (h->timeout_flush_task); 164 GNUNET_SCHEDULER_cancel (h->timeout_flush_task);
165 h->timeout_flush_task = GNUNET_SCHEDULER_NO_TASK; 165 h->timeout_flush_task = NULL;
166} 166}
167 167
168 168
@@ -180,14 +180,14 @@ call_flush_completion (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
180 void *cb_cls; 180 void *cb_cls;
181 size_t bw; 181 size_t bw;
182 182
183 h->flush_completion_task = GNUNET_SCHEDULER_NO_TASK; 183 h->flush_completion_task = NULL;
184 bw = h->bwrote; 184 bw = h->bwrote;
185 h->bwrote = 0; 185 h->bwrote = 0;
186 cb = h->cb; 186 cb = h->cb;
187 h->cb = NULL; 187 h->cb = NULL;
188 cb_cls = h->cb_cls; 188 cb_cls = h->cb_cls;
189 h->cb_cls = NULL; 189 h->cb_cls = NULL;
190 if (GNUNET_SCHEDULER_NO_TASK != h->timeout_flush_task) 190 if (NULL != h->timeout_flush_task)
191 cancel_timeout_flush (h); 191 cancel_timeout_flush (h);
192 if (NULL != cb) 192 if (NULL != cb)
193 cb (cb_cls, bw); 193 cb (cb_cls, bw);
@@ -202,7 +202,7 @@ call_flush_completion (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
202static void 202static void
203trigger_flush_notification (struct GNUNET_TESTBED_LOGGER_Handle *h) 203trigger_flush_notification (struct GNUNET_TESTBED_LOGGER_Handle *h)
204{ 204{
205 if (GNUNET_SCHEDULER_NO_TASK != h->flush_completion_task) 205 if (NULL != h->flush_completion_task)
206 GNUNET_SCHEDULER_cancel (h->flush_completion_task); 206 GNUNET_SCHEDULER_cancel (h->flush_completion_task);
207 h->flush_completion_task = GNUNET_SCHEDULER_add_now (&call_flush_completion, h); 207 h->flush_completion_task = GNUNET_SCHEDULER_add_now (&call_flush_completion, h);
208} 208}
@@ -354,7 +354,7 @@ GNUNET_TESTBED_LOGGER_disconnect (struct GNUNET_TESTBED_LOGGER_Handle *h)
354 struct MessageQueue *mq; 354 struct MessageQueue *mq;
355 unsigned int lost; 355 unsigned int lost;
356 356
357 if (GNUNET_SCHEDULER_NO_TASK != h->flush_completion_task) 357 if (NULL != h->flush_completion_task)
358 GNUNET_SCHEDULER_cancel (h->flush_completion_task); 358 GNUNET_SCHEDULER_cancel (h->flush_completion_task);
359 lost = 0; 359 lost = 0;
360 while (NULL != (mq = h->mq_head)) 360 while (NULL != (mq = h->mq_head))
@@ -425,15 +425,15 @@ timeout_flush (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
425 GNUNET_TESTBED_LOGGER_FlushCompletion cb; 425 GNUNET_TESTBED_LOGGER_FlushCompletion cb;
426 void *cb_cls; 426 void *cb_cls;
427 427
428 h->timeout_flush_task = GNUNET_SCHEDULER_NO_TASK; 428 h->timeout_flush_task = NULL;
429 cb = h->cb; 429 cb = h->cb;
430 h->cb = NULL; 430 h->cb = NULL;
431 cb_cls = h->cb_cls; 431 cb_cls = h->cb_cls;
432 h->cb_cls = NULL; 432 h->cb_cls = NULL;
433 if (GNUNET_SCHEDULER_NO_TASK != h->flush_completion_task) 433 if (NULL != h->flush_completion_task)
434 { 434 {
435 GNUNET_SCHEDULER_cancel (h->flush_completion_task); 435 GNUNET_SCHEDULER_cancel (h->flush_completion_task);
436 h->flush_completion_task = GNUNET_SCHEDULER_NO_TASK; 436 h->flush_completion_task = NULL;
437 } 437 }
438 if (NULL != cb) 438 if (NULL != cb)
439 cb (cb_cls, 0); 439 cb (cb_cls, 0);
@@ -456,7 +456,7 @@ GNUNET_TESTBED_LOGGER_flush (struct GNUNET_TESTBED_LOGGER_Handle *h,
456{ 456{
457 h->cb = cb; 457 h->cb = cb;
458 h->cb_cls = cb_cls; 458 h->cb_cls = cb_cls;
459 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == h->timeout_flush_task); 459 GNUNET_assert (NULL == h->timeout_flush_task);
460 h->timeout_flush_task = 460 h->timeout_flush_task =
461 GNUNET_SCHEDULER_add_delayed (timeout, &timeout_flush, h); 461 GNUNET_SCHEDULER_add_delayed (timeout, &timeout_flush, h);
462 if (NULL == h->buf) 462 if (NULL == h->buf)
@@ -478,12 +478,12 @@ GNUNET_TESTBED_LOGGER_flush (struct GNUNET_TESTBED_LOGGER_Handle *h,
478void 478void
479GNUNET_TESTBED_LOGGER_flush_cancel (struct GNUNET_TESTBED_LOGGER_Handle *h) 479GNUNET_TESTBED_LOGGER_flush_cancel (struct GNUNET_TESTBED_LOGGER_Handle *h)
480{ 480{
481 if (GNUNET_SCHEDULER_NO_TASK != h->flush_completion_task) 481 if (NULL != h->flush_completion_task)
482 { 482 {
483 GNUNET_SCHEDULER_cancel (h->flush_completion_task); 483 GNUNET_SCHEDULER_cancel (h->flush_completion_task);
484 h->flush_completion_task = GNUNET_SCHEDULER_NO_TASK; 484 h->flush_completion_task = NULL;
485 } 485 }
486 if (GNUNET_SCHEDULER_NO_TASK != h->timeout_flush_task) 486 if (NULL != h->timeout_flush_task)
487 cancel_timeout_flush (h); 487 cancel_timeout_flush (h);
488 h->cb = NULL; 488 h->cb = NULL;
489 h->cb_cls = NULL; 489 h->cb_cls = NULL;
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-27 18:47:04 +0000