diff options
Diffstat (limited to 'src/testbed')
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 | */ |
101 | GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 101 | struct GNUNET_SCHEDULER_Task * shutdown_task; |
102 | 102 | ||
103 | 103 | ||
104 | /** | 104 | /** |
@@ -136,7 +136,7 @@ free_iterator (void *cls, | |||
136 | static void | 136 | static void |
137 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 137 | do_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 | */ |
75 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 75 | static 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 | */ |
107 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 107 | static 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 | */ |
127 | static GNUNET_SCHEDULER_TaskIdentifier read_task_id; | 127 | static 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 | */ |
132 | static GNUNET_SCHEDULER_TaskIdentifier write_task_id; | 132 | static 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 | */ |
137 | static GNUNET_SCHEDULER_TaskIdentifier child_death_task_id; | 137 | static struct GNUNET_SCHEDULER_Task * child_death_task_id; |
138 | 138 | ||
139 | /** | 139 | /** |
140 | * shutdown task id | 140 | * shutdown task id |
141 | */ | 141 | */ |
142 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; | 142 | static 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 | |||
162 | shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 162 | shutdown_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) | |||
209 | static void | 209 | static void |
210 | shutdown_now (void) | 210 | shutdown_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 | */ |
86 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; | 86 | static 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 | */ |
135 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; | 135 | static 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) | |||
335 | static void | 335 | static void |
336 | expire_task_cancel (struct PooledConnection *entry) | 336 | expire_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 | */ |
86 | struct GNUNET_BIO_WriteHandle *bw; | 86 | struct GNUNET_BIO_WriteHandle *bw; |
87 | 87 | ||
88 | GNUNET_SCHEDULER_TaskIdentifier sample_load_task_id; | 88 | struct 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 | */ |
320 | static GNUNET_SCHEDULER_TaskIdentifier lcf_proc_task_id; | 320 | static 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 | |||
1508 | cleanup_rocc (struct RemoteOverlayConnectCtx *rocc) | 1508 | cleanup_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 | */ |
58 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 58 | static struct GNUNET_SCHEDULER_Task * abort_task; |
59 | 59 | ||
60 | /** | 60 | /** |
61 | * Shutdown task identifier | 61 | * Shutdown task identifier |
62 | */ | 62 | */ |
63 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 63 | static 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; | |||
112 | static void | 112 | static void |
113 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 113 | do_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 | |||
137 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 137 | do_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 | */ |
61 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task_id; | 61 | static 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 | */ |
66 | static GNUNET_SCHEDULER_TaskIdentifier terminate_task_id; | 66 | static 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 | */ |
71 | static GNUNET_SCHEDULER_TaskIdentifier child_death_task_id; | 71 | static 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; | |||
76 | static void | 76 | static void |
77 | shutdown_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 77 | shutdown_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 | */ |
61 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 61 | static struct GNUNET_SCHEDULER_Task * abort_task; |
62 | 62 | ||
63 | /** | 63 | /** |
64 | * Shutdown task identifier | 64 | * Shutdown task identifier |
65 | */ | 65 | */ |
66 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 66 | static struct GNUNET_SCHEDULER_Task * shutdown_task; |
67 | 67 | ||
68 | /** | 68 | /** |
69 | * Configuratin handler | 69 | * Configuratin handler |
@@ -85,7 +85,7 @@ static int result; | |||
85 | static void | 85 | static void |
86 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 86 | do_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) | |||
104 | static void | 104 | static void |
105 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 105 | do_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 | */ |
93 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 93 | static struct GNUNET_SCHEDULER_Task * abort_task; |
94 | 94 | ||
95 | /** | 95 | /** |
96 | * The testing result | 96 | * The testing result |
@@ -139,7 +139,7 @@ static void | |||
139 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 139 | do_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 | |||
181 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 181 | do_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 | */ |
115 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 115 | static struct GNUNET_SCHEDULER_Task * abort_task; |
116 | 116 | ||
117 | /** | 117 | /** |
118 | * Delayed connect job identifier | 118 | * Delayed connect job identifier |
119 | */ | 119 | */ |
120 | static GNUNET_SCHEDULER_TaskIdentifier delayed_connect_task; | 120 | static 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; | |||
191 | static void | 191 | static void |
192 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 192 | do_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 | |||
216 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 216 | do_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); | |||
242 | static void | 242 | static void |
243 | do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 243 | do_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 | */ |
154 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 154 | static struct GNUNET_SCHEDULER_Task * abort_task; |
155 | 155 | ||
156 | /** | 156 | /** |
157 | * Delayed connect job identifier | 157 | * Delayed connect job identifier |
158 | */ | 158 | */ |
159 | static GNUNET_SCHEDULER_TaskIdentifier delayed_connect_task; | 159 | static 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; | |||
259 | static void | 259 | static void |
260 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 260 | do_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 | |||
294 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 294 | do_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) | |||
306 | static void | 306 | static void |
307 | abort_test () | 307 | abort_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); | |||
333 | static void | 333 | static void |
334 | do_delayed_connect (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 334 | do_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 | */ |
53 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 53 | static 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; | |||
67 | static void | 67 | static void |
68 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 68 | do_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 | */ |
247 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 247 | static 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 | */ |
282 | GNUNET_SCHEDULER_TaskIdentifier delay_task_id; | 282 | struct 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; | |||
315 | static void | 315 | static void |
316 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 316 | do_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 | |||
355 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 355 | do_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) | |||
369 | static void | 369 | static void |
370 | do_abort_now (void *cls) | 370 | do_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); | |||
394 | static void | 394 | static void |
395 | delay_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 395 | delay_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 | */ |
64 | GNUNET_SCHEDULER_TaskIdentifier shutdown_id; | 64 | struct 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 | */ |
118 | GNUNET_SCHEDULER_TaskIdentifier step_task; | 118 | struct GNUNET_SCHEDULER_Task * step_task; |
119 | 119 | ||
120 | 120 | ||
121 | /** | 121 | /** |
@@ -267,8 +267,8 @@ release_cb (void *cls); | |||
267 | static void | 267 | static void |
268 | step (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 268 | step (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 | */ |
50 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 50 | static 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 | |||
95 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 95 | do_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 | */ |
55 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 55 | static 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 | |||
109 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 109 | do_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 | */ |
54 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 54 | static 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 | |||
93 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 93 | do_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 | */ |
56 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 56 | static struct GNUNET_SCHEDULER_Task * abort_task; |
57 | 57 | ||
58 | /** | 58 | /** |
59 | * shutdown task identifier | 59 | * shutdown task identifier |
60 | */ | 60 | */ |
61 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 61 | static struct GNUNET_SCHEDULER_Task * shutdown_task; |
62 | 62 | ||
63 | /** | 63 | /** |
64 | * Testing result | 64 | * Testing result |
@@ -75,8 +75,8 @@ static int result; | |||
75 | static void | 75 | static void |
76 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 76 | do_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 | |||
109 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 109 | do_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 | */ |
49 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 49 | static 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; | |||
73 | static void | 73 | static void |
74 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 74 | do_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 | |||
89 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 89 | do_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 | */ |
49 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 49 | static 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; | |||
68 | static void | 68 | static void |
69 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 69 | do_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 | */ |
49 | static GNUNET_SCHEDULER_TaskIdentifier shutdown_task; | 49 | static 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; | |||
68 | static void | 68 | static void |
69 | do_shutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 69 | do_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 | */ |
56 | static GNUNET_SCHEDULER_TaskIdentifier abort_task; | 56 | static struct GNUNET_SCHEDULER_Task * abort_task; |
57 | static GNUNET_SCHEDULER_TaskIdentifier write_task; | 57 | static struct GNUNET_SCHEDULER_Task * write_task; |
58 | 58 | ||
59 | static int result; | 59 | static 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 | |||
100 | do_abort (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 100 | do_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 | */ |
403 | GNUNET_SCHEDULER_TaskIdentifier process_rq_task_id; | 403 | struct 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 | |||
561 | cancel_interrupt_task (struct GNUNET_TESTBED_RunHandle *rc) | 561 | cancel_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 | |||
730 | call_master (struct GNUNET_TESTBED_RunHandle *rc) | 730 | call_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 | |||
162 | cancel_timeout_flush (struct GNUNET_TESTBED_LOGGER_Handle *h) | 162 | cancel_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) | |||
202 | static void | 202 | static void |
203 | trigger_flush_notification (struct GNUNET_TESTBED_LOGGER_Handle *h) | 203 | trigger_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, | |||
478 | void | 478 | void |
479 | GNUNET_TESTBED_LOGGER_flush_cancel (struct GNUNET_TESTBED_LOGGER_Handle *h) | 479 | GNUNET_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; |