diff options
author | Christian Grothoff <christian@grothoff.org> | 2009-11-04 14:10:32 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2009-11-04 14:10:32 +0000 |
commit | cf45b8dff29c366d51aa2e6ea6a64b99b514b9c9 (patch) | |
tree | 5cb37c041743daff5af528dbbe24f5c563ce702e /src | |
parent | b91546a3de767292e6472c6b1927480adba43d88 (diff) | |
download | gnunet-cf45b8dff29c366d51aa2e6ea6a64b99b514b9c9.tar.gz gnunet-cf45b8dff29c366d51aa2e6ea6a64b99b514b9c9.zip |
bugfixes and redesigning scheduler API
Diffstat (limited to 'src')
63 files changed, 593 insertions, 1022 deletions
diff --git a/src/arm/gnunet-arm.c b/src/arm/gnunet-arm.c index 09a1305a5..d0748f173 100644 --- a/src/arm/gnunet-arm.c +++ b/src/arm/gnunet-arm.c | |||
@@ -123,7 +123,6 @@ confirm_cb (void *cls, int success) | |||
123 | break; | 123 | break; |
124 | } | 124 | } |
125 | GNUNET_SCHEDULER_add_continuation (sched, | 125 | GNUNET_SCHEDULER_add_continuation (sched, |
126 | GNUNET_NO, | ||
127 | &cps_loop, | 126 | &cps_loop, |
128 | NULL, | 127 | NULL, |
129 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 128 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -147,7 +146,6 @@ confirm_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
147 | else | 146 | else |
148 | fprintf (stdout, _("Service `%s' is not running.\n"), service); | 147 | fprintf (stdout, _("Service `%s' is not running.\n"), service); |
149 | GNUNET_SCHEDULER_add_continuation (sched, | 148 | GNUNET_SCHEDULER_add_continuation (sched, |
150 | GNUNET_NO, | ||
151 | &cps_loop, | 149 | &cps_loop, |
152 | NULL, | 150 | NULL, |
153 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 151 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -181,7 +179,6 @@ run (void *cls, | |||
181 | return; | 179 | return; |
182 | } | 180 | } |
183 | GNUNET_SCHEDULER_add_continuation (sched, | 181 | GNUNET_SCHEDULER_add_continuation (sched, |
184 | GNUNET_NO, | ||
185 | &cps_loop, | 182 | &cps_loop, |
186 | NULL, | 183 | NULL, |
187 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 184 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/arm/gnunet-service-arm.c b/src/arm/gnunet-service-arm.c index ebb9c337e..bfb3896bf 100644 --- a/src/arm/gnunet-service-arm.c +++ b/src/arm/gnunet-service-arm.c | |||
@@ -516,9 +516,6 @@ stop_service (struct GNUNET_SERVER_Client *client, | |||
516 | pos->kill_continuation_cls = client; | 516 | pos->kill_continuation_cls = client; |
517 | GNUNET_SERVER_client_keep (client); | 517 | GNUNET_SERVER_client_keep (client); |
518 | GNUNET_SCHEDULER_add_delayed (sched, | 518 | GNUNET_SCHEDULER_add_delayed (sched, |
519 | GNUNET_YES, | ||
520 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
521 | GNUNET_SCHEDULER_NO_TASK, | ||
522 | MAINT_FAST_FREQUENCY, &maint, NULL); | 519 | MAINT_FAST_FREQUENCY, &maint, NULL); |
523 | } | 520 | } |
524 | else | 521 | else |
@@ -641,9 +638,6 @@ maint (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
641 | } | 638 | } |
642 | if (cls == NULL) | 639 | if (cls == NULL) |
643 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 640 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
644 | GNUNET_YES, | ||
645 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
646 | GNUNET_SCHEDULER_NO_TASK, | ||
647 | MAINT_FREQUENCY, &maint, NULL); | 641 | MAINT_FREQUENCY, &maint, NULL); |
648 | 642 | ||
649 | /* check for services that died (WAITPID) */ | 643 | /* check for services that died (WAITPID) */ |
@@ -800,11 +794,9 @@ run (void *cls, | |||
800 | GNUNET_SERVER_add_handlers (server, handlers); | 794 | GNUNET_SERVER_add_handlers (server, handlers); |
801 | 795 | ||
802 | /* manage services */ | 796 | /* manage services */ |
803 | GNUNET_SCHEDULER_add_delayed (sched, | 797 | GNUNET_SCHEDULER_add_with_priority (sched, |
804 | GNUNET_YES, | 798 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
805 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 799 | &maint, NULL); |
806 | GNUNET_SCHEDULER_NO_TASK, | ||
807 | MAINT_FREQUENCY, &maint, NULL); | ||
808 | } | 800 | } |
809 | 801 | ||
810 | 802 | ||
@@ -820,7 +812,7 @@ main (int argc, char *const *argv) | |||
820 | { | 812 | { |
821 | return (GNUNET_OK == | 813 | return (GNUNET_OK == |
822 | GNUNET_SERVICE_run (argc, | 814 | GNUNET_SERVICE_run (argc, |
823 | argv, "arm", &run, NULL, NULL, NULL)) ? 0 : 1; | 815 | argv, "arm", &run, NULL)) ? 0 : 1; |
824 | } | 816 | } |
825 | 817 | ||
826 | /* end of gnunet-service-arm.c */ | 818 | /* end of gnunet-service-arm.c */ |
diff --git a/src/core/core_api.c b/src/core/core_api.c index 1a74eb7d0..91055dd03 100644 --- a/src/core/core_api.c +++ b/src/core/core_api.c | |||
@@ -320,9 +320,6 @@ request_start (void *cls, size_t size, void *buf) | |||
320 | } | 320 | } |
321 | /* create new timeout task (in case core takes too long to respond!) */ | 321 | /* create new timeout task (in case core takes too long to respond!) */ |
322 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (h->sched, | 322 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (h->sched, |
323 | GNUNET_NO, | ||
324 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
325 | GNUNET_SCHEDULER_NO_TASK, | ||
326 | GNUNET_TIME_absolute_get_remaining | 323 | GNUNET_TIME_absolute_get_remaining |
327 | (th->timeout), | 324 | (th->timeout), |
328 | &timeout_request, th); | 325 | &timeout_request, th); |
@@ -748,9 +745,7 @@ transmit_start (void *cls, size_t size, void *buf) | |||
748 | h->startup_timeout = | 745 | h->startup_timeout = |
749 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); | 746 | GNUNET_TIME_relative_to_absolute (GNUNET_TIME_UNIT_MINUTES); |
750 | h->reconnect_task = | 747 | h->reconnect_task = |
751 | GNUNET_SCHEDULER_add_delayed (h->sched, GNUNET_NO, | 748 | GNUNET_SCHEDULER_add_delayed (h->sched, |
752 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
753 | GNUNET_SCHEDULER_NO_TASK, | ||
754 | delay, &reconnect_task, h); | 749 | delay, &reconnect_task, h); |
755 | return 0; | 750 | return 0; |
756 | } | 751 | } |
@@ -990,9 +985,6 @@ GNUNET_CORE_peer_configure (struct GNUNET_CORE_Handle *handle, | |||
990 | th->info_cls = info_cls; | 985 | th->info_cls = info_cls; |
991 | th->timeout = GNUNET_TIME_relative_to_absolute (timeout); | 986 | th->timeout = GNUNET_TIME_relative_to_absolute (timeout); |
992 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched, | 987 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched, |
993 | GNUNET_NO, | ||
994 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
995 | GNUNET_SCHEDULER_NO_TASK, | ||
996 | timeout, | 988 | timeout, |
997 | &timeout_request, th); | 989 | &timeout_request, th); |
998 | th->msize = sizeof (struct RequestConfigureMessage); | 990 | th->msize = sizeof (struct RequestConfigureMessage); |
@@ -1112,9 +1104,6 @@ GNUNET_CORE_notify_transmit_ready (struct GNUNET_CORE_Handle *handle, | |||
1112 | th->peer = *target; | 1104 | th->peer = *target; |
1113 | th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay); | 1105 | th->timeout = GNUNET_TIME_relative_to_absolute (maxdelay); |
1114 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched, | 1106 | th->timeout_task = GNUNET_SCHEDULER_add_delayed (handle->sched, |
1115 | GNUNET_NO, | ||
1116 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1117 | GNUNET_SCHEDULER_NO_TASK, | ||
1118 | maxdelay, | 1107 | maxdelay, |
1119 | &timeout_request, th); | 1108 | &timeout_request, th); |
1120 | th->priority = priority; | 1109 | th->priority = priority; |
diff --git a/src/core/gnunet-service-core.c b/src/core/gnunet-service-core.c index 1d272b873..839eb2727 100644 --- a/src/core/gnunet-service-core.c +++ b/src/core/gnunet-service-core.c | |||
@@ -1703,9 +1703,6 @@ process_plaintext_neighbour_queue (struct Neighbour *n) | |||
1703 | /* no messages selected for sending, try again later... */ | 1703 | /* no messages selected for sending, try again later... */ |
1704 | n->retry_plaintext_task = | 1704 | n->retry_plaintext_task = |
1705 | GNUNET_SCHEDULER_add_delayed (sched, | 1705 | GNUNET_SCHEDULER_add_delayed (sched, |
1706 | GNUNET_NO, | ||
1707 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1708 | GNUNET_SCHEDULER_NO_TASK, | ||
1709 | retry_time, | 1706 | retry_time, |
1710 | &retry_plaintext_processing, n); | 1707 | &retry_plaintext_processing, n); |
1711 | return; | 1708 | return; |
@@ -2154,9 +2151,6 @@ send_key (struct Neighbour *n) | |||
2154 | if (n->status != PEER_STATE_KEY_CONFIRMED) | 2151 | if (n->status != PEER_STATE_KEY_CONFIRMED) |
2155 | n->retry_set_key_task | 2152 | n->retry_set_key_task |
2156 | = GNUNET_SCHEDULER_add_delayed (sched, | 2153 | = GNUNET_SCHEDULER_add_delayed (sched, |
2157 | GNUNET_NO, | ||
2158 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
2159 | GNUNET_SCHEDULER_NO_TASK, | ||
2160 | n->set_key_retry_frequency, | 2154 | n->set_key_retry_frequency, |
2161 | &set_key_retry_task, n); | 2155 | &set_key_retry_task, n); |
2162 | } | 2156 | } |
@@ -2894,9 +2888,6 @@ schedule_quota_update (struct Neighbour *n) | |||
2894 | GNUNET_SCHEDULER_NO_TASK); | 2888 | GNUNET_SCHEDULER_NO_TASK); |
2895 | n->quota_update_task | 2889 | n->quota_update_task |
2896 | = GNUNET_SCHEDULER_add_delayed (sched, | 2890 | = GNUNET_SCHEDULER_add_delayed (sched, |
2897 | GNUNET_NO, | ||
2898 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2899 | GNUNET_SCHEDULER_NO_TASK, | ||
2900 | QUOTA_UPDATE_FREQUENCY, | 2891 | QUOTA_UPDATE_FREQUENCY, |
2901 | &neighbour_quota_update, | 2892 | &neighbour_quota_update, |
2902 | n); | 2893 | n); |
@@ -3114,6 +3105,8 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
3114 | } | 3105 | } |
3115 | while (NULL != (c = clients)) | 3106 | while (NULL != (c = clients)) |
3116 | handle_client_disconnect (NULL, c->client_handle); | 3107 | handle_client_disconnect (NULL, c->client_handle); |
3108 | if (my_private_key != NULL) | ||
3109 | GNUNET_CRYPTO_rsa_key_free (my_private_key); | ||
3117 | } | 3110 | } |
3118 | 3111 | ||
3119 | 3112 | ||
@@ -3198,9 +3191,6 @@ run (void *cls, | |||
3198 | &handle_transport_notify_disconnect); | 3191 | &handle_transport_notify_disconnect); |
3199 | GNUNET_assert (NULL != transport); | 3192 | GNUNET_assert (NULL != transport); |
3200 | GNUNET_SCHEDULER_add_delayed (sched, | 3193 | GNUNET_SCHEDULER_add_delayed (sched, |
3201 | GNUNET_YES, | ||
3202 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
3203 | GNUNET_SCHEDULER_NO_TASK, | ||
3204 | GNUNET_TIME_UNIT_FOREVER_REL, | 3194 | GNUNET_TIME_UNIT_FOREVER_REL, |
3205 | &cleaning_task, NULL); | 3195 | &cleaning_task, NULL); |
3206 | /* process client requests */ | 3196 | /* process client requests */ |
@@ -3210,17 +3200,6 @@ run (void *cls, | |||
3210 | } | 3200 | } |
3211 | 3201 | ||
3212 | 3202 | ||
3213 | /** | ||
3214 | * Function called during shutdown. Clean up our state. | ||
3215 | */ | ||
3216 | static void | ||
3217 | cleanup (void *cls, | ||
3218 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
3219 | { | ||
3220 | if (my_private_key != NULL) | ||
3221 | GNUNET_CRYPTO_rsa_key_free (my_private_key); | ||
3222 | } | ||
3223 | |||
3224 | 3203 | ||
3225 | /** | 3204 | /** |
3226 | * The main function for the transport service. | 3205 | * The main function for the transport service. |
@@ -3235,7 +3214,7 @@ main (int argc, char *const *argv) | |||
3235 | return (GNUNET_OK == | 3214 | return (GNUNET_OK == |
3236 | GNUNET_SERVICE_run (argc, | 3215 | GNUNET_SERVICE_run (argc, |
3237 | argv, | 3216 | argv, |
3238 | "core", &run, NULL, &cleanup, NULL)) ? 0 : 1; | 3217 | "core", &run, NULL)) ? 0 : 1; |
3239 | } | 3218 | } |
3240 | 3219 | ||
3241 | /* end of gnunet-service-core.c */ | 3220 | /* end of gnunet-service-core.c */ |
diff --git a/src/core/test_core_api.c b/src/core/test_core_api.c index 89aa34f5b..ebd4e8e99 100644 --- a/src/core/test_core_api.c +++ b/src/core/test_core_api.c | |||
@@ -172,9 +172,6 @@ process_mtype (void *cls, | |||
172 | OKPP; | 172 | OKPP; |
173 | GNUNET_SCHEDULER_cancel (sched, err_task); | 173 | GNUNET_SCHEDULER_cancel (sched, err_task); |
174 | GNUNET_SCHEDULER_add_delayed (sched, | 174 | GNUNET_SCHEDULER_add_delayed (sched, |
175 | GNUNET_NO, | ||
176 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
177 | GNUNET_SCHEDULER_NO_TASK, | ||
178 | GNUNET_TIME_UNIT_ZERO, &terminate_task, NULL); | 175 | GNUNET_TIME_UNIT_ZERO, &terminate_task, NULL); |
179 | return GNUNET_OK; | 176 | return GNUNET_OK; |
180 | } | 177 | } |
@@ -201,9 +198,6 @@ transmit_ready (void *cls, size_t size, void *buf) | |||
201 | m->size = htons (sizeof (struct GNUNET_MessageHeader)); | 198 | m->size = htons (sizeof (struct GNUNET_MessageHeader)); |
202 | err_task = | 199 | err_task = |
203 | GNUNET_SCHEDULER_add_delayed (sched, | 200 | GNUNET_SCHEDULER_add_delayed (sched, |
204 | GNUNET_NO, | ||
205 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
206 | GNUNET_SCHEDULER_NO_TASK, | ||
207 | GNUNET_TIME_UNIT_MINUTES, &terminate_task_error, NULL); | 201 | GNUNET_TIME_UNIT_MINUTES, &terminate_task_error, NULL); |
208 | 202 | ||
209 | return sizeof (struct GNUNET_MessageHeader); | 203 | return sizeof (struct GNUNET_MessageHeader); |
@@ -300,7 +294,6 @@ setup_peer (struct PeerContext *p, const char *cfgname) | |||
300 | "-L", "DEBUG", | 294 | "-L", "DEBUG", |
301 | #endif | 295 | #endif |
302 | "-c", cfgname, NULL); | 296 | "-c", cfgname, NULL); |
303 | sleep (1); /* allow ARM to start */ | ||
304 | #endif | 297 | #endif |
305 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | 298 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
306 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); | 299 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); |
diff --git a/src/core/test_core_api_start_only.c b/src/core/test_core_api_start_only.c index ce2668b89..5ca750664 100644 --- a/src/core/test_core_api_start_only.c +++ b/src/core/test_core_api_start_only.c | |||
@@ -166,7 +166,6 @@ setup_peer (struct PeerContext *p, const char *cfgname) | |||
166 | "-L", "DEBUG", | 166 | "-L", "DEBUG", |
167 | #endif | 167 | #endif |
168 | "-c", cfgname, NULL); | 168 | "-c", cfgname, NULL); |
169 | sleep (1); /* allow ARM to start */ | ||
170 | #endif | 169 | #endif |
171 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | 170 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
172 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); | 171 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); |
diff --git a/src/datastore/gnunet-service-datastore.c b/src/datastore/gnunet-service-datastore.c index 3a22f9bda..27b1cd58e 100644 --- a/src/datastore/gnunet-service-datastore.c +++ b/src/datastore/gnunet-service-datastore.c | |||
@@ -260,9 +260,6 @@ expired_processor (void *cls, | |||
260 | { | 260 | { |
261 | expired_kill_task | 261 | expired_kill_task |
262 | = GNUNET_SCHEDULER_add_delayed (sched, | 262 | = GNUNET_SCHEDULER_add_delayed (sched, |
263 | GNUNET_NO, | ||
264 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
265 | GNUNET_SCHEDULER_NO_TASK, | ||
266 | MAX_EXPIRE_DELAY, | 263 | MAX_EXPIRE_DELAY, |
267 | &delete_expired, | 264 | &delete_expired, |
268 | NULL); | 265 | NULL); |
@@ -1209,7 +1206,7 @@ cleaning_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1209 | GNUNET_CONTAINER_bloomfilter_free (filter); | 1206 | GNUNET_CONTAINER_bloomfilter_free (filter); |
1210 | filter = NULL; | 1207 | filter = NULL; |
1211 | } | 1208 | } |
1212 | // GNUNET_ARM_stop_services (cfg, tc->sched, "statistics", NULL); | 1209 | GNUNET_ARM_stop_services (cfg, tc->sched, "statistics", NULL); |
1213 | } | 1210 | } |
1214 | 1211 | ||
1215 | 1212 | ||
@@ -1307,28 +1304,22 @@ run (void *cls, | |||
1307 | _("Failed to initialize bloomfilter.\n")); | 1304 | _("Failed to initialize bloomfilter.\n")); |
1308 | return; | 1305 | return; |
1309 | } | 1306 | } |
1310 | // GNUNET_ARM_start_services (cfg, sched, "statistics", NULL); | 1307 | GNUNET_ARM_start_services (cfg, sched, "statistics", NULL); |
1311 | plugin = load_plugin (); | 1308 | plugin = load_plugin (); |
1312 | if (NULL == plugin) | 1309 | if (NULL == plugin) |
1313 | { | 1310 | { |
1314 | GNUNET_CONTAINER_bloomfilter_free (filter); | 1311 | GNUNET_CONTAINER_bloomfilter_free (filter); |
1315 | filter = NULL; | 1312 | filter = NULL; |
1316 | // GNUNET_ARM_stop_services (cfg, sched, "statistics", NULL); | 1313 | GNUNET_ARM_stop_services (cfg, sched, "statistics", NULL); |
1317 | return; | 1314 | return; |
1318 | } | 1315 | } |
1319 | GNUNET_SERVER_disconnect_notify (server, &cleanup_reservations, NULL); | 1316 | GNUNET_SERVER_disconnect_notify (server, &cleanup_reservations, NULL); |
1320 | GNUNET_SERVER_add_handlers (server, handlers); | 1317 | GNUNET_SERVER_add_handlers (server, handlers); |
1321 | expired_kill_task | 1318 | expired_kill_task |
1322 | = GNUNET_SCHEDULER_add_delayed (sched, | 1319 | = GNUNET_SCHEDULER_add_with_priority (sched, |
1323 | GNUNET_NO, | 1320 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1324 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1321 | &delete_expired, NULL); |
1325 | GNUNET_SCHEDULER_NO_TASK, | ||
1326 | GNUNET_TIME_UNIT_ZERO, | ||
1327 | &delete_expired, NULL); | ||
1328 | GNUNET_SCHEDULER_add_delayed (sched, | 1322 | GNUNET_SCHEDULER_add_delayed (sched, |
1329 | GNUNET_YES, | ||
1330 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1331 | GNUNET_SCHEDULER_NO_TASK, | ||
1332 | GNUNET_TIME_UNIT_FOREVER_REL, | 1323 | GNUNET_TIME_UNIT_FOREVER_REL, |
1333 | &cleaning_task, NULL); | 1324 | &cleaning_task, NULL); |
1334 | 1325 | ||
@@ -1350,7 +1341,7 @@ main (int argc, char *const *argv) | |||
1350 | ret = (GNUNET_OK == | 1341 | ret = (GNUNET_OK == |
1351 | GNUNET_SERVICE_run (argc, | 1342 | GNUNET_SERVICE_run (argc, |
1352 | argv, | 1343 | argv, |
1353 | "datastore", &run, NULL, NULL, NULL)) ? 0 : 1; | 1344 | "datastore", &run, NULL)) ? 0 : 1; |
1354 | return ret; | 1345 | return ret; |
1355 | } | 1346 | } |
1356 | 1347 | ||
diff --git a/src/datastore/perf_datastore_api.c b/src/datastore/perf_datastore_api.c index 2344dafe8..34adf0c7d 100644 --- a/src/datastore/perf_datastore_api.c +++ b/src/datastore/perf_datastore_api.c | |||
@@ -140,7 +140,6 @@ check_success (void *cls, | |||
140 | crc->phase = RP_CUT; | 140 | crc->phase = RP_CUT; |
141 | } | 141 | } |
142 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 142 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
143 | GNUNET_NO, | ||
144 | &run_continuation, | 143 | &run_continuation, |
145 | crc, | 144 | crc, |
146 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 145 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -167,7 +166,6 @@ remove_next(void *cls, | |||
167 | #endif | 166 | #endif |
168 | GNUNET_assert (GNUNET_OK == success); | 167 | GNUNET_assert (GNUNET_OK == success); |
169 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 168 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
170 | GNUNET_NO, | ||
171 | &run_continuation, | 169 | &run_continuation, |
172 | crc, | 170 | crc, |
173 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 171 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -214,18 +212,15 @@ delete_value (void *cls, | |||
214 | { | 212 | { |
215 | crc->phase = RP_REPORT; | 213 | crc->phase = RP_REPORT; |
216 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 214 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
217 | GNUNET_NO, | ||
218 | &run_continuation, | 215 | &run_continuation, |
219 | crc, | 216 | crc, |
220 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 217 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
221 | return; | 218 | return; |
222 | } | 219 | } |
223 | GNUNET_SCHEDULER_add_after (crc->sched, | 220 | GNUNET_SCHEDULER_add_with_priority (crc->sched, |
224 | GNUNET_NO, | 221 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
225 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 222 | &do_delete, |
226 | GNUNET_SCHEDULER_NO_TASK, | 223 | crc); |
227 | &do_delete, | ||
228 | crc); | ||
229 | return; | 224 | return; |
230 | } | 225 | } |
231 | stored_ops++; | 226 | stored_ops++; |
@@ -303,7 +298,6 @@ run_continuation (void *cls, | |||
303 | crc->phase = RP_PUT; | 298 | crc->phase = RP_PUT; |
304 | crc->j = 0; | 299 | crc->j = 0; |
305 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 300 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
306 | GNUNET_NO, | ||
307 | &run_continuation, | 301 | &run_continuation, |
308 | crc, | 302 | crc, |
309 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 303 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -335,7 +329,6 @@ run (void *cls, | |||
335 | crc->cfg = cfg; | 329 | crc->cfg = cfg; |
336 | crc->phase = RP_PUT; | 330 | crc->phase = RP_PUT; |
337 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 331 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
338 | GNUNET_NO, | ||
339 | &run_continuation, | 332 | &run_continuation, |
340 | crc, | 333 | crc, |
341 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 334 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -364,7 +357,6 @@ check () | |||
364 | "-L", "DEBUG", | 357 | "-L", "DEBUG", |
365 | #endif | 358 | #endif |
366 | "-c", "test_datastore_api_data.conf", NULL); | 359 | "-c", "test_datastore_api_data.conf", NULL); |
367 | sleep (1); | ||
368 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, | 360 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, |
369 | argv, "perf-datastore-api", "nohelp", | 361 | argv, "perf-datastore-api", "nohelp", |
370 | options, &run, NULL); | 362 | options, &run, NULL); |
diff --git a/src/datastore/perf_plugin_datastore.c b/src/datastore/perf_plugin_datastore.c index b7bc9db31..a23569875 100644 --- a/src/datastore/perf_plugin_datastore.c +++ b/src/datastore/perf_plugin_datastore.c | |||
@@ -168,8 +168,6 @@ iterateDummy (void *cls, | |||
168 | crc->phase = RP_PUT; | 168 | crc->phase = RP_PUT; |
169 | } | 169 | } |
170 | GNUNET_SCHEDULER_add_after (crc->sched, | 170 | GNUNET_SCHEDULER_add_after (crc->sched, |
171 | GNUNET_NO, | ||
172 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
173 | GNUNET_SCHEDULER_NO_TASK, | 171 | GNUNET_SCHEDULER_NO_TASK, |
174 | &test, crc); | 172 | &test, crc); |
175 | return GNUNET_OK; | 173 | return GNUNET_OK; |
@@ -254,8 +252,6 @@ test (void *cls, | |||
254 | crc->i++; | 252 | crc->i++; |
255 | crc->phase = RP_LP_GET; | 253 | crc->phase = RP_LP_GET; |
256 | GNUNET_SCHEDULER_add_after (crc->sched, | 254 | GNUNET_SCHEDULER_add_after (crc->sched, |
257 | GNUNET_NO, | ||
258 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
259 | GNUNET_SCHEDULER_NO_TASK, | 255 | GNUNET_SCHEDULER_NO_TASK, |
260 | &test, crc); | 256 | &test, crc); |
261 | break; | 257 | break; |
@@ -301,11 +297,8 @@ test (void *cls, | |||
301 | break; | 297 | break; |
302 | case RP_DONE: | 298 | case RP_DONE: |
303 | crc->api->drop (crc->api->cls); | 299 | crc->api->drop (crc->api->cls); |
304 | GNUNET_SCHEDULER_add_delayed (crc->sched, | 300 | GNUNET_SCHEDULER_add_with_priority (crc->sched, |
305 | GNUNET_YES, | ||
306 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 301 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
307 | GNUNET_SCHEDULER_NO_TASK, | ||
308 | GNUNET_TIME_UNIT_ZERO, | ||
309 | &cleaning_task, crc); | 302 | &cleaning_task, crc); |
310 | break; | 303 | break; |
311 | } | 304 | } |
@@ -364,8 +357,6 @@ run (void *cls, | |||
364 | crc->cfg = c; | 357 | crc->cfg = c; |
365 | crc->phase = RP_PUT; | 358 | crc->phase = RP_PUT; |
366 | GNUNET_SCHEDULER_add_after (s, | 359 | GNUNET_SCHEDULER_add_after (s, |
367 | GNUNET_YES, | ||
368 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
369 | GNUNET_SCHEDULER_NO_TASK, | 360 | GNUNET_SCHEDULER_NO_TASK, |
370 | &test, crc); | 361 | &test, crc); |
371 | } | 362 | } |
diff --git a/src/datastore/plugin_datastore_sqlite.c b/src/datastore/plugin_datastore_sqlite.c index e673bafa4..1607ba5e0 100644 --- a/src/datastore/plugin_datastore_sqlite.c +++ b/src/datastore/plugin_datastore_sqlite.c | |||
@@ -663,7 +663,6 @@ sqlite_next_request (void *next_cls, | |||
663 | if (GNUNET_YES == end_it) | 663 | if (GNUNET_YES == end_it) |
664 | nc->end_it = GNUNET_YES; | 664 | nc->end_it = GNUNET_YES; |
665 | GNUNET_SCHEDULER_add_continuation (nc->plugin->env->sched, | 665 | GNUNET_SCHEDULER_add_continuation (nc->plugin->env->sched, |
666 | GNUNET_NO, | ||
667 | &sqlite_next_request_cont, | 666 | &sqlite_next_request_cont, |
668 | nc, | 667 | nc, |
669 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 668 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/datastore/test_datastore_api.c b/src/datastore/test_datastore_api.c index 605cb042d..5d4443cbe 100644 --- a/src/datastore/test_datastore_api.c +++ b/src/datastore/test_datastore_api.c | |||
@@ -145,7 +145,6 @@ check_success (void *cls, | |||
145 | GNUNET_free_non_null (crc->data); | 145 | GNUNET_free_non_null (crc->data); |
146 | crc->data = NULL; | 146 | crc->data = NULL; |
147 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 147 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
148 | GNUNET_NO, | ||
149 | &run_continuation, | 148 | &run_continuation, |
150 | crc, | 149 | crc, |
151 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 150 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -164,7 +163,6 @@ get_reserved (void *cls, | |||
164 | GNUNET_assert (0 < success); | 163 | GNUNET_assert (0 < success); |
165 | crc->rid = success; | 164 | crc->rid = success; |
166 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 165 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
167 | GNUNET_NO, | ||
168 | &run_continuation, | 166 | &run_continuation, |
169 | crc, | 167 | crc, |
170 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 168 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -193,7 +191,6 @@ check_value (void *cls, | |||
193 | crc->i = ITERATIONS; | 191 | crc->i = ITERATIONS; |
194 | } | 192 | } |
195 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 193 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
196 | GNUNET_NO, | ||
197 | &run_continuation, | 194 | &run_continuation, |
198 | crc, | 195 | crc, |
199 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 196 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -226,7 +223,6 @@ delete_value (void *cls, | |||
226 | { | 223 | { |
227 | crc->phase = RP_DO_DEL; | 224 | crc->phase = RP_DO_DEL; |
228 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 225 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
229 | GNUNET_NO, | ||
230 | &run_continuation, | 226 | &run_continuation, |
231 | crc, | 227 | crc, |
232 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 228 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -259,7 +255,6 @@ check_nothing (void *cls, | |||
259 | crc->phase = RP_RESERVE; | 255 | crc->phase = RP_RESERVE; |
260 | } | 256 | } |
261 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 257 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
262 | GNUNET_NO, | ||
263 | &run_continuation, | 258 | &run_continuation, |
264 | crc, | 259 | crc, |
265 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 260 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -284,7 +279,6 @@ check_multiple (void *cls, | |||
284 | GNUNET_assert (crc->phase == RP_GET_MULTIPLE_DONE); | 279 | GNUNET_assert (crc->phase == RP_GET_MULTIPLE_DONE); |
285 | crc->phase = RP_UPDATE; | 280 | crc->phase = RP_UPDATE; |
286 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 281 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
287 | GNUNET_NO, | ||
288 | &run_continuation, | 282 | &run_continuation, |
289 | crc, | 283 | crc, |
290 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 284 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -315,7 +309,6 @@ check_update (void *cls, | |||
315 | GNUNET_assert (crc->phase == RP_UPDATE_DONE); | 309 | GNUNET_assert (crc->phase == RP_UPDATE_DONE); |
316 | crc->phase = RP_DONE; | 310 | crc->phase = RP_DONE; |
317 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 311 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
318 | GNUNET_NO, | ||
319 | &run_continuation, | 312 | &run_continuation, |
320 | crc, | 313 | crc, |
321 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 314 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -542,7 +535,6 @@ run (void *cls, | |||
542 | now = GNUNET_TIME_absolute_get (); | 535 | now = GNUNET_TIME_absolute_get (); |
543 | datastore = GNUNET_DATASTORE_connect (cfg, sched); | 536 | datastore = GNUNET_DATASTORE_connect (cfg, sched); |
544 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 537 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
545 | GNUNET_NO, | ||
546 | &run_continuation, | 538 | &run_continuation, |
547 | crc, | 539 | crc, |
548 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 540 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -572,7 +564,6 @@ check () | |||
572 | "-L", "DEBUG", | 564 | "-L", "DEBUG", |
573 | #endif | 565 | #endif |
574 | "-c", "test_datastore_api_data.conf", NULL); | 566 | "-c", "test_datastore_api_data.conf", NULL); |
575 | sleep (1); | ||
576 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, | 567 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, |
577 | argv, "test-datastore-api", "nohelp", | 568 | argv, "test-datastore-api", "nohelp", |
578 | options, &run, NULL); | 569 | options, &run, NULL); |
diff --git a/src/datastore/test_datastore_api_management.c b/src/datastore/test_datastore_api_management.c index 48daebb1d..cad789a6f 100644 --- a/src/datastore/test_datastore_api_management.c +++ b/src/datastore/test_datastore_api_management.c | |||
@@ -133,7 +133,6 @@ check_success (void *cls, | |||
133 | GNUNET_free_non_null (crc->data); | 133 | GNUNET_free_non_null (crc->data); |
134 | crc->data = NULL; | 134 | crc->data = NULL; |
135 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 135 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
136 | GNUNET_NO, | ||
137 | &run_continuation, | 136 | &run_continuation, |
138 | crc, | 137 | crc, |
139 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 138 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -171,7 +170,6 @@ check_value (void *cls, | |||
171 | if (0 == crc->i) | 170 | if (0 == crc->i) |
172 | crc->phase = RP_DONE; | 171 | crc->phase = RP_DONE; |
173 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 172 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
174 | GNUNET_NO, | ||
175 | &run_continuation, | 173 | &run_continuation, |
176 | crc, | 174 | crc, |
177 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 175 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -206,7 +204,6 @@ check_nothing (void *cls, | |||
206 | if (0 == --crc->i) | 204 | if (0 == --crc->i) |
207 | crc->phase = RP_DONE; | 205 | crc->phase = RP_DONE; |
208 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 206 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
209 | GNUNET_NO, | ||
210 | &run_continuation, | 207 | &run_continuation, |
211 | crc, | 208 | crc, |
212 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 209 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -310,7 +307,6 @@ run (void *cls, | |||
310 | now = GNUNET_TIME_absolute_get (); | 307 | now = GNUNET_TIME_absolute_get (); |
311 | datastore = GNUNET_DATASTORE_connect (cfg, sched); | 308 | datastore = GNUNET_DATASTORE_connect (cfg, sched); |
312 | GNUNET_SCHEDULER_add_continuation (crc->sched, | 309 | GNUNET_SCHEDULER_add_continuation (crc->sched, |
313 | GNUNET_NO, | ||
314 | &run_continuation, | 310 | &run_continuation, |
315 | crc, | 311 | crc, |
316 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 312 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -340,7 +336,6 @@ check () | |||
340 | "-L", "DEBUG", | 336 | "-L", "DEBUG", |
341 | #endif | 337 | #endif |
342 | "-c", "test_datastore_api_data.conf", NULL); | 338 | "-c", "test_datastore_api_data.conf", NULL); |
343 | sleep (1); | ||
344 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, | 339 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, |
345 | argv, "test-datastore-api", "nohelp", | 340 | argv, "test-datastore-api", "nohelp", |
346 | options, &run, NULL); | 341 | options, &run, NULL); |
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c index e92eb85c1..4b3d96082 100644 --- a/src/fs/fs_download.c +++ b/src/fs/fs_download.c | |||
@@ -718,9 +718,6 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc) | |||
718 | } | 718 | } |
719 | dc->task | 719 | dc->task |
720 | = GNUNET_SCHEDULER_add_delayed (dc->h->sched, | 720 | = GNUNET_SCHEDULER_add_delayed (dc->h->sched, |
721 | GNUNET_NO, | ||
722 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
723 | GNUNET_SCHEDULER_NO_TASK, | ||
724 | GNUNET_TIME_UNIT_SECONDS, | 721 | GNUNET_TIME_UNIT_SECONDS, |
725 | &do_reconnect, | 722 | &do_reconnect, |
726 | dc); | 723 | dc); |
diff --git a/src/fs/fs_list_indexed.c b/src/fs/fs_list_indexed.c index 9ef205ca0..d182f9aa4 100644 --- a/src/fs/fs_list_indexed.c +++ b/src/fs/fs_list_indexed.c | |||
@@ -91,7 +91,6 @@ handle_index_info (void *cls, | |||
91 | "GET_INDEXED", | 91 | "GET_INDEXED", |
92 | "fs"); | 92 | "fs"); |
93 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, | 93 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, |
94 | GNUNET_NO, | ||
95 | gic->cont, | 94 | gic->cont, |
96 | gic->cont_cls, | 95 | gic->cont_cls, |
97 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 96 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
@@ -103,7 +102,6 @@ handle_index_info (void *cls, | |||
103 | { | 102 | { |
104 | /* normal end-of-list */ | 103 | /* normal end-of-list */ |
105 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, | 104 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, |
106 | GNUNET_NO, | ||
107 | gic->cont, | 105 | gic->cont, |
108 | gic->cont_cls, | 106 | gic->cont_cls, |
109 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 107 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -124,7 +122,6 @@ handle_index_info (void *cls, | |||
124 | "GET_INDEXED", | 122 | "GET_INDEXED", |
125 | "fs"); | 123 | "fs"); |
126 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, | 124 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, |
127 | GNUNET_NO, | ||
128 | gic->cont, | 125 | gic->cont, |
129 | gic->cont_cls, | 126 | gic->cont_cls, |
130 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 127 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
@@ -138,7 +135,6 @@ handle_index_info (void *cls, | |||
138 | &iim->file_id)) | 135 | &iim->file_id)) |
139 | { | 136 | { |
140 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, | 137 | GNUNET_SCHEDULER_add_continuation (gic->h->sched, |
141 | GNUNET_NO, | ||
142 | gic->cont, | 138 | gic->cont, |
143 | gic->cont_cls, | 139 | gic->cont_cls, |
144 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 140 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -185,7 +181,6 @@ GNUNET_FS_get_indexed_files (struct GNUNET_FS_Handle *h, | |||
185 | _("Failed to not connect to `%s' service.\n"), | 181 | _("Failed to not connect to `%s' service.\n"), |
186 | "fs"); | 182 | "fs"); |
187 | GNUNET_SCHEDULER_add_continuation (h->sched, | 183 | GNUNET_SCHEDULER_add_continuation (h->sched, |
188 | GNUNET_NO, | ||
189 | cont, | 184 | cont, |
190 | cont_cls, | 185 | cont_cls, |
191 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 186 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
diff --git a/src/fs/fs_publish.c b/src/fs/fs_publish.c index 721951970..bef03a45e 100644 --- a/src/fs/fs_publish.c +++ b/src/fs/fs_publish.c | |||
@@ -185,13 +185,10 @@ ds_put_cont (void *cls, | |||
185 | GNUNET_FS_file_information_sync (pcc->p); | 185 | GNUNET_FS_file_information_sync (pcc->p); |
186 | if (NULL != pcc->cont) | 186 | if (NULL != pcc->cont) |
187 | pcc->sc->upload_task | 187 | pcc->sc->upload_task |
188 | = GNUNET_SCHEDULER_add_delayed (pcc->sc->h->sched, | 188 | = GNUNET_SCHEDULER_add_with_priority (pcc->sc->h->sched, |
189 | GNUNET_NO, | 189 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
190 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 190 | pcc->cont, |
191 | GNUNET_SCHEDULER_NO_TASK, | 191 | pcc->cont_cls); |
192 | GNUNET_TIME_UNIT_ZERO, | ||
193 | pcc->cont, | ||
194 | pcc->cont_cls); | ||
195 | GNUNET_free (pcc); | 192 | GNUNET_free (pcc); |
196 | } | 193 | } |
197 | 194 | ||
@@ -325,13 +322,10 @@ publish_kblocks_cont (void *cls, | |||
325 | { | 322 | { |
326 | signal_publish_error (p, sc, emsg); | 323 | signal_publish_error (p, sc, emsg); |
327 | sc->upload_task | 324 | sc->upload_task |
328 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, | 325 | = GNUNET_SCHEDULER_add_with_priority (sc->h->sched, |
329 | GNUNET_NO, | 326 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
330 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 327 | &do_upload, |
331 | GNUNET_SCHEDULER_NO_TASK, | 328 | sc); |
332 | GNUNET_TIME_UNIT_ZERO, | ||
333 | &do_upload, | ||
334 | sc); | ||
335 | return; | 329 | return; |
336 | } | 330 | } |
337 | GNUNET_FS_file_information_sync (p); | 331 | GNUNET_FS_file_information_sync (p); |
@@ -343,13 +337,10 @@ publish_kblocks_cont (void *cls, | |||
343 | else | 337 | else |
344 | sc->fi_pos = p->dir; | 338 | sc->fi_pos = p->dir; |
345 | sc->upload_task | 339 | sc->upload_task |
346 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, | 340 | = GNUNET_SCHEDULER_add_with_priority (sc->h->sched, |
347 | GNUNET_NO, | 341 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
348 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 342 | &do_upload, |
349 | GNUNET_SCHEDULER_NO_TASK, | 343 | sc); |
350 | GNUNET_TIME_UNIT_ZERO, | ||
351 | &do_upload, | ||
352 | sc); | ||
353 | } | 344 | } |
354 | 345 | ||
355 | 346 | ||
@@ -446,11 +437,8 @@ encode_cont (void *cls, | |||
446 | } | 437 | } |
447 | /* continue with main */ | 438 | /* continue with main */ |
448 | sc->upload_task | 439 | sc->upload_task |
449 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, | 440 | = GNUNET_SCHEDULER_add_with_priority (sc->h->sched, |
450 | GNUNET_NO, | 441 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
451 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | ||
452 | GNUNET_SCHEDULER_NO_TASK, | ||
453 | GNUNET_TIME_UNIT_ZERO, | ||
454 | &do_upload, | 442 | &do_upload, |
455 | sc); | 443 | sc); |
456 | } | 444 | } |
@@ -486,11 +474,8 @@ block_proc (void *cls, | |||
486 | if (NULL == sc->dsh) | 474 | if (NULL == sc->dsh) |
487 | { | 475 | { |
488 | sc->upload_task | 476 | sc->upload_task |
489 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, | 477 | = GNUNET_SCHEDULER_add_with_priority (sc->h->sched, |
490 | GNUNET_NO, | ||
491 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 478 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
492 | GNUNET_SCHEDULER_NO_TASK, | ||
493 | GNUNET_TIME_UNIT_ZERO, | ||
494 | &do_upload, | 479 | &do_upload, |
495 | sc); | 480 | sc); |
496 | return; | 481 | return; |
@@ -910,7 +895,6 @@ do_upload (void *cls, | |||
910 | else | 895 | else |
911 | GNUNET_CRYPTO_hash_file (sc->h->sched, | 896 | GNUNET_CRYPTO_hash_file (sc->h->sched, |
912 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 897 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
913 | GNUNET_NO, | ||
914 | p->data.file.filename, | 898 | p->data.file.filename, |
915 | HASHING_BLOCKSIZE, | 899 | HASHING_BLOCKSIZE, |
916 | &hash_for_index_cb, | 900 | &hash_for_index_cb, |
@@ -1018,11 +1002,8 @@ GNUNET_FS_publish_start (struct GNUNET_FS_Handle *h, | |||
1018 | // and reserve as first task (then trigger | 1002 | // and reserve as first task (then trigger |
1019 | // "do_upload" from that continuation)! | 1003 | // "do_upload" from that continuation)! |
1020 | ret->upload_task | 1004 | ret->upload_task |
1021 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1005 | = GNUNET_SCHEDULER_add_with_priority (h->sched, |
1022 | GNUNET_NO, | ||
1023 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | 1006 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, |
1024 | GNUNET_SCHEDULER_NO_TASK, | ||
1025 | GNUNET_TIME_UNIT_ZERO, | ||
1026 | &do_upload, | 1007 | &do_upload, |
1027 | ret); | 1008 | ret); |
1028 | return ret; | 1009 | return ret; |
@@ -1217,7 +1198,6 @@ kb_put_cont (void *cls, | |||
1217 | return; | 1198 | return; |
1218 | } | 1199 | } |
1219 | GNUNET_SCHEDULER_add_continuation (pkc->h->sched, | 1200 | GNUNET_SCHEDULER_add_continuation (pkc->h->sched, |
1220 | GNUNET_NO, | ||
1221 | &publish_ksk_cont, | 1201 | &publish_ksk_cont, |
1222 | pkc, | 1202 | pkc, |
1223 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 1203 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -1383,7 +1363,6 @@ GNUNET_FS_publish_ksk (struct GNUNET_FS_Handle *h, | |||
1383 | pkc->cpy->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK); | 1363 | pkc->cpy->purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_FS_KBLOCK); |
1384 | pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri); | 1364 | pkc->ksk_uri = GNUNET_FS_uri_dup (ksk_uri); |
1385 | GNUNET_SCHEDULER_add_continuation (h->sched, | 1365 | GNUNET_SCHEDULER_add_continuation (h->sched, |
1386 | GNUNET_NO, | ||
1387 | &publish_ksk_cont, | 1366 | &publish_ksk_cont, |
1388 | pkc, | 1367 | pkc, |
1389 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 1368 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c index 8b986ec7c..5d03046e2 100644 --- a/src/fs/fs_search.c +++ b/src/fs/fs_search.c | |||
@@ -720,9 +720,6 @@ try_reconnect (struct GNUNET_FS_SearchContext *sc) | |||
720 | } | 720 | } |
721 | sc->task | 721 | sc->task |
722 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, | 722 | = GNUNET_SCHEDULER_add_delayed (sc->h->sched, |
723 | GNUNET_NO, | ||
724 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
725 | GNUNET_SCHEDULER_NO_TASK, | ||
726 | GNUNET_TIME_UNIT_SECONDS, | 723 | GNUNET_TIME_UNIT_SECONDS, |
727 | &do_reconnect, | 724 | &do_reconnect, |
728 | sc); | 725 | sc); |
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c index 83da423f3..4d15d78f3 100644 --- a/src/fs/fs_tree.c +++ b/src/fs/fs_tree.c | |||
@@ -287,7 +287,6 @@ void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te) | |||
287 | &te->emsg)) | 287 | &te->emsg)) |
288 | { | 288 | { |
289 | GNUNET_SCHEDULER_add_continuation (te->h->sched, | 289 | GNUNET_SCHEDULER_add_continuation (te->h->sched, |
290 | GNUNET_NO, | ||
291 | te->cont, | 290 | te->cont, |
292 | te->cls, | 291 | te->cls, |
293 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 292 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
@@ -309,7 +308,6 @@ void GNUNET_FS_tree_encoder_next (struct GNUNET_FS_TreeEncoder * te) | |||
309 | te->uri->data.chk.chk = te->chk_tree[0]; | 308 | te->uri->data.chk.chk = te->chk_tree[0]; |
310 | te->uri->data.chk.file_length = GNUNET_htonll (te->size); | 309 | te->uri->data.chk.file_length = GNUNET_htonll (te->size); |
311 | GNUNET_SCHEDULER_add_continuation (te->h->sched, | 310 | GNUNET_SCHEDULER_add_continuation (te->h->sched, |
312 | GNUNET_NO, | ||
313 | te->cont, | 311 | te->cont, |
314 | te->cls, | 312 | te->cls, |
315 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 313 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/fs_unindex.c b/src/fs/fs_unindex.c index 0c3738753..243209b0e 100644 --- a/src/fs/fs_unindex.c +++ b/src/fs/fs_unindex.c | |||
@@ -420,7 +420,6 @@ GNUNET_FS_unindex_start (struct GNUNET_FS_Handle *h, | |||
420 | &pi); | 420 | &pi); |
421 | GNUNET_CRYPTO_hash_file (h->sched, | 421 | GNUNET_CRYPTO_hash_file (h->sched, |
422 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 422 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
423 | GNUNET_NO, | ||
424 | filename, | 423 | filename, |
425 | HASHING_BLOCKSIZE, | 424 | HASHING_BLOCKSIZE, |
426 | &process_hash, | 425 | &process_hash, |
diff --git a/src/fs/gnunet-service-fs.c b/src/fs/gnunet-service-fs.c index 5148c4675..ca6b9b426 100644 --- a/src/fs/gnunet-service-fs.c +++ b/src/fs/gnunet-service-fs.c | |||
@@ -1075,7 +1075,6 @@ handle_index_start (void *cls, | |||
1075 | /* slow validation, need to hash full file (again) */ | 1075 | /* slow validation, need to hash full file (again) */ |
1076 | GNUNET_CRYPTO_hash_file (sched, | 1076 | GNUNET_CRYPTO_hash_file (sched, |
1077 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1077 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1078 | GNUNET_NO, | ||
1079 | fn, | 1078 | fn, |
1080 | HASHING_BLOCKSIZE, | 1079 | HASHING_BLOCKSIZE, |
1081 | &hash_for_index_val, | 1080 | &hash_for_index_val, |
@@ -1287,9 +1286,6 @@ queue_ds_request (struct GNUNET_TIME_Relative deadline, | |||
1287 | if (deadline.value == GNUNET_TIME_UNIT_FOREVER_REL.value) | 1286 | if (deadline.value == GNUNET_TIME_UNIT_FOREVER_REL.value) |
1288 | return e; | 1287 | return e; |
1289 | e->task = GNUNET_SCHEDULER_add_delayed (sched, | 1288 | e->task = GNUNET_SCHEDULER_add_delayed (sched, |
1290 | GNUNET_NO, | ||
1291 | GNUNET_SCHEDULER_PRIORITY_BACKGROUND, | ||
1292 | GNUNET_SCHEDULER_NO_TASK, | ||
1293 | deadline, | 1289 | deadline, |
1294 | &timeout_ds_request, | 1290 | &timeout_ds_request, |
1295 | e); | 1291 | e); |
@@ -1718,13 +1714,10 @@ transmit_request_cb (void *cls, | |||
1718 | if (NULL == buf) | 1714 | if (NULL == buf) |
1719 | { | 1715 | { |
1720 | /* timeout, try another peer immediately again */ | 1716 | /* timeout, try another peer immediately again */ |
1721 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1717 | pr->task = GNUNET_SCHEDULER_add_with_priority (sched, |
1722 | GNUNET_NO, | 1718 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1723 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1719 | &forward_request_task, |
1724 | GNUNET_SCHEDULER_NO_TASK, | 1720 | pr); |
1725 | GNUNET_TIME_UNIT_ZERO, | ||
1726 | &forward_request_task, | ||
1727 | pr); | ||
1728 | return 0; | 1721 | return 0; |
1729 | } | 1722 | } |
1730 | /* (2) build query message */ | 1723 | /* (2) build query message */ |
@@ -1751,9 +1744,6 @@ transmit_request_cb (void *cls, | |||
1751 | 1744 | ||
1752 | /* (3) schedule job to do it again (or another peer, etc.) */ | 1745 | /* (3) schedule job to do it again (or another peer, etc.) */ |
1753 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1746 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
1754 | GNUNET_NO, | ||
1755 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1756 | GNUNET_SCHEDULER_NO_TASK, | ||
1757 | get_processing_delay (), // FIXME! | 1747 | get_processing_delay (), // FIXME! |
1758 | &forward_request_task, | 1748 | &forward_request_task, |
1759 | pr); | 1749 | pr); |
@@ -1797,9 +1787,6 @@ target_reservation_cb (void *cls, | |||
1797 | { | 1787 | { |
1798 | /* try again later; FIXME: we may need to un-reserve "amount"? */ | 1788 | /* try again later; FIXME: we may need to un-reserve "amount"? */ |
1799 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1789 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
1800 | GNUNET_NO, | ||
1801 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1802 | GNUNET_SCHEDULER_NO_TASK, | ||
1803 | get_processing_delay (), // FIXME: longer? | 1790 | get_processing_delay (), // FIXME: longer? |
1804 | &forward_request_task, | 1791 | &forward_request_task, |
1805 | pr); | 1792 | pr); |
@@ -1821,9 +1808,6 @@ target_reservation_cb (void *cls, | |||
1821 | { | 1808 | { |
1822 | /* try again later */ | 1809 | /* try again later */ |
1823 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1810 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
1824 | GNUNET_NO, | ||
1825 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1826 | GNUNET_SCHEDULER_NO_TASK, | ||
1827 | get_processing_delay (), // FIXME: longer? | 1811 | get_processing_delay (), // FIXME: longer? |
1828 | &forward_request_task, | 1812 | &forward_request_task, |
1829 | pr); | 1813 | pr); |
@@ -1854,9 +1838,6 @@ forward_request_task (void *cls, | |||
1854 | { | 1838 | { |
1855 | /* we're busy transmitting a result, wait a bit */ | 1839 | /* we're busy transmitting a result, wait a bit */ |
1856 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1840 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
1857 | GNUNET_NO, | ||
1858 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1859 | GNUNET_SCHEDULER_NO_TASK, | ||
1860 | get_processing_delay (), | 1841 | get_processing_delay (), |
1861 | &forward_request_task, | 1842 | &forward_request_task, |
1862 | pr); | 1843 | pr); |
@@ -1872,9 +1853,6 @@ forward_request_task (void *cls, | |||
1872 | { | 1853 | { |
1873 | /* no possible target found, wait some time */ | 1854 | /* no possible target found, wait some time */ |
1874 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1855 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
1875 | GNUNET_NO, | ||
1876 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1877 | GNUNET_SCHEDULER_NO_TASK, | ||
1878 | get_processing_delay (), // FIXME: exponential back-off? or at least wait longer... | 1856 | get_processing_delay (), // FIXME: exponential back-off? or at least wait longer... |
1879 | &forward_request_task, | 1857 | &forward_request_task, |
1880 | pr); | 1858 | pr); |
@@ -1998,9 +1976,6 @@ process_local_get_result (void *cls, | |||
1998 | pr, | 1976 | pr, |
1999 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); | 1977 | GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE); |
2000 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 1978 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
2001 | GNUNET_NO, | ||
2002 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2003 | GNUNET_SCHEDULER_NO_TASK, | ||
2004 | get_processing_delay (), | 1979 | get_processing_delay (), |
2005 | &forward_request_task, | 1980 | &forward_request_task, |
2006 | pr); | 1981 | pr); |
@@ -2132,7 +2107,6 @@ transmit_local_get_ready (void *cls, | |||
2132 | 2107 | ||
2133 | GNUNET_assert (GNUNET_OK == ok); | 2108 | GNUNET_assert (GNUNET_OK == ok); |
2134 | GNUNET_SCHEDULER_add_continuation (sched, | 2109 | GNUNET_SCHEDULER_add_continuation (sched, |
2135 | GNUNET_NO, | ||
2136 | &transmit_local_get, | 2110 | &transmit_local_get, |
2137 | lgc, | 2111 | lgc, |
2138 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 2112 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -2514,9 +2488,6 @@ forward_get_request (void *cls, | |||
2514 | destroy_pending_request (eer); | 2488 | destroy_pending_request (eer); |
2515 | } | 2489 | } |
2516 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, | 2490 | pr->task = GNUNET_SCHEDULER_add_delayed (sched, |
2517 | GNUNET_NO, | ||
2518 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2519 | GNUNET_SCHEDULER_NO_TASK, | ||
2520 | get_processing_delay (), | 2491 | get_processing_delay (), |
2521 | &forward_request_task, | 2492 | &forward_request_task, |
2522 | pr); | 2493 | pr); |
@@ -2617,7 +2588,6 @@ process_p2p_get_result (void *cls, | |||
2617 | (pgc->type == GNUNET_DATASTORE_BLOCKTYPE_SKBLOCK) ) ) | 2588 | (pgc->type == GNUNET_DATASTORE_BLOCKTYPE_SKBLOCK) ) ) |
2618 | { | 2589 | { |
2619 | GNUNET_SCHEDULER_add_continuation (sched, | 2590 | GNUNET_SCHEDULER_add_continuation (sched, |
2620 | GNUNET_NO, | ||
2621 | &forward_get_request, | 2591 | &forward_get_request, |
2622 | pgc, | 2592 | pgc, |
2623 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 2593 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -2942,7 +2912,6 @@ handle_p2p_get (void *cls, | |||
2942 | pgc); | 2912 | pgc); |
2943 | else | 2913 | else |
2944 | GNUNET_SCHEDULER_add_continuation (sched, | 2914 | GNUNET_SCHEDULER_add_continuation (sched, |
2945 | GNUNET_NO, | ||
2946 | &forward_get_request, | 2915 | &forward_get_request, |
2947 | pgc, | 2916 | pgc, |
2948 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 2917 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -3338,9 +3307,6 @@ core_start_cb (void *cls, | |||
3338 | if (server == NULL) | 3307 | if (server == NULL) |
3339 | { | 3308 | { |
3340 | GNUNET_SCHEDULER_add_delayed (sched, | 3309 | GNUNET_SCHEDULER_add_delayed (sched, |
3341 | GNUNET_NO, | ||
3342 | GNUNET_SCHEDULER_PRIORITY_HIGH, | ||
3343 | GNUNET_SCHEDULER_NO_TASK, | ||
3344 | GNUNET_TIME_UNIT_SECONDS, | 3310 | GNUNET_TIME_UNIT_SECONDS, |
3345 | &core_connect_task, | 3311 | &core_connect_task, |
3346 | NULL); | 3312 | NULL); |
@@ -3412,9 +3378,6 @@ run (void *cls, | |||
3412 | GNUNET_SERVER_add_handlers (server, handlers); | 3378 | GNUNET_SERVER_add_handlers (server, handlers); |
3413 | core_connect_task (NULL, NULL); | 3379 | core_connect_task (NULL, NULL); |
3414 | GNUNET_SCHEDULER_add_delayed (sched, | 3380 | GNUNET_SCHEDULER_add_delayed (sched, |
3415 | GNUNET_YES, | ||
3416 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
3417 | GNUNET_SCHEDULER_NO_TASK, | ||
3418 | GNUNET_TIME_UNIT_FOREVER_REL, | 3381 | GNUNET_TIME_UNIT_FOREVER_REL, |
3419 | &shutdown_task, | 3382 | &shutdown_task, |
3420 | NULL); | 3383 | NULL); |
@@ -3434,7 +3397,7 @@ main (int argc, char *const *argv) | |||
3434 | return (GNUNET_OK == | 3397 | return (GNUNET_OK == |
3435 | GNUNET_SERVICE_run (argc, | 3398 | GNUNET_SERVICE_run (argc, |
3436 | argv, | 3399 | argv, |
3437 | "fs", &run, NULL, NULL, NULL)) ? 0 : 1; | 3400 | "fs", &run, NULL)) ? 0 : 1; |
3438 | } | 3401 | } |
3439 | 3402 | ||
3440 | /* end of gnunet-service-fs.c */ | 3403 | /* end of gnunet-service-fs.c */ |
diff --git a/src/fs/test_fs_download.c b/src/fs/test_fs_download.c index 04cd3e5d8..4e73ef182 100644 --- a/src/fs/test_fs_download.c +++ b/src/fs/test_fs_download.c | |||
@@ -29,7 +29,7 @@ | |||
29 | #include "gnunet_arm_service.h" | 29 | #include "gnunet_arm_service.h" |
30 | #include "gnunet_fs_service.h" | 30 | #include "gnunet_fs_service.h" |
31 | 31 | ||
32 | #define VERBOSE GNUNET_NO | 32 | #define VERBOSE GNUNET_YES |
33 | 33 | ||
34 | #define START_ARM GNUNET_YES | 34 | #define START_ARM GNUNET_YES |
35 | 35 | ||
@@ -133,7 +133,6 @@ progress_cb (void *cls, | |||
133 | printf ("Download complete, %llu kbps.\n", | 133 | printf ("Download complete, %llu kbps.\n", |
134 | (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).value) / 1024)); | 134 | (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).value) / 1024)); |
135 | GNUNET_SCHEDULER_add_continuation (sched, | 135 | GNUNET_SCHEDULER_add_continuation (sched, |
136 | GNUNET_NO, | ||
137 | &abort_download_task, | 136 | &abort_download_task, |
138 | NULL, | 137 | NULL, |
139 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 138 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -154,7 +153,6 @@ progress_cb (void *cls, | |||
154 | event->value.publish.specifics.error.message); | 153 | event->value.publish.specifics.error.message); |
155 | GNUNET_break (0); | 154 | GNUNET_break (0); |
156 | GNUNET_SCHEDULER_add_continuation (sched, | 155 | GNUNET_SCHEDULER_add_continuation (sched, |
157 | GNUNET_NO, | ||
158 | &abort_publish_task, | 156 | &abort_publish_task, |
159 | NULL, | 157 | NULL, |
160 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 158 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -164,7 +162,6 @@ progress_cb (void *cls, | |||
164 | "Error downloading file: %s\n", | 162 | "Error downloading file: %s\n", |
165 | event->value.download.specifics.error.message); | 163 | event->value.download.specifics.error.message); |
166 | GNUNET_SCHEDULER_add_continuation (sched, | 164 | GNUNET_SCHEDULER_add_continuation (sched, |
167 | GNUNET_NO, | ||
168 | &abort_download_task, | 165 | &abort_download_task, |
169 | NULL, | 166 | NULL, |
170 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 167 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -196,7 +193,6 @@ progress_cb (void *cls, | |||
196 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: | 193 | case GNUNET_FS_STATUS_DOWNLOAD_STOPPED: |
197 | GNUNET_assert (download == event->value.download.dc); | 194 | GNUNET_assert (download == event->value.download.dc); |
198 | GNUNET_SCHEDULER_add_continuation (sched, | 195 | GNUNET_SCHEDULER_add_continuation (sched, |
199 | GNUNET_NO, | ||
200 | &abort_publish_task, | 196 | &abort_publish_task, |
201 | NULL, | 197 | NULL, |
202 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 198 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/test_fs_list_indexed.c b/src/fs/test_fs_list_indexed.c index 868c9d71a..f9225e3ce 100644 --- a/src/fs/test_fs_list_indexed.c +++ b/src/fs/test_fs_list_indexed.c | |||
@@ -97,7 +97,6 @@ list_indexed_task (void *cls, | |||
97 | { | 97 | { |
98 | 98 | ||
99 | GNUNET_SCHEDULER_add_continuation (sched, | 99 | GNUNET_SCHEDULER_add_continuation (sched, |
100 | GNUNET_NO, | ||
101 | &abort_publish_task, | 100 | &abort_publish_task, |
102 | NULL, | 101 | NULL, |
103 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 102 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -120,7 +119,6 @@ progress_cb (void *cls, | |||
120 | if (0 == strcmp ("list_indexed-context-dir", | 119 | if (0 == strcmp ("list_indexed-context-dir", |
121 | event->value.publish.cctx)) | 120 | event->value.publish.cctx)) |
122 | GNUNET_SCHEDULER_add_continuation (sched, | 121 | GNUNET_SCHEDULER_add_continuation (sched, |
123 | GNUNET_NO, | ||
124 | &list_indexed_task, | 122 | &list_indexed_task, |
125 | NULL, | 123 | NULL, |
126 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 124 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -146,7 +144,6 @@ progress_cb (void *cls, | |||
146 | if (0 == strcmp ("list_indexed-context-dir", | 144 | if (0 == strcmp ("list_indexed-context-dir", |
147 | event->value.publish.cctx)) | 145 | event->value.publish.cctx)) |
148 | GNUNET_SCHEDULER_add_continuation (sched, | 146 | GNUNET_SCHEDULER_add_continuation (sched, |
149 | GNUNET_NO, | ||
150 | &abort_publish_task, | 147 | &abort_publish_task, |
151 | NULL, | 148 | NULL, |
152 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 149 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/test_fs_publish.c b/src/fs/test_fs_publish.c index 1b79b941d..a7bcd48d9 100644 --- a/src/fs/test_fs_publish.c +++ b/src/fs/test_fs_publish.c | |||
@@ -106,7 +106,6 @@ progress_cb (void *cls, | |||
106 | if (0 == strcmp ("list_indexed-context-dir", | 106 | if (0 == strcmp ("list_indexed-context-dir", |
107 | event->value.publish.cctx)) | 107 | event->value.publish.cctx)) |
108 | GNUNET_SCHEDULER_add_continuation (sched, | 108 | GNUNET_SCHEDULER_add_continuation (sched, |
109 | GNUNET_NO, | ||
110 | &abort_publish_task, | 109 | &abort_publish_task, |
111 | NULL, | 110 | NULL, |
112 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 111 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -131,7 +130,6 @@ progress_cb (void *cls, | |||
131 | if (0 == strcmp ("list_indexed-context-dir", | 130 | if (0 == strcmp ("list_indexed-context-dir", |
132 | event->value.publish.cctx)) | 131 | event->value.publish.cctx)) |
133 | GNUNET_SCHEDULER_add_continuation (sched, | 132 | GNUNET_SCHEDULER_add_continuation (sched, |
134 | GNUNET_NO, | ||
135 | &abort_publish_task, | 133 | &abort_publish_task, |
136 | NULL, | 134 | NULL, |
137 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 135 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -171,7 +169,6 @@ progress_cb (void *cls, | |||
171 | { | 169 | { |
172 | GNUNET_assert (publish == event->value.publish.sc); | 170 | GNUNET_assert (publish == event->value.publish.sc); |
173 | GNUNET_SCHEDULER_add_continuation (sched, | 171 | GNUNET_SCHEDULER_add_continuation (sched, |
174 | GNUNET_NO, | ||
175 | &abort_publish_task, | 172 | &abort_publish_task, |
176 | NULL, | 173 | NULL, |
177 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 174 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/test_fs_search.c b/src/fs/test_fs_search.c index d1b5f77aa..e0961c4a7 100644 --- a/src/fs/test_fs_search.c +++ b/src/fs/test_fs_search.c | |||
@@ -124,7 +124,6 @@ progress_cb (void *cls, | |||
124 | printf ("Search complete.\n"); | 124 | printf ("Search complete.\n"); |
125 | #endif | 125 | #endif |
126 | GNUNET_SCHEDULER_add_continuation (sched, | 126 | GNUNET_SCHEDULER_add_continuation (sched, |
127 | GNUNET_NO, | ||
128 | &abort_search_task, | 127 | &abort_search_task, |
129 | NULL, | 128 | NULL, |
130 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 129 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -135,7 +134,6 @@ progress_cb (void *cls, | |||
135 | event->value.publish.specifics.error.message); | 134 | event->value.publish.specifics.error.message); |
136 | GNUNET_break (0); | 135 | GNUNET_break (0); |
137 | GNUNET_SCHEDULER_add_continuation (sched, | 136 | GNUNET_SCHEDULER_add_continuation (sched, |
138 | GNUNET_NO, | ||
139 | &abort_publish_task, | 137 | &abort_publish_task, |
140 | NULL, | 138 | NULL, |
141 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 139 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -145,7 +143,6 @@ progress_cb (void *cls, | |||
145 | "Error searching file: %s\n", | 143 | "Error searching file: %s\n", |
146 | event->value.search.specifics.error.message); | 144 | event->value.search.specifics.error.message); |
147 | GNUNET_SCHEDULER_add_continuation (sched, | 145 | GNUNET_SCHEDULER_add_continuation (sched, |
148 | GNUNET_NO, | ||
149 | &abort_search_task, | 146 | &abort_search_task, |
150 | NULL, | 147 | NULL, |
151 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 148 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -174,7 +171,6 @@ progress_cb (void *cls, | |||
174 | case GNUNET_FS_STATUS_SEARCH_STOPPED: | 171 | case GNUNET_FS_STATUS_SEARCH_STOPPED: |
175 | GNUNET_assert (search == event->value.search.sc); | 172 | GNUNET_assert (search == event->value.search.sc); |
176 | GNUNET_SCHEDULER_add_continuation (sched, | 173 | GNUNET_SCHEDULER_add_continuation (sched, |
177 | GNUNET_NO, | ||
178 | &abort_publish_task, | 174 | &abort_publish_task, |
179 | NULL, | 175 | NULL, |
180 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 176 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/fs/test_fs_unindex.c b/src/fs/test_fs_unindex.c index eb10c1db9..af9db7400 100644 --- a/src/fs/test_fs_unindex.c +++ b/src/fs/test_fs_unindex.c | |||
@@ -121,7 +121,6 @@ progress_cb (void *cls, | |||
121 | printf ("Unindex complete, %llu kbps.\n", | 121 | printf ("Unindex complete, %llu kbps.\n", |
122 | (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).value) / 1024)); | 122 | (unsigned long long) (FILESIZE * 1000 / (1+GNUNET_TIME_absolute_get_duration (start).value) / 1024)); |
123 | GNUNET_SCHEDULER_add_continuation (sched, | 123 | GNUNET_SCHEDULER_add_continuation (sched, |
124 | GNUNET_NO, | ||
125 | &abort_unindex_task, | 124 | &abort_unindex_task, |
126 | NULL, | 125 | NULL, |
127 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 126 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -142,7 +141,6 @@ progress_cb (void *cls, | |||
142 | event->value.publish.specifics.error.message); | 141 | event->value.publish.specifics.error.message); |
143 | GNUNET_break (0); | 142 | GNUNET_break (0); |
144 | GNUNET_SCHEDULER_add_continuation (sched, | 143 | GNUNET_SCHEDULER_add_continuation (sched, |
145 | GNUNET_NO, | ||
146 | &abort_publish_task, | 144 | &abort_publish_task, |
147 | NULL, | 145 | NULL, |
148 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 146 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -152,7 +150,6 @@ progress_cb (void *cls, | |||
152 | "Error unindexing file: %s\n", | 150 | "Error unindexing file: %s\n", |
153 | event->value.unindex.specifics.error.message); | 151 | event->value.unindex.specifics.error.message); |
154 | GNUNET_SCHEDULER_add_continuation (sched, | 152 | GNUNET_SCHEDULER_add_continuation (sched, |
155 | GNUNET_NO, | ||
156 | &abort_unindex_task, | 153 | &abort_unindex_task, |
157 | NULL, | 154 | NULL, |
158 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 155 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -181,7 +178,6 @@ progress_cb (void *cls, | |||
181 | case GNUNET_FS_STATUS_UNINDEX_STOPPED: | 178 | case GNUNET_FS_STATUS_UNINDEX_STOPPED: |
182 | GNUNET_assert (unindex == event->value.unindex.uc); | 179 | GNUNET_assert (unindex == event->value.unindex.uc); |
183 | GNUNET_SCHEDULER_add_continuation (sched, | 180 | GNUNET_SCHEDULER_add_continuation (sched, |
184 | GNUNET_NO, | ||
185 | &abort_publish_task, | 181 | &abort_publish_task, |
186 | NULL, | 182 | NULL, |
187 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 183 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/hostlist/gnunet-daemon-hostlist.c b/src/hostlist/gnunet-daemon-hostlist.c index 5aa4e70ea..78584cac9 100644 --- a/src/hostlist/gnunet-daemon-hostlist.c +++ b/src/hostlist/gnunet-daemon-hostlist.c | |||
@@ -177,9 +177,6 @@ run (void *cls, | |||
177 | NULL, GNUNET_NO, | 177 | NULL, GNUNET_NO, |
178 | handlers); | 178 | handlers); |
179 | GNUNET_SCHEDULER_add_delayed (sched, | 179 | GNUNET_SCHEDULER_add_delayed (sched, |
180 | GNUNET_YES, | ||
181 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
182 | GNUNET_SCHEDULER_NO_TASK, | ||
183 | GNUNET_TIME_UNIT_FOREVER_REL, | 180 | GNUNET_TIME_UNIT_FOREVER_REL, |
184 | &cleaning_task, NULL); | 181 | &cleaning_task, NULL); |
185 | } | 182 | } |
diff --git a/src/hostlist/hostlist-client.c b/src/hostlist/hostlist-client.c index e0ff1f5a2..8ef5c9895 100644 --- a/src/hostlist/hostlist-client.c +++ b/src/hostlist/hostlist-client.c | |||
@@ -404,7 +404,6 @@ run_multi () | |||
404 | GNUNET_NETWORK_fdset_copy_native (gws, &ws, max); | 404 | GNUNET_NETWORK_fdset_copy_native (gws, &ws, max); |
405 | current_task | 405 | current_task |
406 | = GNUNET_SCHEDULER_add_select (sched, | 406 | = GNUNET_SCHEDULER_add_select (sched, |
407 | GNUNET_NO, | ||
408 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 407 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
409 | GNUNET_SCHEDULER_NO_TASK, | 408 | GNUNET_SCHEDULER_NO_TASK, |
410 | GNUNET_TIME_UNIT_MINUTES, | 409 | GNUNET_TIME_UNIT_MINUTES, |
@@ -549,9 +548,6 @@ schedule_hostlist_task () | |||
549 | hostlist_delay.value, | 548 | hostlist_delay.value, |
550 | GNUNET_YES); | 549 | GNUNET_YES); |
551 | current_task = GNUNET_SCHEDULER_add_delayed (sched, | 550 | current_task = GNUNET_SCHEDULER_add_delayed (sched, |
552 | GNUNET_NO, | ||
553 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
554 | GNUNET_SCHEDULER_NO_TASK, | ||
555 | delay, | 551 | delay, |
556 | &check_task, | 552 | &check_task, |
557 | NULL); | 553 | NULL); |
diff --git a/src/hostlist/hostlist-server.c b/src/hostlist/hostlist-server.c index 03e3c5d69..38e144a9d 100644 --- a/src/hostlist/hostlist-server.c +++ b/src/hostlist/hostlist-server.c | |||
@@ -92,9 +92,6 @@ finish_response (struct HostSet *results) | |||
92 | GNUNET_free (results); | 92 | GNUNET_free (results); |
93 | /* schedule next update of the response */ | 93 | /* schedule next update of the response */ |
94 | GNUNET_SCHEDULER_add_delayed (sched, | 94 | GNUNET_SCHEDULER_add_delayed (sched, |
95 | GNUNET_NO, | ||
96 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
97 | GNUNET_SCHEDULER_NO_TASK, | ||
98 | RESPONSE_UPDATE_FREQUENCY, | 95 | RESPONSE_UPDATE_FREQUENCY, |
99 | &update_response, | 96 | &update_response, |
100 | NULL); | 97 | NULL); |
@@ -252,7 +249,6 @@ prepare_daemon () | |||
252 | GNUNET_NETWORK_fdset_copy_native (wes, &es, max); | 249 | GNUNET_NETWORK_fdset_copy_native (wes, &es, max); |
253 | hostlist_task | 250 | hostlist_task |
254 | = GNUNET_SCHEDULER_add_select (sched, | 251 | = GNUNET_SCHEDULER_add_select (sched, |
255 | GNUNET_NO, | ||
256 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 252 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
257 | GNUNET_SCHEDULER_NO_TASK, | 253 | GNUNET_SCHEDULER_NO_TASK, |
258 | tv, | 254 | tv, |
diff --git a/src/hostlist/test_gnunet_daemon_hostlist.c b/src/hostlist/test_gnunet_daemon_hostlist.c index d71340377..ca7a2369a 100644 --- a/src/hostlist/test_gnunet_daemon_hostlist.c +++ b/src/hostlist/test_gnunet_daemon_hostlist.c | |||
@@ -95,7 +95,6 @@ setup_peer (struct PeerContext *p, const char *cfgname) | |||
95 | "-L", "DEBUG", | 95 | "-L", "DEBUG", |
96 | #endif | 96 | #endif |
97 | "-c", cfgname, NULL); | 97 | "-c", cfgname, NULL); |
98 | sleep (1); /* allow ARM to start */ | ||
99 | #endif | 98 | #endif |
100 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); | 99 | GNUNET_assert (GNUNET_OK == GNUNET_CONFIGURATION_load (p->cfg, cfgname)); |
101 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); | 100 | GNUNET_ARM_start_services (p->cfg, sched, "core", NULL); |
diff --git a/src/include/gnunet_crypto_lib.h b/src/include/gnunet_crypto_lib.h index 76d28ad57..1dc9cb1aa 100644 --- a/src/include/gnunet_crypto_lib.h +++ b/src/include/gnunet_crypto_lib.h | |||
@@ -370,7 +370,6 @@ typedef void (*GNUNET_CRYPTO_HashCompletedCallback) (void *cls, | |||
370 | * | 370 | * |
371 | * @param sched scheduler to use | 371 | * @param sched scheduler to use |
372 | * @param priority scheduling priority to use | 372 | * @param priority scheduling priority to use |
373 | * @param run_on_shutdown should we complete even on shutdown? | ||
374 | * @param filename name of file to hash | 373 | * @param filename name of file to hash |
375 | * @param blocksize number of bytes to process in one task | 374 | * @param blocksize number of bytes to process in one task |
376 | * @param callback function to call upon completion | 375 | * @param callback function to call upon completion |
@@ -378,7 +377,6 @@ typedef void (*GNUNET_CRYPTO_HashCompletedCallback) (void *cls, | |||
378 | */ | 377 | */ |
379 | void GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, | 378 | void GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, |
380 | enum GNUNET_SCHEDULER_Priority priority, | 379 | enum GNUNET_SCHEDULER_Priority priority, |
381 | int run_on_shutdown, | ||
382 | const char *filename, | 380 | const char *filename, |
383 | size_t blocksize, | 381 | size_t blocksize, |
384 | GNUNET_CRYPTO_HashCompletedCallback callback, | 382 | GNUNET_CRYPTO_HashCompletedCallback callback, |
diff --git a/src/include/gnunet_scheduler_lib.h b/src/include/gnunet_scheduler_lib.h index 621e57fcf..760a674d5 100644 --- a/src/include/gnunet_scheduler_lib.h +++ b/src/include/gnunet_scheduler_lib.h | |||
@@ -197,21 +197,30 @@ typedef void (*GNUNET_SCHEDULER_Task) (void *cls, | |||
197 | 197 | ||
198 | 198 | ||
199 | /** | 199 | /** |
200 | * Initialize and run scheduler. This function will return when | 200 | * Initialize and run scheduler. This function will return when all |
201 | * either a shutdown was initiated (via signal) and all tasks marked | 201 | * tasks have completed. On systems with signals, receiving a SIGTERM |
202 | * to "run_on_shutdown" have been completed or when all tasks in | 202 | * (and other similar signals) will cause "GNUNET_SCHEDULER_shutdown" |
203 | * general have been completed. | 203 | * to be run after the active task is complete. As a result, SIGTERM |
204 | * causes all active tasks to be scheduled with reason | ||
205 | * "GNUNET_SCHEDULER_REASON_SHUTDOWN". (However, tasks added | ||
206 | * afterwards will execute normally!). Note that any particular | ||
207 | * signal will only shut down one scheduler; applications should | ||
208 | * always only create a single scheduler. | ||
204 | * | 209 | * |
205 | * @param task task to run immediately | 210 | * @param task task to run first (and immediately) |
206 | * @param cls closure of task | 211 | * @param task_cls closure of task |
207 | */ | 212 | */ |
208 | void GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls); | 213 | void GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls); |
209 | 214 | ||
210 | 215 | ||
211 | /** | 216 | /** |
212 | * Request the shutdown of a scheduler. This function can be used to | 217 | * Request the shutdown of a scheduler. Marks all currently |
213 | * stop a scheduler, for example from within the signal | 218 | * pending tasks as ready because of shutdown. This will |
214 | * handler for signals causing shutdowns. | 219 | * cause all tasks to run (as soon as possible, respecting |
220 | * priorities and prerequisite tasks). Note that tasks | ||
221 | * scheduled AFTER this call may still be delayed arbitrarily. | ||
222 | * | ||
223 | * @param sched the scheduler | ||
215 | */ | 224 | */ |
216 | void GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched); | 225 | void GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched); |
217 | 226 | ||
@@ -256,68 +265,70 @@ void *GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched, | |||
256 | */ | 265 | */ |
257 | void | 266 | void |
258 | GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched, | 267 | GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched, |
259 | int run_on_shutdown, | ||
260 | GNUNET_SCHEDULER_Task main, | 268 | GNUNET_SCHEDULER_Task main, |
261 | void *cls, | 269 | void *cls, |
262 | enum GNUNET_SCHEDULER_Reason reason); | 270 | enum GNUNET_SCHEDULER_Reason reason); |
263 | 271 | ||
264 | 272 | ||
265 | /** | 273 | /** |
266 | * Schedule a new task to be run after the specified | 274 | * Schedule a new task to be run after the specified prerequisite task |
267 | * prerequisite task has completed. | 275 | * has completed. It will be run with the priority of the calling |
276 | * task. | ||
268 | * | 277 | * |
269 | * @param sched scheduler to use | 278 | * @param sched scheduler to use |
270 | * @param run_on_shutdown run on shutdown? | ||
271 | * @param prio how important is this task? | ||
272 | * @param prerequisite_task run this task after the task with the given | 279 | * @param prerequisite_task run this task after the task with the given |
273 | * task identifier completes (and any of our other | 280 | * task identifier completes (and any of our other |
274 | * conditions, such as delay, read or write-readyness | 281 | * conditions, such as delay, read or write-readyness |
275 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | 282 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency |
276 | * on completion of other tasks. | 283 | * on completion of other tasks (this will cause the task to run as |
277 | * @param main main function of the task | 284 | * soon as possible). |
278 | * @param cls closure of task | 285 | * @param task main function of the task |
286 | * @param task_cls closure of task | ||
279 | * @return unique task identifier for the job | 287 | * @return unique task identifier for the job |
280 | * only valid until "main" is started! | 288 | * only valid until "task" is started! |
281 | */ | 289 | */ |
282 | GNUNET_SCHEDULER_TaskIdentifier | 290 | GNUNET_SCHEDULER_TaskIdentifier |
283 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, | 291 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, |
284 | int run_on_shutdown, | ||
285 | enum GNUNET_SCHEDULER_Priority prio, | ||
286 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | 292 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, |
287 | GNUNET_SCHEDULER_Task main, void *cls); | 293 | GNUNET_SCHEDULER_Task task, |
294 | void *task_cls); | ||
295 | |||
296 | |||
297 | /** | ||
298 | * Schedule a new task to be run with a specified priority. | ||
299 | * | ||
300 | * @param sched scheduler to use | ||
301 | * @param prio how important is the new task? | ||
302 | * @param task main function of the task | ||
303 | * @param task_cls closure of task | ||
304 | * @return unique task identifier for the job | ||
305 | * only valid until "task" is started! | ||
306 | */ | ||
307 | GNUNET_SCHEDULER_TaskIdentifier | ||
308 | GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched, | ||
309 | enum GNUNET_SCHEDULER_Priority prio, | ||
310 | GNUNET_SCHEDULER_Task task, | ||
311 | void *task_cls); | ||
288 | 312 | ||
289 | 313 | ||
290 | /** | 314 | /** |
291 | * Schedule a new task to be run with a specified delay. The task | 315 | * Schedule a new task to be run with a specified delay. The task |
292 | * will be scheduled for execution once the delay has expired and the | 316 | * will be scheduled for execution once the delay has expired. It |
293 | * prerequisite task has completed. | 317 | * will be run with the priority of the calling task. |
294 | * | 318 | * |
295 | * @param sched scheduler to use | 319 | * @param sched scheduler to use |
296 | * @param run_on_shutdown run on shutdown? You can use this | 320 | * @param delay when should this operation time out? Use |
297 | * argument to run a function only during shutdown | 321 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
298 | * by setting delay to -1. Set this | 322 | * @param task main function of the task |
299 | * argument to GNUNET_NO to skip this task if | 323 | * @param task_cls closure of task |
300 | * the user requested process termination. | ||
301 | * @param prio how important is this task? | ||
302 | * @param prerequisite_task run this task after the task with the given | ||
303 | * task identifier completes (and any of our other | ||
304 | * conditions, such as delay, read or write-readyness | ||
305 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
306 | * on completion of other tasks. | ||
307 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
308 | * @param main main function of the task | ||
309 | * @param cls closure of task | ||
310 | * @return unique task identifier for the job | 324 | * @return unique task identifier for the job |
311 | * only valid until "main" is started! | 325 | * only valid until "task" is started! |
312 | */ | 326 | */ |
313 | GNUNET_SCHEDULER_TaskIdentifier | 327 | GNUNET_SCHEDULER_TaskIdentifier |
314 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, | 328 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, |
315 | int run_on_shutdown, | ||
316 | enum GNUNET_SCHEDULER_Priority prio, | ||
317 | GNUNET_SCHEDULER_TaskIdentifier | ||
318 | prerequisite_task, | ||
319 | struct GNUNET_TIME_Relative delay, | 329 | struct GNUNET_TIME_Relative delay, |
320 | GNUNET_SCHEDULER_Task main, void *cls); | 330 | GNUNET_SCHEDULER_Task task, |
331 | void *task_cls); | ||
321 | 332 | ||
322 | 333 | ||
323 | /** | 334 | /** |
@@ -325,32 +336,24 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, | |||
325 | * specified file descriptor is ready for reading. The delay can be | 336 | * specified file descriptor is ready for reading. The delay can be |
326 | * used as a timeout on the socket being ready. The task will be | 337 | * used as a timeout on the socket being ready. The task will be |
327 | * scheduled for execution once either the delay has expired or the | 338 | * scheduled for execution once either the delay has expired or the |
328 | * socket operation is ready. | 339 | * socket operation is ready. It will be run with the priority of |
340 | * the calling task. | ||
329 | * | 341 | * |
330 | * @param sched scheduler to use | 342 | * @param sched scheduler to use |
331 | * @param run_on_shutdown run on shutdown? Set this | 343 | * @param delay when should this operation time out? Use |
332 | * argument to GNUNET_NO to skip this task if | 344 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
333 | * the user requested process termination. | ||
334 | * @param prio how important is this task? | ||
335 | * @param prerequisite_task run this task after the task with the given | ||
336 | * task identifier completes (and any of our other | ||
337 | * conditions, such as delay, read or write-readyness | ||
338 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
339 | * on completion of other tasks. | ||
340 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
341 | * @param rfd read file-descriptor | 345 | * @param rfd read file-descriptor |
342 | * @param main main function of the task | 346 | * @param task main function of the task |
343 | * @param cls closure of task | 347 | * @param task_cls closure of task |
344 | * @return unique task identifier for the job | 348 | * @return unique task identifier for the job |
345 | * only valid until "main" is started! | 349 | * only valid until "task" is started! |
346 | */ | 350 | */ |
347 | GNUNET_SCHEDULER_TaskIdentifier | 351 | GNUNET_SCHEDULER_TaskIdentifier |
348 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, | 352 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, |
349 | int run_on_shutdown, | 353 | struct GNUNET_TIME_Relative delay, |
350 | enum GNUNET_SCHEDULER_Priority prio, | 354 | struct GNUNET_NETWORK_Handle *rfd, |
351 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | 355 | GNUNET_SCHEDULER_Task task, |
352 | struct GNUNET_TIME_Relative delay, | 356 | void *task_cls); |
353 | struct GNUNET_NETWORK_Handle *rfd, GNUNET_SCHEDULER_Task main, void *cls); | ||
354 | 357 | ||
355 | 358 | ||
356 | /** | 359 | /** |
@@ -358,32 +361,24 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
358 | * specified file descriptor is ready for writing. The delay can be | 361 | * specified file descriptor is ready for writing. The delay can be |
359 | * used as a timeout on the socket being ready. The task will be | 362 | * used as a timeout on the socket being ready. The task will be |
360 | * scheduled for execution once either the delay has expired or the | 363 | * scheduled for execution once either the delay has expired or the |
361 | * socket operation is ready. | 364 | * socket operation is ready. It will be run with the priority of |
365 | * the calling task. | ||
362 | * | 366 | * |
363 | * @param sched scheduler to use | 367 | * @param sched scheduler to use |
364 | * @param run_on_shutdown run on shutdown? Set this | 368 | * @param delay when should this operation time out? Use |
365 | * argument to GNUNET_NO to skip this task if | 369 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
366 | * the user requested process termination. | ||
367 | * @param prio how important is this task? | ||
368 | * @param prerequisite_task run this task after the task with the given | ||
369 | * task identifier completes (and any of our other | ||
370 | * conditions, such as delay, read or write-readyness | ||
371 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
372 | * on completion of other tasks. | ||
373 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
374 | * @param wfd write file-descriptor | 370 | * @param wfd write file-descriptor |
375 | * @param main main function of the task | 371 | * @param task main function of the task |
376 | * @param cls closure of task | 372 | * @param task_cls closure of task |
377 | * @return unique task identifier for the job | 373 | * @return unique task identifier for the job |
378 | * only valid until "main" is started! | 374 | * only valid until "task" is started! |
379 | */ | 375 | */ |
380 | GNUNET_SCHEDULER_TaskIdentifier | 376 | GNUNET_SCHEDULER_TaskIdentifier |
381 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, | 377 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, |
382 | int run_on_shutdown, | 378 | struct GNUNET_TIME_Relative delay, |
383 | enum GNUNET_SCHEDULER_Priority prio, | 379 | struct GNUNET_NETWORK_Handle *wfd, |
384 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | 380 | GNUNET_SCHEDULER_Task task, |
385 | struct GNUNET_TIME_Relative delay, | 381 | void *task_cls); |
386 | struct GNUNET_NETWORK_Handle *wfd, GNUNET_SCHEDULER_Task main, void *cls); | ||
387 | 382 | ||
388 | 383 | ||
389 | /** | 384 | /** |
@@ -391,33 +386,24 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, | |||
391 | * specified file descriptor is ready for reading. The delay can be | 386 | * specified file descriptor is ready for reading. The delay can be |
392 | * used as a timeout on the socket being ready. The task will be | 387 | * used as a timeout on the socket being ready. The task will be |
393 | * scheduled for execution once either the delay has expired or the | 388 | * scheduled for execution once either the delay has expired or the |
394 | * socket operation is ready. | 389 | * socket operation is ready. It will be run with the priority of |
390 | * the calling task. | ||
395 | * | 391 | * |
396 | * @param sched scheduler to use | 392 | * @param sched scheduler to use |
397 | * @param run_on_shutdown run on shutdown? Set this | 393 | * @param delay when should this operation time out? Use |
398 | * argument to GNUNET_NO to skip this task if | 394 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
399 | * the user requested process termination. | ||
400 | * @param prio how important is this task? | ||
401 | * @param prerequisite_task run this task after the task with the given | ||
402 | * task identifier completes (and any of our other | ||
403 | * conditions, such as delay, read or write-readyness | ||
404 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
405 | * on completion of other tasks. | ||
406 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
407 | * @param rfd read file-descriptor | 395 | * @param rfd read file-descriptor |
408 | * @param main main function of the task | 396 | * @param task main function of the task |
409 | * @param cls closure of task | 397 | * @param task_cls closure of task |
410 | * @return unique task identifier for the job | 398 | * @return unique task identifier for the job |
411 | * only valid until "main" is started! | 399 | * only valid until "task" is started! |
412 | */ | 400 | */ |
413 | GNUNET_SCHEDULER_TaskIdentifier | 401 | GNUNET_SCHEDULER_TaskIdentifier |
414 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | 402 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, |
415 | int run_on_shutdown, | ||
416 | enum GNUNET_SCHEDULER_Priority prio, | ||
417 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | ||
418 | struct GNUNET_TIME_Relative delay, | 403 | struct GNUNET_TIME_Relative delay, |
419 | const struct GNUNET_DISK_FileHandle *rfd, | 404 | const struct GNUNET_DISK_FileHandle *rfd, |
420 | GNUNET_SCHEDULER_Task main, void *cls); | 405 | GNUNET_SCHEDULER_Task task, |
406 | void *task_cls); | ||
421 | 407 | ||
422 | 408 | ||
423 | /** | 409 | /** |
@@ -425,33 +411,24 @@ GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
425 | * specified file descriptor is ready for writing. The delay can be | 411 | * specified file descriptor is ready for writing. The delay can be |
426 | * used as a timeout on the socket being ready. The task will be | 412 | * used as a timeout on the socket being ready. The task will be |
427 | * scheduled for execution once either the delay has expired or the | 413 | * scheduled for execution once either the delay has expired or the |
428 | * socket operation is ready. | 414 | * socket operation is ready. It will be run with the priority of |
415 | * the calling task. | ||
429 | * | 416 | * |
430 | * @param sched scheduler to use | 417 | * @param sched scheduler to use |
431 | * @param run_on_shutdown run on shutdown? Set this | 418 | * @param delay when should this operation time out? Use |
432 | * argument to GNUNET_NO to skip this task if | 419 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
433 | * the user requested process termination. | ||
434 | * @param prio how important is this task? | ||
435 | * @param prerequisite_task run this task after the task with the given | ||
436 | * task identifier completes (and any of our other | ||
437 | * conditions, such as delay, read or write-readyness | ||
438 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
439 | * on completion of other tasks. | ||
440 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
441 | * @param wfd write file-descriptor | 420 | * @param wfd write file-descriptor |
442 | * @param main main function of the task | 421 | * @param task main function of the task |
443 | * @param cls closure of task | 422 | * @param task_cls closure of task |
444 | * @return unique task identifier for the job | 423 | * @return unique task identifier for the job |
445 | * only valid until "main" is started! | 424 | * only valid until "task" is started! |
446 | */ | 425 | */ |
447 | GNUNET_SCHEDULER_TaskIdentifier | 426 | GNUNET_SCHEDULER_TaskIdentifier |
448 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | 427 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, |
449 | int run_on_shutdown, | ||
450 | enum GNUNET_SCHEDULER_Priority prio, | ||
451 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | ||
452 | struct GNUNET_TIME_Relative delay, | 428 | struct GNUNET_TIME_Relative delay, |
453 | const struct GNUNET_DISK_FileHandle *wfd, | 429 | const struct GNUNET_DISK_FileHandle *wfd, |
454 | GNUNET_SCHEDULER_Task main, void *cls); | 430 | GNUNET_SCHEDULER_Task task, |
431 | void *task_cls); | ||
455 | 432 | ||
456 | 433 | ||
457 | /** | 434 | /** |
@@ -472,33 +449,31 @@ GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
472 | * </code> | 449 | * </code> |
473 | * | 450 | * |
474 | * @param sched scheduler to use | 451 | * @param sched scheduler to use |
475 | * @param run_on_shutdown run on shutdown? Set this | ||
476 | * argument to GNUNET_NO to skip this task if | ||
477 | * the user requested process termination. | ||
478 | * @param prio how important is this task? | 452 | * @param prio how important is this task? |
479 | * @param prerequisite_task run this task after the task with the given | 453 | * @param prerequisite_task run this task after the task with the given |
480 | * task identifier completes (and any of our other | 454 | * task identifier completes (and any of our other |
481 | * conditions, such as delay, read or write-readyness | 455 | * conditions, such as delay, read or write-readyness |
482 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | 456 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency |
483 | * on completion of other tasks. | 457 | * on completion of other tasks. |
484 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | 458 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever", |
459 | * which means that the task will only be run after we receive SIGTERM | ||
485 | * @param rs set of file descriptors we want to read (can be NULL) | 460 | * @param rs set of file descriptors we want to read (can be NULL) |
486 | * @param ws set of file descriptors we want to write (can be NULL) | 461 | * @param ws set of file descriptors we want to write (can be NULL) |
487 | * @param main main function of the task | 462 | * @param task main function of the task |
488 | * @param cls closure of task | 463 | * @param task_cls closure of task |
489 | * @return unique task identifier for the job | 464 | * @return unique task identifier for the job |
490 | * only valid until "main" is started! | 465 | * only valid until "task" is started! |
491 | */ | 466 | */ |
492 | GNUNET_SCHEDULER_TaskIdentifier | 467 | GNUNET_SCHEDULER_TaskIdentifier |
493 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched, | 468 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched, |
494 | int run_on_shutdown, | ||
495 | enum GNUNET_SCHEDULER_Priority prio, | 469 | enum GNUNET_SCHEDULER_Priority prio, |
496 | GNUNET_SCHEDULER_TaskIdentifier | 470 | GNUNET_SCHEDULER_TaskIdentifier |
497 | prerequisite_task, | 471 | prerequisite_task, |
498 | struct GNUNET_TIME_Relative delay, | 472 | struct GNUNET_TIME_Relative delay, |
499 | const struct GNUNET_NETWORK_FDSet * rs, | 473 | const struct GNUNET_NETWORK_FDSet * rs, |
500 | const struct GNUNET_NETWORK_FDSet * ws, | 474 | const struct GNUNET_NETWORK_FDSet * ws, |
501 | GNUNET_SCHEDULER_Task main, void *cls); | 475 | GNUNET_SCHEDULER_Task task, |
476 | void *task_cls); | ||
502 | 477 | ||
503 | #if 0 /* keep Emacsens' auto-indent happy */ | 478 | #if 0 /* keep Emacsens' auto-indent happy */ |
504 | { | 479 | { |
diff --git a/src/include/gnunet_service_lib.h b/src/include/gnunet_service_lib.h index 0c69d297c..82089954e 100644 --- a/src/include/gnunet_service_lib.h +++ b/src/include/gnunet_service_lib.h | |||
@@ -55,18 +55,6 @@ typedef void (*GNUNET_SERVICE_Main) (void *cls, | |||
55 | 55 | ||
56 | 56 | ||
57 | /** | 57 | /** |
58 | * Function called when the service shuts | ||
59 | * down to run service-specific teardown code. | ||
60 | * | ||
61 | * @param cls closure | ||
62 | * @param cfg configuration to use | ||
63 | */ | ||
64 | typedef void (*GNUNET_SERVICE_Term) (void *cls, | ||
65 | const struct GNUNET_CONFIGURATION_Handle * | ||
66 | cfg); | ||
67 | |||
68 | |||
69 | /** | ||
70 | * Run a standard GNUnet service startup sequence (initialize loggers | 58 | * Run a standard GNUnet service startup sequence (initialize loggers |
71 | * and configuration, parse options). | 59 | * and configuration, parse options). |
72 | * | 60 | * |
@@ -75,8 +63,6 @@ typedef void (*GNUNET_SERVICE_Term) (void *cls, | |||
75 | * @param serviceName our service name | 63 | * @param serviceName our service name |
76 | * @param task main task of the service | 64 | * @param task main task of the service |
77 | * @param task_cls closure for task | 65 | * @param task_cls closure for task |
78 | * @param term termination task of the service | ||
79 | * @param term_cls closure for term | ||
80 | * @return GNUNET_SYSERR on error, GNUNET_OK | 66 | * @return GNUNET_SYSERR on error, GNUNET_OK |
81 | * if we shutdown nicely | 67 | * if we shutdown nicely |
82 | */ | 68 | */ |
@@ -84,8 +70,7 @@ int GNUNET_SERVICE_run (int argc, | |||
84 | char *const *argv, | 70 | char *const *argv, |
85 | const char *serviceName, | 71 | const char *serviceName, |
86 | GNUNET_SERVICE_Main task, | 72 | GNUNET_SERVICE_Main task, |
87 | void *task_cls, | 73 | void *task_cls); |
88 | GNUNET_SERVICE_Term term, void *term_cls); | ||
89 | 74 | ||
90 | 75 | ||
91 | struct GNUNET_SERVICE_Context; | 76 | struct GNUNET_SERVICE_Context; |
diff --git a/src/nat/nat.c b/src/nat/nat.c index 2a93d31a7..151c526d4 100644 --- a/src/nat/nat.c +++ b/src/nat/nat.c | |||
@@ -285,9 +285,7 @@ nat_pulse (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
285 | notify_change (nat, ext_addr_natpmp, port_mapped); | 285 | notify_change (nat, ext_addr_natpmp, port_mapped); |
286 | } | 286 | } |
287 | 287 | ||
288 | nat->pulse_timer = GNUNET_SCHEDULER_add_delayed (nat->sched, GNUNET_NO, | 288 | nat->pulse_timer = GNUNET_SCHEDULER_add_delayed (nat->sched, |
289 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
290 | GNUNET_SCHEDULER_NO_TASK, | ||
291 | GNUNET_TIME_UNIT_SECONDS, | 289 | GNUNET_TIME_UNIT_SECONDS, |
292 | &nat_pulse, nat); | 290 | &nat_pulse, nat); |
293 | } | 291 | } |
@@ -335,9 +333,7 @@ GNUNET_NAT_register (struct GNUNET_SCHEDULER_Handle *sched, | |||
335 | nat->natpmp = GNUNET_NAT_NATPMP_init (nat->local_addr, addrlen, nat->public_port); | 333 | nat->natpmp = GNUNET_NAT_NATPMP_init (nat->local_addr, addrlen, nat->public_port); |
336 | nat->upnp = GNUNET_NAT_UPNP_init (nat->local_addr, addrlen, nat->public_port); | 334 | nat->upnp = GNUNET_NAT_UPNP_init (nat->local_addr, addrlen, nat->public_port); |
337 | 335 | ||
338 | nat->pulse_timer = GNUNET_SCHEDULER_add_delayed (sched, GNUNET_NO, | 336 | nat->pulse_timer = GNUNET_SCHEDULER_add_delayed (sched, |
339 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
340 | GNUNET_SCHEDULER_NO_TASK, | ||
341 | GNUNET_TIME_UNIT_SECONDS, | 337 | GNUNET_TIME_UNIT_SECONDS, |
342 | &nat_pulse, nat); | 338 | &nat_pulse, nat); |
343 | 339 | ||
diff --git a/src/nat/test_nat.c b/src/nat/test_nat.c index 2ff168c56..dc5112c36 100644 --- a/src/nat/test_nat.c +++ b/src/nat/test_nat.c | |||
@@ -125,9 +125,7 @@ run (void *cls, | |||
125 | nat = GNUNET_NAT_register (sched, addr, data.addrlen, addr_callback, NULL); | 125 | nat = GNUNET_NAT_register (sched, addr, data.addrlen, addr_callback, NULL); |
126 | GNUNET_free (addr); | 126 | GNUNET_free (addr); |
127 | 127 | ||
128 | GNUNET_SCHEDULER_add_delayed (sched, GNUNET_NO, | 128 | GNUNET_SCHEDULER_add_delayed (sched, |
129 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
130 | GNUNET_SCHEDULER_NO_TASK, | ||
131 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, TIMEOUT), | 129 | GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_SECONDS, TIMEOUT), |
132 | stop, nat); | 130 | stop, nat); |
133 | } | 131 | } |
diff --git a/src/peerinfo/gnunet-service-peerinfo.c b/src/peerinfo/gnunet-service-peerinfo.c index 11e311c22..f5a60470e 100644 --- a/src/peerinfo/gnunet-service-peerinfo.c +++ b/src/peerinfo/gnunet-service-peerinfo.c | |||
@@ -342,6 +342,8 @@ cron_scan_directory_data_hosts (void *cls, | |||
342 | static unsigned int retries; | 342 | static unsigned int retries; |
343 | unsigned int count; | 343 | unsigned int count; |
344 | 344 | ||
345 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | ||
346 | return; | ||
345 | count = 0; | 347 | count = 0; |
346 | GNUNET_DISK_directory_create (networkIdDirectory); | 348 | GNUNET_DISK_directory_create (networkIdDirectory); |
347 | GNUNET_DISK_directory_scan (networkIdDirectory, | 349 | GNUNET_DISK_directory_scan (networkIdDirectory, |
@@ -351,9 +353,6 @@ cron_scan_directory_data_hosts (void *cls, | |||
351 | GNUNET_ERROR_TYPE_BULK, | 353 | GNUNET_ERROR_TYPE_BULK, |
352 | _("Still no peers found in `%s'!\n"), networkIdDirectory); | 354 | _("Still no peers found in `%s'!\n"), networkIdDirectory); |
353 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 355 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
354 | GNUNET_NO, | ||
355 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
356 | GNUNET_SCHEDULER_NO_TASK, | ||
357 | DATA_HOST_FREQ, | 356 | DATA_HOST_FREQ, |
358 | &cron_scan_directory_data_hosts, NULL); | 357 | &cron_scan_directory_data_hosts, NULL); |
359 | } | 358 | } |
@@ -501,12 +500,10 @@ cron_flush_trust (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
501 | flush_trust (pos); | 500 | flush_trust (pos); |
502 | pos = pos->next; | 501 | pos = pos->next; |
503 | } | 502 | } |
504 | if (0 == (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | 503 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) |
505 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 504 | return; |
506 | GNUNET_YES, | 505 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
507 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 506 | TRUST_FLUSH_FREQ, &cron_flush_trust, NULL); |
508 | GNUNET_SCHEDULER_NO_TASK, | ||
509 | TRUST_FLUSH_FREQ, &cron_flush_trust, NULL); | ||
510 | } | 507 | } |
511 | 508 | ||
512 | 509 | ||
@@ -558,14 +555,13 @@ cron_clean_data_hosts (void *cls, | |||
558 | { | 555 | { |
559 | struct GNUNET_TIME_Absolute now; | 556 | struct GNUNET_TIME_Absolute now; |
560 | 557 | ||
558 | if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN)) | ||
559 | return; | ||
561 | now = GNUNET_TIME_absolute_get (); | 560 | now = GNUNET_TIME_absolute_get (); |
562 | GNUNET_DISK_directory_scan (networkIdDirectory, | 561 | GNUNET_DISK_directory_scan (networkIdDirectory, |
563 | &discard_hosts_helper, &now); | 562 | &discard_hosts_helper, &now); |
564 | 563 | ||
565 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 564 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
566 | GNUNET_NO, | ||
567 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
568 | GNUNET_SCHEDULER_NO_TASK, | ||
569 | DATA_HOST_CLEAN_FREQ, | 565 | DATA_HOST_CLEAN_FREQ, |
570 | &cron_clean_data_hosts, NULL); | 566 | &cron_clean_data_hosts, NULL); |
571 | } | 567 | } |
@@ -660,6 +656,7 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = { | |||
660 | }; | 656 | }; |
661 | 657 | ||
662 | 658 | ||
659 | |||
663 | /** | 660 | /** |
664 | * Process statistics requests. | 661 | * Process statistics requests. |
665 | * | 662 | * |
@@ -686,23 +683,15 @@ run (void *cls, | |||
686 | &trustDirectory)); | 683 | &trustDirectory)); |
687 | GNUNET_DISK_directory_create (networkIdDirectory); | 684 | GNUNET_DISK_directory_create (networkIdDirectory); |
688 | GNUNET_DISK_directory_create (trustDirectory); | 685 | GNUNET_DISK_directory_create (trustDirectory); |
689 | GNUNET_SCHEDULER_add_delayed (sched, | 686 | GNUNET_SCHEDULER_add_with_priority (sched, |
690 | GNUNET_NO, | 687 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
691 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 688 | &cron_scan_directory_data_hosts, NULL); |
692 | GNUNET_SCHEDULER_NO_TASK, | 689 | GNUNET_SCHEDULER_add_with_priority (sched, |
693 | GNUNET_TIME_UNIT_MILLISECONDS, | 690 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
694 | &cron_scan_directory_data_hosts, NULL); | 691 | &cron_flush_trust, NULL); |
695 | GNUNET_SCHEDULER_add_delayed (sched, | 692 | GNUNET_SCHEDULER_add_with_priority (sched, |
696 | GNUNET_YES, | 693 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
697 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 694 | &cron_clean_data_hosts, NULL); |
698 | GNUNET_SCHEDULER_NO_TASK, | ||
699 | TRUST_FLUSH_FREQ, &cron_flush_trust, NULL); | ||
700 | GNUNET_SCHEDULER_add_delayed (sched, | ||
701 | GNUNET_NO, | ||
702 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
703 | GNUNET_SCHEDULER_NO_TASK, | ||
704 | DATA_HOST_CLEAN_FREQ, | ||
705 | &cron_clean_data_hosts, NULL); | ||
706 | GNUNET_SERVER_add_handlers (server, handlers); | 695 | GNUNET_SERVER_add_handlers (server, handlers); |
707 | } | 696 | } |
708 | 697 | ||
@@ -722,7 +711,7 @@ main (int argc, char *const *argv) | |||
722 | ret = (GNUNET_OK == | 711 | ret = (GNUNET_OK == |
723 | GNUNET_SERVICE_run (argc, | 712 | GNUNET_SERVICE_run (argc, |
724 | argv, | 713 | argv, |
725 | "peerinfo", &run, NULL, NULL, NULL)) ? 0 : 1; | 714 | "peerinfo", &run, NULL)) ? 0 : 1; |
726 | GNUNET_free_non_null (networkIdDirectory); | 715 | GNUNET_free_non_null (networkIdDirectory); |
727 | GNUNET_free_non_null (trustDirectory); | 716 | GNUNET_free_non_null (trustDirectory); |
728 | return ret; | 717 | return ret; |
diff --git a/src/peerinfo/test_peerinfo_api.c b/src/peerinfo/test_peerinfo_api.c index 2bae851bc..a375ca40e 100644 --- a/src/peerinfo/test_peerinfo_api.c +++ b/src/peerinfo/test_peerinfo_api.c | |||
@@ -149,7 +149,6 @@ check () | |||
149 | "-L", "DEBUG", | 149 | "-L", "DEBUG", |
150 | #endif | 150 | #endif |
151 | "-c", "test_peerinfo_api_data.conf", NULL); | 151 | "-c", "test_peerinfo_api_data.conf", NULL); |
152 | sleep (1); | ||
153 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, | 152 | GNUNET_PROGRAM_run ((sizeof (argv) / sizeof (char *)) - 1, |
154 | argv, "test-peerinfo-api", "nohelp", | 153 | argv, "test-peerinfo-api", "nohelp", |
155 | options, &run, &ok); | 154 | options, &run, &ok); |
diff --git a/src/statistics/gnunet-service-statistics.c b/src/statistics/gnunet-service-statistics.c index 3221fe2ae..8de9a8047 100644 --- a/src/statistics/gnunet-service-statistics.c +++ b/src/statistics/gnunet-service-statistics.c | |||
@@ -83,6 +83,11 @@ struct StatsEntry | |||
83 | }; | 83 | }; |
84 | 84 | ||
85 | /** | 85 | /** |
86 | * Our configuration. | ||
87 | */ | ||
88 | static const struct GNUNET_CONFIGURATION_Handle *cfg; | ||
89 | |||
90 | /** | ||
86 | * Linked list of our active statistics. | 91 | * Linked list of our active statistics. |
87 | */ | 92 | */ |
88 | static struct StatsEntry *start; | 93 | static struct StatsEntry *start; |
@@ -96,10 +101,11 @@ static uint32_t uidgen; | |||
96 | * Load persistent values from disk. Disk format is | 101 | * Load persistent values from disk. Disk format is |
97 | * exactly the same format that we also use for | 102 | * exactly the same format that we also use for |
98 | * setting the values over the network. | 103 | * setting the values over the network. |
104 | * | ||
105 | * @param server handle to the server context | ||
99 | */ | 106 | */ |
100 | static void | 107 | static void |
101 | load (struct GNUNET_SERVER_Handle *server, | 108 | load (struct GNUNET_SERVER_Handle *server) |
102 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
103 | { | 109 | { |
104 | char *fn; | 110 | char *fn; |
105 | struct GNUNET_DISK_FileHandle *fh; | 111 | struct GNUNET_DISK_FileHandle *fh; |
@@ -153,16 +159,11 @@ load (struct GNUNET_SERVER_Handle *server, | |||
153 | GNUNET_free (fn); | 159 | GNUNET_free (fn); |
154 | } | 160 | } |
155 | 161 | ||
156 | |||
157 | /** | 162 | /** |
158 | * Write persistent statistics to disk. | 163 | * Write persistent statistics to disk. |
159 | * | ||
160 | * @param cls closure | ||
161 | * @param cfg configuration to use | ||
162 | */ | 164 | */ |
163 | static void | 165 | static void |
164 | save (void *cls, | 166 | save () |
165 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
166 | { | 167 | { |
167 | struct StatsEntry *pos; | 168 | struct StatsEntry *pos; |
168 | char *fn; | 169 | char *fn; |
@@ -435,21 +436,40 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = { | |||
435 | 436 | ||
436 | 437 | ||
437 | /** | 438 | /** |
439 | * Task run during shutdown. | ||
440 | * | ||
441 | * @param cls unused | ||
442 | * @param tc unused | ||
443 | */ | ||
444 | static void | ||
445 | shutdown_task (void *cls, | ||
446 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
447 | { | ||
448 | save (); | ||
449 | } | ||
450 | |||
451 | |||
452 | /** | ||
438 | * Process statistics requests. | 453 | * Process statistics requests. |
439 | * | 454 | * |
440 | * @param cls closure | 455 | * @param cls closure |
441 | * @param sched scheduler to use | 456 | * @param sched scheduler to use |
442 | * @param server the initialized server | 457 | * @param server the initialized server |
443 | * @param cfg configuration to use | 458 | * @param c configuration to use |
444 | */ | 459 | */ |
445 | static void | 460 | static void |
446 | run (void *cls, | 461 | run (void *cls, |
447 | struct GNUNET_SCHEDULER_Handle *sched, | 462 | struct GNUNET_SCHEDULER_Handle *sched, |
448 | struct GNUNET_SERVER_Handle *server, | 463 | struct GNUNET_SERVER_Handle *server, |
449 | const struct GNUNET_CONFIGURATION_Handle *cfg) | 464 | const struct GNUNET_CONFIGURATION_Handle *c) |
450 | { | 465 | { |
466 | cfg = c; | ||
451 | GNUNET_SERVER_add_handlers (server, handlers); | 467 | GNUNET_SERVER_add_handlers (server, handlers); |
452 | load (server, cfg); | 468 | load (server); |
469 | GNUNET_SCHEDULER_add_delayed (sched, | ||
470 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
471 | &shutdown_task, | ||
472 | NULL); | ||
453 | } | 473 | } |
454 | 474 | ||
455 | 475 | ||
@@ -466,7 +486,7 @@ main (int argc, char *const *argv) | |||
466 | return (GNUNET_OK == | 486 | return (GNUNET_OK == |
467 | GNUNET_SERVICE_run (argc, | 487 | GNUNET_SERVICE_run (argc, |
468 | argv, | 488 | argv, |
469 | "statistics", &run, NULL, &save, NULL)) ? 0 : 1; | 489 | "statistics", &run, NULL)) ? 0 : 1; |
470 | } | 490 | } |
471 | 491 | ||
472 | /* end of gnunet-service-statistics.c */ | 492 | /* end of gnunet-service-statistics.c */ |
diff --git a/src/template/gnunet-service-template.c b/src/template/gnunet-service-template.c index 3ab7d3dcc..15ba94b7d 100644 --- a/src/template/gnunet-service-template.c +++ b/src/template/gnunet-service-template.c | |||
@@ -27,19 +27,6 @@ | |||
27 | #include "gnunet_getopt_lib.h" | 27 | #include "gnunet_getopt_lib.h" |
28 | #include "gnunet_service_lib.h" | 28 | #include "gnunet_service_lib.h" |
29 | 29 | ||
30 | /** | ||
31 | * Do cleanup here. | ||
32 | * | ||
33 | * @param cls closure | ||
34 | * @param cfg configuration to use | ||
35 | */ | ||
36 | static void | ||
37 | finish (void *cls, | ||
38 | const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
39 | { | ||
40 | /* FIXME */ | ||
41 | } | ||
42 | |||
43 | 30 | ||
44 | /** | 31 | /** |
45 | * List of handlers for the messages understood by this | 32 | * List of handlers for the messages understood by this |
@@ -50,6 +37,21 @@ static struct GNUNET_SERVER_MessageHandler handlers[] = { | |||
50 | {NULL, NULL, 0, 0} | 37 | {NULL, NULL, 0, 0} |
51 | }; | 38 | }; |
52 | 39 | ||
40 | |||
41 | /** | ||
42 | * Task run during shutdown. | ||
43 | * | ||
44 | * @param cls unused | ||
45 | * @param tc unused | ||
46 | */ | ||
47 | static void | ||
48 | cleanup_task (void *cls, | ||
49 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
50 | { | ||
51 | /* FIXME: do clean up here */ | ||
52 | } | ||
53 | |||
54 | |||
53 | /** | 55 | /** |
54 | * Process template requests. | 56 | * Process template requests. |
55 | * | 57 | * |
@@ -66,6 +68,10 @@ run (void *cls, | |||
66 | { | 68 | { |
67 | /* FIXME: do setup here */ | 69 | /* FIXME: do setup here */ |
68 | GNUNET_SERVER_add_handlers (server, handlers); | 70 | GNUNET_SERVER_add_handlers (server, handlers); |
71 | GNUNET_SCHEDULER_add_delayed (sched, | ||
72 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
73 | &cleanup_task, | ||
74 | NULL); | ||
69 | } | 75 | } |
70 | 76 | ||
71 | 77 | ||
@@ -82,7 +88,7 @@ main (int argc, char *const *argv) | |||
82 | return (GNUNET_OK == | 88 | return (GNUNET_OK == |
83 | GNUNET_SERVICE_run (argc, | 89 | GNUNET_SERVICE_run (argc, |
84 | argv, | 90 | argv, |
85 | "template", &run, NULL, &finish, NULL)) ? 0 : 1; | 91 | "template", &run, NULL)) ? 0 : 1; |
86 | } | 92 | } |
87 | 93 | ||
88 | /* end of gnunet-service-template.c */ | 94 | /* end of gnunet-service-template.c */ |
diff --git a/src/testing/testing.c b/src/testing/testing.c index 2bd14095f..e34e7a9ac 100644 --- a/src/testing/testing.c +++ b/src/testing/testing.c | |||
@@ -306,9 +306,6 @@ start_fsm (void *cls, | |||
306 | /* wait some more */ | 306 | /* wait some more */ |
307 | d->task | 307 | d->task |
308 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 308 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
309 | GNUNET_NO, | ||
310 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
311 | GNUNET_SCHEDULER_NO_TASK, | ||
312 | GNUNET_CONSTANTS_EXEC_WAIT, | 309 | GNUNET_CONSTANTS_EXEC_WAIT, |
313 | &start_fsm, | 310 | &start_fsm, |
314 | d); | 311 | d); |
@@ -392,9 +389,6 @@ start_fsm (void *cls, | |||
392 | d->wait_runs = 0; | 389 | d->wait_runs = 0; |
393 | d->task | 390 | d->task |
394 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 391 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
395 | GNUNET_NO, | ||
396 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
397 | GNUNET_SCHEDULER_NO_TASK, | ||
398 | GNUNET_CONSTANTS_EXEC_WAIT, | 392 | GNUNET_CONSTANTS_EXEC_WAIT, |
399 | &start_fsm, | 393 | &start_fsm, |
400 | d); | 394 | d); |
@@ -423,9 +417,6 @@ start_fsm (void *cls, | |||
423 | /* wait some more */ | 417 | /* wait some more */ |
424 | d->task | 418 | d->task |
425 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 419 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
426 | GNUNET_NO, | ||
427 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
428 | GNUNET_SCHEDULER_NO_TASK, | ||
429 | GNUNET_CONSTANTS_EXEC_WAIT, | 420 | GNUNET_CONSTANTS_EXEC_WAIT, |
430 | &start_fsm, | 421 | &start_fsm, |
431 | d); | 422 | d); |
@@ -474,9 +465,6 @@ start_fsm (void *cls, | |||
474 | /* wait some more */ | 465 | /* wait some more */ |
475 | d->task | 466 | d->task |
476 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 467 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
477 | GNUNET_NO, | ||
478 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
479 | GNUNET_SCHEDULER_NO_TASK, | ||
480 | GNUNET_CONSTANTS_EXEC_WAIT, | 468 | GNUNET_CONSTANTS_EXEC_WAIT, |
481 | &start_fsm, | 469 | &start_fsm, |
482 | d); | 470 | d); |
@@ -528,9 +516,6 @@ start_fsm (void *cls, | |||
528 | /* wait some more */ | 516 | /* wait some more */ |
529 | d->task | 517 | d->task |
530 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 518 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
531 | GNUNET_NO, | ||
532 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
533 | GNUNET_SCHEDULER_NO_TASK, | ||
534 | GNUNET_CONSTANTS_EXEC_WAIT, | 519 | GNUNET_CONSTANTS_EXEC_WAIT, |
535 | &start_fsm, | 520 | &start_fsm, |
536 | d); | 521 | d); |
@@ -675,9 +660,6 @@ GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched, | |||
675 | } | 660 | } |
676 | ret->task | 661 | ret->task |
677 | = GNUNET_SCHEDULER_add_delayed (sched, | 662 | = GNUNET_SCHEDULER_add_delayed (sched, |
678 | GNUNET_YES, | ||
679 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
680 | GNUNET_SCHEDULER_NO_TASK, | ||
681 | GNUNET_CONSTANTS_EXEC_WAIT, | 663 | GNUNET_CONSTANTS_EXEC_WAIT, |
682 | &start_fsm, | 664 | &start_fsm, |
683 | ret); | 665 | ret); |
@@ -689,7 +671,6 @@ GNUNET_TESTING_daemon_start (struct GNUNET_SCHEDULER_Handle *sched, | |||
689 | #endif | 671 | #endif |
690 | ret->phase = SP_COPIED; | 672 | ret->phase = SP_COPIED; |
691 | GNUNET_SCHEDULER_add_continuation (sched, | 673 | GNUNET_SCHEDULER_add_continuation (sched, |
692 | GNUNET_NO, | ||
693 | &start_fsm, | 674 | &start_fsm, |
694 | ret, | 675 | ret, |
695 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 676 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -781,9 +762,6 @@ void GNUNET_TESTING_daemon_stop (struct GNUNET_TESTING_Daemon *d, | |||
781 | d->dead_cb_cls = cb_cls; | 762 | d->dead_cb_cls = cb_cls; |
782 | d->task | 763 | d->task |
783 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 764 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
784 | GNUNET_YES, | ||
785 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
786 | GNUNET_SCHEDULER_NO_TASK, | ||
787 | GNUNET_CONSTANTS_EXEC_WAIT, | 765 | GNUNET_CONSTANTS_EXEC_WAIT, |
788 | &start_fsm, | 766 | &start_fsm, |
789 | d); | 767 | d); |
@@ -879,9 +857,6 @@ void GNUNET_TESTING_daemon_reconfigure (struct GNUNET_TESTING_Daemon *d, | |||
879 | d->update_cb_cls = cb_cls; | 857 | d->update_cb_cls = cb_cls; |
880 | d->task | 858 | d->task |
881 | = GNUNET_SCHEDULER_add_delayed (d->sched, | 859 | = GNUNET_SCHEDULER_add_delayed (d->sched, |
882 | GNUNET_NO, | ||
883 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
884 | GNUNET_SCHEDULER_NO_TASK, | ||
885 | GNUNET_CONSTANTS_EXEC_WAIT, | 860 | GNUNET_CONSTANTS_EXEC_WAIT, |
886 | &start_fsm, | 861 | &start_fsm, |
887 | d); | 862 | d); |
@@ -986,7 +961,6 @@ transmit_ready (void *cls, size_t size, void *buf) | |||
986 | GNUNET_TRANSPORT_disconnect (ctx->d2th); | 961 | GNUNET_TRANSPORT_disconnect (ctx->d2th); |
987 | ctx->d2th = NULL; | 962 | ctx->d2th = NULL; |
988 | GNUNET_SCHEDULER_add_continuation (ctx->d1->sched, | 963 | GNUNET_SCHEDULER_add_continuation (ctx->d1->sched, |
989 | GNUNET_NO, | ||
990 | ¬ify_connect_result, | 964 | ¬ify_connect_result, |
991 | ctx, | 965 | ctx, |
992 | (buf == NULL) ? | 966 | (buf == NULL) ? |
diff --git a/src/topology/gnunet-daemon-topology.c b/src/topology/gnunet-daemon-topology.c index b156ddfaf..cdf3da809 100644 --- a/src/topology/gnunet-daemon-topology.c +++ b/src/topology/gnunet-daemon-topology.c | |||
@@ -523,9 +523,6 @@ schedule_peer_search () | |||
523 | (unsigned long long) delay.value); | 523 | (unsigned long long) delay.value); |
524 | #endif | 524 | #endif |
525 | GNUNET_SCHEDULER_add_delayed (sched, | 525 | GNUNET_SCHEDULER_add_delayed (sched, |
526 | GNUNET_NO, | ||
527 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
528 | GNUNET_SCHEDULER_NO_TASK, | ||
529 | delay, | 526 | delay, |
530 | &find_more_peers, | 527 | &find_more_peers, |
531 | NULL); | 528 | NULL); |
@@ -823,9 +820,6 @@ core_init (void *cls, | |||
823 | #endif | 820 | #endif |
824 | if (autoconnect) | 821 | if (autoconnect) |
825 | GNUNET_SCHEDULER_add_delayed (sched, | 822 | GNUNET_SCHEDULER_add_delayed (sched, |
826 | GNUNET_NO, | ||
827 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
828 | GNUNET_SCHEDULER_NO_TASK, | ||
829 | GNUNET_TIME_UNIT_SECONDS /* give core time to tell us about existing connections */, | 823 | GNUNET_TIME_UNIT_SECONDS /* give core time to tell us about existing connections */, |
830 | &find_more_peers, | 824 | &find_more_peers, |
831 | NULL); | 825 | NULL); |
@@ -1227,9 +1221,6 @@ run (void *cls, | |||
1227 | handlers); | 1221 | handlers); |
1228 | 1222 | ||
1229 | GNUNET_SCHEDULER_add_delayed (sched, | 1223 | GNUNET_SCHEDULER_add_delayed (sched, |
1230 | GNUNET_YES, | ||
1231 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1232 | GNUNET_SCHEDULER_NO_TASK, | ||
1233 | GNUNET_TIME_UNIT_FOREVER_REL, | 1224 | GNUNET_TIME_UNIT_FOREVER_REL, |
1234 | &cleaning_task, NULL); | 1225 | &cleaning_task, NULL); |
1235 | } | 1226 | } |
diff --git a/src/topology/test_gnunet_service_topology.c b/src/topology/test_gnunet_service_topology.c index b2790c0c9..2536f5454 100644 --- a/src/topology/test_gnunet_service_topology.c +++ b/src/topology/test_gnunet_service_topology.c | |||
@@ -26,7 +26,7 @@ | |||
26 | 26 | ||
27 | #define VERBOSE GNUNET_YES | 27 | #define VERBOSE GNUNET_YES |
28 | 28 | ||
29 | #define NUM_PEERS 10 | 29 | #define NUM_PEERS 4 |
30 | 30 | ||
31 | /** | 31 | /** |
32 | * How long until we give up on connecting the peers? | 32 | * How long until we give up on connecting the peers? |
diff --git a/src/transport/gnunet-service-transport.c b/src/transport/gnunet-service-transport.c index 0dc3f859d..efe53e021 100644 --- a/src/transport/gnunet-service-transport.c +++ b/src/transport/gnunet-service-transport.c | |||
@@ -710,9 +710,9 @@ transmit_to_client_callback (void *cls, size_t size, void *buf) | |||
710 | GNUNET_free (q); | 710 | GNUNET_free (q); |
711 | client->message_count--; | 711 | client->message_count--; |
712 | } | 712 | } |
713 | GNUNET_assert (tsize > 0); | ||
714 | if (NULL != q) | 713 | if (NULL != q) |
715 | { | 714 | { |
715 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); | ||
716 | th = GNUNET_SERVER_notify_transmit_ready (client->client, | 716 | th = GNUNET_SERVER_notify_transmit_ready (client->client, |
717 | msize, | 717 | msize, |
718 | GNUNET_TIME_UNIT_FOREVER_REL, | 718 | GNUNET_TIME_UNIT_FOREVER_REL, |
@@ -753,6 +753,7 @@ transmit_to_client (struct TransportClient *client, | |||
753 | } | 753 | } |
754 | client->message_count++; | 754 | client->message_count++; |
755 | msize = ntohs (msg->size); | 755 | msize = ntohs (msg->size); |
756 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); | ||
756 | q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize); | 757 | q = GNUNET_malloc (sizeof (struct ClientMessageQueueEntry) + msize); |
757 | memcpy (&q[1], msg, msize); | 758 | memcpy (&q[1], msg, msize); |
758 | /* append to message queue */ | 759 | /* append to message queue */ |
@@ -1217,9 +1218,6 @@ update_addresses (struct TransportPlugin *plugin, int fresh) | |||
1217 | if (min_remaining.value < GNUNET_TIME_UNIT_FOREVER_REL.value) | 1218 | if (min_remaining.value < GNUNET_TIME_UNIT_FOREVER_REL.value) |
1218 | plugin->address_update_task | 1219 | plugin->address_update_task |
1219 | = GNUNET_SCHEDULER_add_delayed (plugin->env.sched, | 1220 | = GNUNET_SCHEDULER_add_delayed (plugin->env.sched, |
1220 | GNUNET_NO, | ||
1221 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1222 | GNUNET_SCHEDULER_NO_TASK, | ||
1223 | min_remaining, | 1221 | min_remaining, |
1224 | &expire_address_task, plugin); | 1222 | &expire_address_task, plugin); |
1225 | 1223 | ||
@@ -1527,9 +1525,6 @@ cleanup_validation (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1527 | pos = pos->next; | 1525 | pos = pos->next; |
1528 | } | 1526 | } |
1529 | GNUNET_SCHEDULER_add_delayed (sched, | 1527 | GNUNET_SCHEDULER_add_delayed (sched, |
1530 | GNUNET_NO, | ||
1531 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1532 | GNUNET_SCHEDULER_NO_TASK, | ||
1533 | GNUNET_TIME_absolute_get_remaining (first), | 1528 | GNUNET_TIME_absolute_get_remaining (first), |
1534 | &cleanup_validation, NULL); | 1529 | &cleanup_validation, NULL); |
1535 | } | 1530 | } |
@@ -1631,12 +1626,9 @@ plugin_env_notify_validation (void *cls, | |||
1631 | GNUNET_i2s (peer)); | 1626 | GNUNET_i2s (peer)); |
1632 | #endif | 1627 | #endif |
1633 | pos->timeout.value = 0; | 1628 | pos->timeout.value = 0; |
1634 | GNUNET_SCHEDULER_add_delayed (sched, | 1629 | GNUNET_SCHEDULER_add_with_priority (sched, |
1635 | GNUNET_NO, | 1630 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
1636 | GNUNET_SCHEDULER_PRIORITY_IDLE, | 1631 | &cleanup_validation, NULL); |
1637 | GNUNET_SCHEDULER_NO_TASK, | ||
1638 | GNUNET_TIME_UNIT_ZERO, | ||
1639 | &cleanup_validation, NULL); | ||
1640 | } | 1632 | } |
1641 | else | 1633 | else |
1642 | { | 1634 | { |
@@ -1798,9 +1790,6 @@ check_hello_validated (void *cls, | |||
1798 | va = va->next; | 1790 | va = va->next; |
1799 | } | 1791 | } |
1800 | GNUNET_SCHEDULER_add_delayed (sched, | 1792 | GNUNET_SCHEDULER_add_delayed (sched, |
1801 | GNUNET_NO, | ||
1802 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
1803 | GNUNET_SCHEDULER_NO_TASK, | ||
1804 | GNUNET_TIME_absolute_get_remaining (chvc->e->timeout), | 1793 | GNUNET_TIME_absolute_get_remaining (chvc->e->timeout), |
1805 | &cleanup_validation, NULL); | 1794 | &cleanup_validation, NULL); |
1806 | GNUNET_free (chvc); | 1795 | GNUNET_free (chvc); |
@@ -2047,9 +2036,6 @@ setup_new_neighbour (const struct GNUNET_PeerIdentity *peer) | |||
2047 | n->quota_in = (GNUNET_CONSTANTS_DEFAULT_BPM_IN_OUT + 59999) / (60 * 1000); | 2036 | n->quota_in = (GNUNET_CONSTANTS_DEFAULT_BPM_IN_OUT + 59999) / (60 * 1000); |
2048 | add_plugins (n); | 2037 | add_plugins (n); |
2049 | n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched, | 2038 | n->timeout_task = GNUNET_SCHEDULER_add_delayed (sched, |
2050 | GNUNET_NO, | ||
2051 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2052 | GNUNET_SCHEDULER_NO_TASK, | ||
2053 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 2039 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
2054 | &neighbour_timeout_task, n); | 2040 | &neighbour_timeout_task, n); |
2055 | transmit_to_peer (NULL, 0, | 2041 | transmit_to_peer (NULL, 0, |
@@ -2161,9 +2147,7 @@ plugin_env_receive (void *cls, | |||
2161 | n->peer_timeout = | 2147 | n->peer_timeout = |
2162 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); | 2148 | GNUNET_TIME_relative_to_absolute (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT); |
2163 | n->timeout_task = | 2149 | n->timeout_task = |
2164 | GNUNET_SCHEDULER_add_delayed (sched, GNUNET_NO, | 2150 | GNUNET_SCHEDULER_add_delayed (sched, |
2165 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2166 | GNUNET_SCHEDULER_NO_TASK, | ||
2167 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, | 2151 | GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, |
2168 | &neighbour_timeout_task, n); | 2152 | &neighbour_timeout_task, n); |
2169 | update_quota (n); | 2153 | update_quota (n); |
@@ -2698,9 +2682,6 @@ run (void *cls, | |||
2698 | GNUNET_free (plugs); | 2682 | GNUNET_free (plugs); |
2699 | } | 2683 | } |
2700 | GNUNET_SCHEDULER_add_delayed (sched, | 2684 | GNUNET_SCHEDULER_add_delayed (sched, |
2701 | GNUNET_YES, | ||
2702 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
2703 | GNUNET_SCHEDULER_NO_TASK, | ||
2704 | GNUNET_TIME_UNIT_FOREVER_REL, | 2685 | GNUNET_TIME_UNIT_FOREVER_REL, |
2705 | &unload_plugins, NULL); | 2686 | &unload_plugins, NULL); |
2706 | if (no_transports) | 2687 | if (no_transports) |
@@ -2728,7 +2709,7 @@ main (int argc, char *const *argv) | |||
2728 | GNUNET_SERVICE_run (argc, | 2709 | GNUNET_SERVICE_run (argc, |
2729 | argv, | 2710 | argv, |
2730 | "transport", | 2711 | "transport", |
2731 | &run, NULL, NULL, NULL)) ? 0 : 1; | 2712 | &run, NULL)) ? 0 : 1; |
2732 | } | 2713 | } |
2733 | 2714 | ||
2734 | /* end of gnunet-service-transport.c */ | 2715 | /* end of gnunet-service-transport.c */ |
diff --git a/src/transport/plugin_transport_tcp.c b/src/transport/plugin_transport_tcp.c index eeb333a53..a391b1b42 100644 --- a/src/transport/plugin_transport_tcp.c +++ b/src/transport/plugin_transport_tcp.c | |||
@@ -1898,9 +1898,6 @@ handle_tcp_data (void *cls, | |||
1898 | GNUNET_SERVER_receive_done (client, GNUNET_OK); | 1898 | GNUNET_SERVER_receive_done (client, GNUNET_OK); |
1899 | else | 1899 | else |
1900 | GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched, | 1900 | GNUNET_SCHEDULER_add_delayed (session->plugin->env->sched, |
1901 | GNUNET_NO, | ||
1902 | GNUNET_SCHEDULER_PRIORITY_HIGH, | ||
1903 | GNUNET_SCHEDULER_NO_TASK, | ||
1904 | delay, &delayed_done, session); | 1901 | delay, &delayed_done, session); |
1905 | } | 1902 | } |
1906 | 1903 | ||
diff --git a/src/transport/test_plugin_transport.c b/src/transport/test_plugin_transport.c index ec1b6b76c..856cadeaf 100644 --- a/src/transport/test_plugin_transport.c +++ b/src/transport/test_plugin_transport.c | |||
@@ -179,7 +179,6 @@ validation_notification (void *cls, | |||
179 | here will end the process. */ | 179 | here will end the process. */ |
180 | ok = 0; /* if the last test succeeded, report success */ | 180 | ok = 0; /* if the last test succeeded, report success */ |
181 | GNUNET_SCHEDULER_add_continuation (sched, | 181 | GNUNET_SCHEDULER_add_continuation (sched, |
182 | GNUNET_NO, | ||
183 | &unload_task, | 182 | &unload_task, |
184 | (void*) cfg, | 183 | (void*) cfg, |
185 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 184 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -236,9 +235,6 @@ test_validation () | |||
236 | /* add job to catch failure (timeout) */ | 235 | /* add job to catch failure (timeout) */ |
237 | validation_timeout_task = | 236 | validation_timeout_task = |
238 | GNUNET_SCHEDULER_add_delayed (sched, | 237 | GNUNET_SCHEDULER_add_delayed (sched, |
239 | GNUNET_NO, | ||
240 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
241 | GNUNET_SCHEDULER_NO_TASK, | ||
242 | TIMEOUT, | 238 | TIMEOUT, |
243 | &validation_failed, | 239 | &validation_failed, |
244 | NULL); | 240 | NULL); |
diff --git a/src/transport/transport_api.c b/src/transport/transport_api.c index 122950a74..c98194da0 100644 --- a/src/transport/transport_api.c +++ b/src/transport/transport_api.c | |||
@@ -625,9 +625,6 @@ schedule_control_transmit (struct GNUNET_TRANSPORT_Handle *h, | |||
625 | th->notify_size = size; | 625 | th->notify_size = size; |
626 | th->notify_delay_task | 626 | th->notify_delay_task |
627 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 627 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
628 | GNUNET_NO, | ||
629 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
630 | GNUNET_SCHEDULER_NO_TASK, | ||
631 | timeout, | 628 | timeout, |
632 | &peer_transmit_timeout, th); | 629 | &peer_transmit_timeout, th); |
633 | if (at_head) | 630 | if (at_head) |
@@ -704,7 +701,6 @@ send_set_quota (void *cls, size_t size, void *buf) | |||
704 | if (buf == NULL) | 701 | if (buf == NULL) |
705 | { | 702 | { |
706 | GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, | 703 | GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, |
707 | GNUNET_NO, | ||
708 | sqc->cont, | 704 | sqc->cont, |
709 | sqc->cont_cls, | 705 | sqc->cont_cls, |
710 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 706 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
@@ -724,7 +720,6 @@ send_set_quota (void *cls, size_t size, void *buf) | |||
724 | memcpy (&msg->peer, &sqc->target, sizeof (struct GNUNET_PeerIdentity)); | 720 | memcpy (&msg->peer, &sqc->target, sizeof (struct GNUNET_PeerIdentity)); |
725 | if (sqc->cont != NULL) | 721 | if (sqc->cont != NULL) |
726 | GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, | 722 | GNUNET_SCHEDULER_add_continuation (sqc->handle->sched, |
727 | GNUNET_NO, | ||
728 | sqc->cont, | 723 | sqc->cont, |
729 | sqc->cont_cls, | 724 | sqc->cont_cls, |
730 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 725 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -802,9 +797,6 @@ hello_wait_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
802 | GNUNET_TIME_absolute_get_remaining (hwl->timeout).value); | 797 | GNUNET_TIME_absolute_get_remaining (hwl->timeout).value); |
803 | #endif | 798 | #endif |
804 | hwl->task = GNUNET_SCHEDULER_add_delayed (hwl->handle->sched, | 799 | hwl->task = GNUNET_SCHEDULER_add_delayed (hwl->handle->sched, |
805 | GNUNET_YES, | ||
806 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
807 | GNUNET_SCHEDULER_NO_TASK, | ||
808 | GNUNET_TIME_absolute_get_remaining (hwl->timeout), | 800 | GNUNET_TIME_absolute_get_remaining (hwl->timeout), |
809 | &hello_wait_timeout, hwl); | 801 | &hello_wait_timeout, hwl); |
810 | return; | 802 | return; |
@@ -862,9 +854,6 @@ GNUNET_TRANSPORT_get_hello (struct GNUNET_TRANSPORT_Handle *handle, | |||
862 | hwl->rec_cls = rec_cls; | 854 | hwl->rec_cls = rec_cls; |
863 | hwl->timeout = GNUNET_TIME_relative_to_absolute (timeout); | 855 | hwl->timeout = GNUNET_TIME_relative_to_absolute (timeout); |
864 | hwl->task = GNUNET_SCHEDULER_add_delayed (handle->sched, | 856 | hwl->task = GNUNET_SCHEDULER_add_delayed (handle->sched, |
865 | GNUNET_YES, | ||
866 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
867 | GNUNET_SCHEDULER_NO_TASK, | ||
868 | timeout, | 857 | timeout, |
869 | &hello_wait_timeout, hwl); | 858 | &hello_wait_timeout, hwl); |
870 | return; | 859 | return; |
@@ -1018,9 +1007,6 @@ request_connect (void *cls, size_t size, void *buf) | |||
1018 | memcpy (&tcm->peer, &th->target, sizeof (struct GNUNET_PeerIdentity)); | 1007 | memcpy (&tcm->peer, &th->target, sizeof (struct GNUNET_PeerIdentity)); |
1019 | th->notify_delay_task | 1008 | th->notify_delay_task |
1020 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1009 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1021 | GNUNET_NO, | ||
1022 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1023 | GNUNET_SCHEDULER_NO_TASK, | ||
1024 | GNUNET_TIME_absolute_get_remaining | 1010 | GNUNET_TIME_absolute_get_remaining |
1025 | (th->timeout), | 1011 | (th->timeout), |
1026 | &peer_transmit_timeout, th); | 1012 | &peer_transmit_timeout, th); |
@@ -1128,9 +1114,6 @@ remove_neighbour (struct GNUNET_TRANSPORT_Handle *h, | |||
1128 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->notify_delay_task); | 1114 | GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == th->notify_delay_task); |
1129 | th->notify_delay_task | 1115 | th->notify_delay_task |
1130 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1116 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1131 | GNUNET_NO, | ||
1132 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1133 | GNUNET_SCHEDULER_NO_TASK, | ||
1134 | CONNECT_RETRY_TIMEOUT, | 1117 | CONNECT_RETRY_TIMEOUT, |
1135 | &try_connect_task, | 1118 | &try_connect_task, |
1136 | th); | 1119 | th); |
@@ -1214,9 +1197,6 @@ schedule_reconnect (struct GNUNET_TRANSPORT_Handle *h) | |||
1214 | GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK); | 1197 | GNUNET_assert (h->reconnect_task == GNUNET_SCHEDULER_NO_TASK); |
1215 | h->reconnect_task | 1198 | h->reconnect_task |
1216 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1199 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1217 | GNUNET_NO, | ||
1218 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
1219 | GNUNET_SCHEDULER_NO_TASK, | ||
1220 | h->reconnect_delay, &reconnect, h); | 1200 | h->reconnect_delay, &reconnect, h); |
1221 | h->reconnect_delay = GNUNET_TIME_UNIT_SECONDS; | 1201 | h->reconnect_delay = GNUNET_TIME_UNIT_SECONDS; |
1222 | } | 1202 | } |
@@ -1318,9 +1298,6 @@ schedule_request (struct GNUNET_TRANSPORT_TransmitHandle *th) | |||
1318 | #endif | 1298 | #endif |
1319 | th->notify_delay_task | 1299 | th->notify_delay_task |
1320 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1300 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1321 | GNUNET_NO, | ||
1322 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1323 | GNUNET_SCHEDULER_NO_TASK, | ||
1324 | duration, &transmit_ready, th); | 1301 | duration, &transmit_ready, th); |
1325 | return; | 1302 | return; |
1326 | } | 1303 | } |
@@ -1340,9 +1317,6 @@ schedule_request (struct GNUNET_TRANSPORT_TransmitHandle *th) | |||
1340 | #endif | 1317 | #endif |
1341 | th->notify_delay_task | 1318 | th->notify_delay_task |
1342 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1319 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1343 | GNUNET_NO, | ||
1344 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1345 | GNUNET_SCHEDULER_NO_TASK, | ||
1346 | GNUNET_TIME_absolute_get_remaining | 1320 | GNUNET_TIME_absolute_get_remaining |
1347 | (th->timeout), &peer_transmit_timeout, th); | 1321 | (th->timeout), &peer_transmit_timeout, th); |
1348 | return; | 1322 | return; |
@@ -1593,9 +1567,6 @@ demultiplexer (void *cls, const struct GNUNET_MessageHeader *msg) | |||
1593 | GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK); | 1567 | GNUNET_assert (th->notify_delay_task == GNUNET_SCHEDULER_NO_TASK); |
1594 | th->notify_delay_task | 1568 | th->notify_delay_task |
1595 | = GNUNET_SCHEDULER_add_delayed (h->sched, | 1569 | = GNUNET_SCHEDULER_add_delayed (h->sched, |
1596 | GNUNET_NO, | ||
1597 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1598 | GNUNET_SCHEDULER_NO_TASK, | ||
1599 | GNUNET_TIME_absolute_get_remaining(th->timeout), | 1570 | GNUNET_TIME_absolute_get_remaining(th->timeout), |
1600 | &peer_transmit_timeout, | 1571 | &peer_transmit_timeout, |
1601 | th); | 1572 | th); |
@@ -1937,9 +1908,6 @@ GNUNET_TRANSPORT_notify_transmit_ready (struct GNUNET_TRANSPORT_Handle | |||
1937 | #endif | 1908 | #endif |
1938 | th->notify_delay_task | 1909 | th->notify_delay_task |
1939 | = GNUNET_SCHEDULER_add_delayed (handle->sched, | 1910 | = GNUNET_SCHEDULER_add_delayed (handle->sched, |
1940 | GNUNET_NO, | ||
1941 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1942 | GNUNET_SCHEDULER_NO_TASK, | ||
1943 | timeout, &peer_transmit_timeout, th); | 1911 | timeout, &peer_transmit_timeout, th); |
1944 | return th; | 1912 | return th; |
1945 | } | 1913 | } |
diff --git a/src/util/client.c b/src/util/client.c index 60aa6f101..05f579b9f 100644 --- a/src/util/client.c +++ b/src/util/client.c | |||
@@ -308,8 +308,6 @@ GNUNET_CLIENT_disconnect (struct GNUNET_CLIENT_Connection *sock) | |||
308 | sock->in_receive = GNUNET_SYSERR; | 308 | sock->in_receive = GNUNET_SYSERR; |
309 | else | 309 | else |
310 | GNUNET_SCHEDULER_add_after (sock->sched, | 310 | GNUNET_SCHEDULER_add_after (sock->sched, |
311 | GNUNET_YES, | ||
312 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
313 | GNUNET_SCHEDULER_NO_TASK, | 311 | GNUNET_SCHEDULER_NO_TASK, |
314 | &finish_cleanup, sock); | 312 | &finish_cleanup, sock); |
315 | } | 313 | } |
@@ -353,8 +351,6 @@ receive_helper (void *cls, | |||
353 | GNUNET_assert (conn->msg_complete == GNUNET_NO); | 351 | GNUNET_assert (conn->msg_complete == GNUNET_NO); |
354 | if (GNUNET_SYSERR == conn->in_receive) | 352 | if (GNUNET_SYSERR == conn->in_receive) |
355 | GNUNET_SCHEDULER_add_after (conn->sched, | 353 | GNUNET_SCHEDULER_add_after (conn->sched, |
356 | GNUNET_YES, | ||
357 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
358 | GNUNET_SCHEDULER_NO_TASK, | 354 | GNUNET_SCHEDULER_NO_TASK, |
359 | &finish_cleanup, conn); | 355 | &finish_cleanup, conn); |
360 | conn->in_receive = GNUNET_NO; | 356 | conn->in_receive = GNUNET_NO; |
@@ -412,8 +408,6 @@ receive_task (void *scls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
412 | 408 | ||
413 | if (GNUNET_SYSERR == sock->in_receive) | 409 | if (GNUNET_SYSERR == sock->in_receive) |
414 | GNUNET_SCHEDULER_add_after (sock->sched, | 410 | GNUNET_SCHEDULER_add_after (sock->sched, |
415 | GNUNET_YES, | ||
416 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
417 | GNUNET_SCHEDULER_NO_TASK, | 411 | GNUNET_SCHEDULER_NO_TASK, |
418 | &finish_cleanup, sock); | 412 | &finish_cleanup, sock); |
419 | sock->in_receive = GNUNET_NO; | 413 | sock->in_receive = GNUNET_NO; |
@@ -457,8 +451,6 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock, | |||
457 | sock->in_receive = GNUNET_YES; | 451 | sock->in_receive = GNUNET_YES; |
458 | if (GNUNET_YES == sock->msg_complete) | 452 | if (GNUNET_YES == sock->msg_complete) |
459 | GNUNET_SCHEDULER_add_after (sock->sched, | 453 | GNUNET_SCHEDULER_add_after (sock->sched, |
460 | GNUNET_YES, | ||
461 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
462 | GNUNET_SCHEDULER_NO_TASK, | 454 | GNUNET_SCHEDULER_NO_TASK, |
463 | &receive_task, sock); | 455 | &receive_task, sock); |
464 | else | 456 | else |
@@ -522,7 +514,6 @@ service_test_error (struct GNUNET_SCHEDULER_Handle *s, | |||
522 | GNUNET_SCHEDULER_Task task, void *task_cls) | 514 | GNUNET_SCHEDULER_Task task, void *task_cls) |
523 | { | 515 | { |
524 | GNUNET_SCHEDULER_add_continuation (s, | 516 | GNUNET_SCHEDULER_add_continuation (s, |
525 | GNUNET_YES, | ||
526 | task, | 517 | task, |
527 | task_cls, | 518 | task_cls, |
528 | GNUNET_SCHEDULER_REASON_TIMEOUT); | 519 | GNUNET_SCHEDULER_REASON_TIMEOUT); |
@@ -549,7 +540,6 @@ confirm_handler (void *cls, const struct GNUNET_MessageHeader *msg) | |||
549 | "Received confirmation that service is running.\n"); | 540 | "Received confirmation that service is running.\n"); |
550 | #endif | 541 | #endif |
551 | GNUNET_SCHEDULER_add_continuation (conn->sched, | 542 | GNUNET_SCHEDULER_add_continuation (conn->sched, |
552 | GNUNET_YES, | ||
553 | conn->test_cb, | 543 | conn->test_cb, |
554 | conn->test_cb_cls, | 544 | conn->test_cb_cls, |
555 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 545 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -719,9 +709,6 @@ client_notify (void *cls, size_t size, void *buf) | |||
719 | GNUNET_assert (NULL != th->sock->sock); | 709 | GNUNET_assert (NULL != th->sock->sock); |
720 | delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS); | 710 | delay = GNUNET_TIME_relative_min (delay, GNUNET_TIME_UNIT_SECONDS); |
721 | th->task = GNUNET_SCHEDULER_add_delayed (th->sock->sched, | 711 | th->task = GNUNET_SCHEDULER_add_delayed (th->sock->sched, |
722 | GNUNET_NO, | ||
723 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
724 | GNUNET_SCHEDULER_NO_TASK, | ||
725 | delay, | 712 | delay, |
726 | &client_delayed_retry, th); | 713 | &client_delayed_retry, th); |
727 | th->sock->th = th; | 714 | th->sock->th = th; |
diff --git a/src/util/connection.c b/src/util/connection.c index 066b81bbe..9bf2aa975 100644 --- a/src/util/connection.c +++ b/src/util/connection.c | |||
@@ -476,8 +476,6 @@ destroy_continuation (void *cls, | |||
476 | "Destroy waits for write_task to be done (%p)\n", sock); | 476 | "Destroy waits for write_task to be done (%p)\n", sock); |
477 | #endif | 477 | #endif |
478 | GNUNET_SCHEDULER_add_after (sock->sched, | 478 | GNUNET_SCHEDULER_add_after (sock->sched, |
479 | GNUNET_YES, | ||
480 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
481 | sock->write_task, | 479 | sock->write_task, |
482 | &destroy_continuation, sock); | 480 | &destroy_continuation, sock); |
483 | return; | 481 | return; |
@@ -498,8 +496,6 @@ destroy_continuation (void *cls, | |||
498 | if (sock->read_task != GNUNET_SCHEDULER_NO_TASK) | 496 | if (sock->read_task != GNUNET_SCHEDULER_NO_TASK) |
499 | { | 497 | { |
500 | GNUNET_SCHEDULER_add_after (sock->sched, | 498 | GNUNET_SCHEDULER_add_after (sock->sched, |
501 | GNUNET_YES, | ||
502 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
503 | sock->read_task, | 499 | sock->read_task, |
504 | &destroy_continuation, sock); | 500 | &destroy_continuation, sock); |
505 | return; | 501 | return; |
@@ -569,8 +565,6 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
569 | #endif | 565 | #endif |
570 | h->ccs -= COCO_RECEIVE_AGAIN; | 566 | h->ccs -= COCO_RECEIVE_AGAIN; |
571 | h->read_task = GNUNET_SCHEDULER_add_after (h->sched, | 567 | h->read_task = GNUNET_SCHEDULER_add_after (h->sched, |
572 | GNUNET_NO, | ||
573 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
574 | GNUNET_SCHEDULER_NO_TASK, | 568 | GNUNET_SCHEDULER_NO_TASK, |
575 | &receive_again, h); | 569 | &receive_again, h); |
576 | } | 570 | } |
@@ -586,8 +580,6 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
586 | h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK; | 580 | h->nth.timeout_task = GNUNET_SCHEDULER_NO_TASK; |
587 | h->ccs -= COCO_TRANSMIT_READY; | 581 | h->ccs -= COCO_TRANSMIT_READY; |
588 | h->write_task = GNUNET_SCHEDULER_add_after (h->sched, | 582 | h->write_task = GNUNET_SCHEDULER_add_after (h->sched, |
589 | GNUNET_NO, | ||
590 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
591 | GNUNET_SCHEDULER_NO_TASK, | 583 | GNUNET_SCHEDULER_NO_TASK, |
592 | &transmit_ready, h); | 584 | &transmit_ready, h); |
593 | } | 585 | } |
@@ -600,7 +592,6 @@ connect_fail_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
600 | #endif | 592 | #endif |
601 | h->ccs -= COCO_DESTROY_CONTINUATION; | 593 | h->ccs -= COCO_DESTROY_CONTINUATION; |
602 | GNUNET_SCHEDULER_add_continuation (h->sched, | 594 | GNUNET_SCHEDULER_add_continuation (h->sched, |
603 | GNUNET_NO, | ||
604 | &destroy_continuation, | 595 | &destroy_continuation, |
605 | h, GNUNET_SCHEDULER_REASON_TIMEOUT); | 596 | h, GNUNET_SCHEDULER_REASON_TIMEOUT); |
606 | } | 597 | } |
@@ -630,8 +621,6 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
630 | #endif | 621 | #endif |
631 | h->ccs -= COCO_RECEIVE_AGAIN; | 622 | h->ccs -= COCO_RECEIVE_AGAIN; |
632 | h->read_task = GNUNET_SCHEDULER_add_after (h->sched, | 623 | h->read_task = GNUNET_SCHEDULER_add_after (h->sched, |
633 | GNUNET_NO, | ||
634 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
635 | GNUNET_SCHEDULER_NO_TASK, | 624 | GNUNET_SCHEDULER_NO_TASK, |
636 | &receive_again, h); | 625 | &receive_again, h); |
637 | } | 626 | } |
@@ -648,9 +637,6 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
648 | h->ccs -= COCO_TRANSMIT_READY; | 637 | h->ccs -= COCO_TRANSMIT_READY; |
649 | h->write_task = | 638 | h->write_task = |
650 | GNUNET_SCHEDULER_add_write_net (h->sched, | 639 | GNUNET_SCHEDULER_add_write_net (h->sched, |
651 | GNUNET_NO, | ||
652 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
653 | GNUNET_SCHEDULER_NO_TASK, | ||
654 | GNUNET_TIME_absolute_get_remaining | 640 | GNUNET_TIME_absolute_get_remaining |
655 | (h->nth.transmit_timeout), h->sock, | 641 | (h->nth.transmit_timeout), h->sock, |
656 | &transmit_ready, h); | 642 | &transmit_ready, h); |
@@ -664,7 +650,6 @@ connect_success_continuation (struct GNUNET_CONNECTION_Handle *h) | |||
664 | #endif | 650 | #endif |
665 | h->ccs -= COCO_DESTROY_CONTINUATION; | 651 | h->ccs -= COCO_DESTROY_CONTINUATION; |
666 | GNUNET_SCHEDULER_add_continuation (h->sched, | 652 | GNUNET_SCHEDULER_add_continuation (h->sched, |
667 | GNUNET_NO, | ||
668 | &destroy_continuation, | 653 | &destroy_continuation, |
669 | h, | 654 | h, |
670 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 655 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -808,9 +793,8 @@ try_connect_using_address (void *cls, | |||
808 | GNUNET_TIME_absolute_get_remaining (h-> | 793 | GNUNET_TIME_absolute_get_remaining (h-> |
809 | receive_timeout)); | 794 | receive_timeout)); |
810 | ap->task = | 795 | ap->task = |
811 | GNUNET_SCHEDULER_add_write_net (h->sched, GNUNET_NO, | 796 | GNUNET_SCHEDULER_add_write_net (h->sched, |
812 | GNUNET_SCHEDULER_PRIORITY_KEEP, | 797 | delay, ap->sock, |
813 | GNUNET_SCHEDULER_NO_TASK, delay, ap->sock, | ||
814 | &connect_probe_continuation, ap); | 798 | &connect_probe_continuation, ap); |
815 | } | 799 | } |
816 | 800 | ||
@@ -956,8 +940,6 @@ GNUNET_CONNECTION_destroy (struct GNUNET_CONNECTION_Handle *sock) | |||
956 | } | 940 | } |
957 | GNUNET_assert (sock->sched != NULL); | 941 | GNUNET_assert (sock->sched != NULL); |
958 | GNUNET_SCHEDULER_add_after (sock->sched, | 942 | GNUNET_SCHEDULER_add_after (sock->sched, |
959 | GNUNET_YES, | ||
960 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
961 | GNUNET_SCHEDULER_NO_TASK, | 943 | GNUNET_SCHEDULER_NO_TASK, |
962 | &destroy_continuation, sock); | 944 | &destroy_continuation, sock); |
963 | } | 945 | } |
@@ -1101,9 +1083,6 @@ receive_again (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1101 | GNUNET_assert (sh->sock != NULL); | 1083 | GNUNET_assert (sh->sock != NULL); |
1102 | /* connect succeeded, wait for data! */ | 1084 | /* connect succeeded, wait for data! */ |
1103 | sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched, | 1085 | sh->read_task = GNUNET_SCHEDULER_add_read_net (tc->sched, |
1104 | GNUNET_YES, | ||
1105 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1106 | GNUNET_SCHEDULER_NO_TASK, | ||
1107 | GNUNET_TIME_absolute_get_remaining | 1086 | GNUNET_TIME_absolute_get_remaining |
1108 | (sh->receive_timeout), | 1087 | (sh->receive_timeout), |
1109 | sh->sock, | 1088 | sh->sock, |
@@ -1406,9 +1385,6 @@ SCHEDULE_WRITE: | |||
1406 | if (sock->write_task == GNUNET_SCHEDULER_NO_TASK) | 1385 | if (sock->write_task == GNUNET_SCHEDULER_NO_TASK) |
1407 | sock->write_task = | 1386 | sock->write_task = |
1408 | GNUNET_SCHEDULER_add_write_net (tc->sched, | 1387 | GNUNET_SCHEDULER_add_write_net (tc->sched, |
1409 | GNUNET_NO, | ||
1410 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1411 | GNUNET_SCHEDULER_NO_TASK, | ||
1412 | GNUNET_TIME_absolute_get_remaining | 1388 | GNUNET_TIME_absolute_get_remaining |
1413 | (sock->nth.transmit_timeout), | 1389 | (sock->nth.transmit_timeout), |
1414 | sock->sock, &transmit_ready, sock); | 1390 | sock->sock, &transmit_ready, sock); |
@@ -1453,9 +1429,6 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle | |||
1453 | (sock->ap_head == NULL) && (sock->dns_active == NULL)) | 1429 | (sock->ap_head == NULL) && (sock->dns_active == NULL)) |
1454 | { | 1430 | { |
1455 | sock->write_task = GNUNET_SCHEDULER_add_delayed (sock->sched, | 1431 | sock->write_task = GNUNET_SCHEDULER_add_delayed (sock->sched, |
1456 | GNUNET_NO, | ||
1457 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1458 | GNUNET_SCHEDULER_NO_TASK, | ||
1459 | GNUNET_TIME_UNIT_ZERO, | 1432 | GNUNET_TIME_UNIT_ZERO, |
1460 | &connect_error, sock); | 1433 | &connect_error, sock); |
1461 | return &sock->nth; | 1434 | return &sock->nth; |
@@ -1469,9 +1442,6 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle | |||
1469 | "Scheduling transmit_ready (%p).\n", sock); | 1442 | "Scheduling transmit_ready (%p).\n", sock); |
1470 | #endif | 1443 | #endif |
1471 | sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched, | 1444 | sock->write_task = GNUNET_SCHEDULER_add_write_net (sock->sched, |
1472 | GNUNET_NO, | ||
1473 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1474 | GNUNET_SCHEDULER_NO_TASK, | ||
1475 | GNUNET_TIME_absolute_get_remaining | 1445 | GNUNET_TIME_absolute_get_remaining |
1476 | (sock->nth. | 1446 | (sock->nth. |
1477 | transmit_timeout), | 1447 | transmit_timeout), |
@@ -1488,9 +1458,6 @@ GNUNET_CONNECTION_notify_transmit_ready (struct GNUNET_CONNECTION_Handle | |||
1488 | #endif | 1458 | #endif |
1489 | sock->ccs |= COCO_TRANSMIT_READY; | 1459 | sock->ccs |= COCO_TRANSMIT_READY; |
1490 | sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched, | 1460 | sock->nth.timeout_task = GNUNET_SCHEDULER_add_delayed (sock->sched, |
1491 | GNUNET_NO, | ||
1492 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
1493 | GNUNET_SCHEDULER_NO_TASK, | ||
1494 | timeout, | 1461 | timeout, |
1495 | &transmit_timeout, | 1462 | &transmit_timeout, |
1496 | sock); | 1463 | sock); |
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c index 3f5869489..dcee545f7 100644 --- a/src/util/crypto_hash.c +++ b/src/util/crypto_hash.c | |||
@@ -416,11 +416,6 @@ struct FileHashContext | |||
416 | uint64_t offset; | 416 | uint64_t offset; |
417 | 417 | ||
418 | /** | 418 | /** |
419 | * Run on shutdown? | ||
420 | */ | ||
421 | int run_on_shutdown; | ||
422 | |||
423 | /** | ||
424 | * File descriptor. | 419 | * File descriptor. |
425 | */ | 420 | */ |
426 | struct GNUNET_DISK_FileHandle *fh; | 421 | struct GNUNET_DISK_FileHandle *fh; |
@@ -476,8 +471,6 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
476 | return; | 471 | return; |
477 | } | 472 | } |
478 | GNUNET_SCHEDULER_add_after (tc->sched, | 473 | GNUNET_SCHEDULER_add_after (tc->sched, |
479 | fhc->run_on_shutdown, | ||
480 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
481 | GNUNET_SCHEDULER_NO_TASK, &file_hash_task, fhc); | 474 | GNUNET_SCHEDULER_NO_TASK, &file_hash_task, fhc); |
482 | } | 475 | } |
483 | 476 | ||
@@ -487,7 +480,6 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
487 | * | 480 | * |
488 | * @param sched scheduler to use | 481 | * @param sched scheduler to use |
489 | * @param priority scheduling priority to use | 482 | * @param priority scheduling priority to use |
490 | * @param run_on_shutdown should we complete even on shutdown? | ||
491 | * @param filename name of file to hash | 483 | * @param filename name of file to hash |
492 | * @param blocksize number of bytes to process in one task | 484 | * @param blocksize number of bytes to process in one task |
493 | * @param callback function to call upon completion | 485 | * @param callback function to call upon completion |
@@ -496,7 +488,6 @@ file_hash_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
496 | void | 488 | void |
497 | GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, | 489 | GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, |
498 | enum GNUNET_SCHEDULER_Priority priority, | 490 | enum GNUNET_SCHEDULER_Priority priority, |
499 | int run_on_shutdown, | ||
500 | const char *filename, | 491 | const char *filename, |
501 | size_t blocksize, | 492 | size_t blocksize, |
502 | GNUNET_CRYPTO_HashCompletedCallback callback, | 493 | GNUNET_CRYPTO_HashCompletedCallback callback, |
@@ -518,7 +509,6 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
518 | file_hash_finish (fhc, NULL); | 509 | file_hash_finish (fhc, NULL); |
519 | return; | 510 | return; |
520 | } | 511 | } |
521 | fhc->run_on_shutdown = run_on_shutdown; | ||
522 | fhc->fh = GNUNET_DISK_file_open (filename, | 512 | fhc->fh = GNUNET_DISK_file_open (filename, |
523 | GNUNET_DISK_OPEN_READ, | 513 | GNUNET_DISK_OPEN_READ, |
524 | GNUNET_DISK_PERM_NONE); | 514 | GNUNET_DISK_PERM_NONE); |
@@ -527,10 +517,7 @@ GNUNET_CRYPTO_hash_file (struct GNUNET_SCHEDULER_Handle *sched, | |||
527 | file_hash_finish (fhc, NULL); | 517 | file_hash_finish (fhc, NULL); |
528 | return; | 518 | return; |
529 | } | 519 | } |
530 | GNUNET_SCHEDULER_add_after (sched, | 520 | GNUNET_SCHEDULER_add_with_priority (sched, priority, &file_hash_task, fhc); |
531 | run_on_shutdown, | ||
532 | priority, | ||
533 | GNUNET_SCHEDULER_NO_TASK, &file_hash_task, fhc); | ||
534 | } | 521 | } |
535 | 522 | ||
536 | 523 | ||
diff --git a/src/util/disk.c b/src/util/disk.c index 9f93a1ee2..3b3cb9e65 100644 --- a/src/util/disk.c +++ b/src/util/disk.c | |||
@@ -856,11 +856,9 @@ GNUNET_DISK_directory_iterator_next (struct GNUNET_DISK_DirectoryIterator | |||
856 | GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES); | 856 | GNUNET_DISK_directory_iterator_next (iter, GNUNET_YES); |
857 | return GNUNET_NO; | 857 | return GNUNET_NO; |
858 | } | 858 | } |
859 | GNUNET_SCHEDULER_add_after (iter->sched, | 859 | GNUNET_SCHEDULER_add_with_priority (iter->sched, |
860 | GNUNET_YES, | 860 | iter->priority, |
861 | iter->priority, | 861 | &directory_iterator_task, iter); |
862 | GNUNET_SCHEDULER_NO_TASK, | ||
863 | &directory_iterator_task, iter); | ||
864 | return GNUNET_YES; | 862 | return GNUNET_YES; |
865 | } | 863 | } |
866 | 864 | ||
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c index f8dd2e166..4dcabface 100644 --- a/src/util/gnunet-service-resolver.c +++ b/src/util/gnunet-service-resolver.c | |||
@@ -516,7 +516,7 @@ main (int argc, char *const *argv) | |||
516 | ret = (GNUNET_OK == | 516 | ret = (GNUNET_OK == |
517 | GNUNET_SERVICE_run (argc, | 517 | GNUNET_SERVICE_run (argc, |
518 | argv, | 518 | argv, |
519 | "resolver", &run, NULL, NULL, NULL)) ? 0 : 1; | 519 | "resolver", &run, NULL)) ? 0 : 1; |
520 | 520 | ||
521 | while (head != NULL) | 521 | while (head != NULL) |
522 | { | 522 | { |
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c index 69d143bc1..812cdc84e 100644 --- a/src/util/resolver_api.c +++ b/src/util/resolver_api.c | |||
@@ -442,9 +442,6 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched, | |||
442 | ((domain == AF_INET6) || (domain == AF_UNSPEC)))) | 442 | ((domain == AF_INET6) || (domain == AF_UNSPEC)))) |
443 | { | 443 | { |
444 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, | 444 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, |
445 | GNUNET_NO, | ||
446 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
447 | GNUNET_SCHEDULER_NO_TASK, | ||
448 | GNUNET_TIME_UNIT_ZERO, | 445 | GNUNET_TIME_UNIT_ZERO, |
449 | &numeric_resolution, rh); | 446 | &numeric_resolution, rh); |
450 | return rh; | 447 | return rh; |
@@ -455,9 +452,6 @@ GNUNET_RESOLVER_ip_get (struct GNUNET_SCHEDULER_Handle *sched, | |||
455 | if (0 == strcasecmp (loopback[i++], hostname)) | 452 | if (0 == strcasecmp (loopback[i++], hostname)) |
456 | { | 453 | { |
457 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, | 454 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, |
458 | GNUNET_NO, | ||
459 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
460 | GNUNET_SCHEDULER_NO_TASK, | ||
461 | GNUNET_TIME_UNIT_ZERO, | 455 | GNUNET_TIME_UNIT_ZERO, |
462 | &loopback_resolution, rh); | 456 | &loopback_resolution, rh); |
463 | return rh; | 457 | return rh; |
@@ -623,9 +617,6 @@ GNUNET_RESOLVER_hostname_get (struct GNUNET_SCHEDULER_Handle *sched, | |||
623 | if (GNUNET_NO == do_resolve) | 617 | if (GNUNET_NO == do_resolve) |
624 | { | 618 | { |
625 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, | 619 | rh->task = GNUNET_SCHEDULER_add_delayed (sched, |
626 | GNUNET_NO, | ||
627 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
628 | GNUNET_SCHEDULER_NO_TASK, | ||
629 | GNUNET_TIME_UNIT_ZERO, | 620 | GNUNET_TIME_UNIT_ZERO, |
630 | &numeric_reverse, rh); | 621 | &numeric_reverse, rh); |
631 | return rh; | 622 | return rh; |
diff --git a/src/util/scheduler.c b/src/util/scheduler.c index 2bb356eb6..16f65b457 100644 --- a/src/util/scheduler.c +++ b/src/util/scheduler.c | |||
@@ -95,11 +95,6 @@ struct Task | |||
95 | */ | 95 | */ |
96 | enum GNUNET_SCHEDULER_Priority priority; | 96 | enum GNUNET_SCHEDULER_Priority priority; |
97 | 97 | ||
98 | /** | ||
99 | * Should this task be run on shutdown? | ||
100 | */ | ||
101 | int run_on_shutdown; | ||
102 | |||
103 | }; | 98 | }; |
104 | 99 | ||
105 | 100 | ||
@@ -135,12 +130,6 @@ struct GNUNET_SCHEDULER_Handle | |||
135 | GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id; | 130 | GNUNET_SCHEDULER_TaskIdentifier lowest_pending_id; |
136 | 131 | ||
137 | /** | 132 | /** |
138 | * GNUNET_NO if we are running normally, | ||
139 | * GNUNET_YES if we are in shutdown mode. | ||
140 | */ | ||
141 | int shutdown; | ||
142 | |||
143 | /** | ||
144 | * Number of tasks on the ready list. | 133 | * Number of tasks on the ready list. |
145 | */ | 134 | */ |
146 | unsigned int ready_count; | 135 | unsigned int ready_count; |
@@ -260,6 +249,8 @@ update_sets (struct GNUNET_SCHEDULER_Handle *sched, | |||
260 | GNUNET_NETWORK_fdset_add (rs, pos->read_set); | 249 | GNUNET_NETWORK_fdset_add (rs, pos->read_set); |
261 | if (pos->write_set != NULL) | 250 | if (pos->write_set != NULL) |
262 | GNUNET_NETWORK_fdset_add (ws, pos->write_set); | 251 | GNUNET_NETWORK_fdset_add (ws, pos->write_set); |
252 | if (pos->reason != 0) | ||
253 | *timeout = GNUNET_TIME_UNIT_ZERO; | ||
263 | pos = pos->next; | 254 | pos = pos->next; |
264 | } | 255 | } |
265 | } | 256 | } |
@@ -309,12 +300,7 @@ is_ready (struct GNUNET_SCHEDULER_Handle *sched, | |||
309 | const struct GNUNET_NETWORK_FDSet *rs, | 300 | const struct GNUNET_NETWORK_FDSet *rs, |
310 | const struct GNUNET_NETWORK_FDSet *ws) | 301 | const struct GNUNET_NETWORK_FDSet *ws) |
311 | { | 302 | { |
312 | if ((GNUNET_NO == task->run_on_shutdown) && (GNUNET_YES == sched->shutdown)) | 303 | if (now.value >= task->timeout.value) |
313 | return GNUNET_NO; | ||
314 | if ((GNUNET_YES == task->run_on_shutdown) && | ||
315 | (GNUNET_YES == sched->shutdown)) | ||
316 | task->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; | ||
317 | if (now.value >= task->timeout.value) | ||
318 | task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; | 304 | task->reason |= GNUNET_SCHEDULER_REASON_TIMEOUT; |
319 | if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && | 305 | if ((0 == (task->reason & GNUNET_SCHEDULER_REASON_READ_READY)) && |
320 | (rs != NULL) && (set_overlaps (rs, task->read_set))) | 306 | (rs != NULL) && (set_overlaps (rs, task->read_set))) |
@@ -395,6 +381,32 @@ check_ready (struct GNUNET_SCHEDULER_Handle *handle, | |||
395 | 381 | ||
396 | 382 | ||
397 | /** | 383 | /** |
384 | * Request the shutdown of a scheduler. Marks all currently | ||
385 | * pending tasks as ready because of shutdown. This will | ||
386 | * cause all tasks to run (as soon as possible, respecting | ||
387 | * priorities and prerequisite tasks). Note that tasks | ||
388 | * scheduled AFTER this call may still be delayed arbitrarily. | ||
389 | * | ||
390 | * @param sched the scheduler | ||
391 | */ | ||
392 | void | ||
393 | GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched) | ||
394 | { | ||
395 | struct Task *pos; | ||
396 | |||
397 | pos = sched->pending; | ||
398 | while (pos != NULL) | ||
399 | { | ||
400 | pos->reason |= GNUNET_SCHEDULER_REASON_SHUTDOWN; | ||
401 | /* we don't move the task into the ready queue yet; check_ready | ||
402 | will do that later, possibly adding additional | ||
403 | readyness-factors */ | ||
404 | pos = pos->next; | ||
405 | } | ||
406 | } | ||
407 | |||
408 | |||
409 | /** | ||
398 | * Destroy a task (release associated resources) | 410 | * Destroy a task (release associated resources) |
399 | * | 411 | * |
400 | * @param t task to destroy | 412 | * @param t task to destroy |
@@ -415,7 +427,7 @@ destroy_task (struct Task *t) | |||
415 | * empty. Keep running tasks until we are either no longer running | 427 | * empty. Keep running tasks until we are either no longer running |
416 | * "URGENT" tasks or until we have at least one "pending" task (which | 428 | * "URGENT" tasks or until we have at least one "pending" task (which |
417 | * may become ready, hence we should select on it). Naturally, if | 429 | * may become ready, hence we should select on it). Naturally, if |
418 | * there are no more ready tasks, we also return. | 430 | * there are no more ready tasks, we also return. |
419 | * | 431 | * |
420 | * @param sched the scheduler | 432 | * @param sched the scheduler |
421 | */ | 433 | */ |
@@ -459,7 +471,7 @@ run_ready (struct GNUNET_SCHEDULER_Handle *sched) | |||
459 | while ((sched->pending == NULL) || (p == GNUNET_SCHEDULER_PRIORITY_URGENT)); | 471 | while ((sched->pending == NULL) || (p == GNUNET_SCHEDULER_PRIORITY_URGENT)); |
460 | } | 472 | } |
461 | 473 | ||
462 | 474 | #ifndef MINGW | |
463 | /** | 475 | /** |
464 | * Pipe used to communicate shutdown via signal. | 476 | * Pipe used to communicate shutdown via signal. |
465 | */ | 477 | */ |
@@ -478,19 +490,25 @@ sighandler_shutdown () | |||
478 | (sigpipe, GNUNET_DISK_PIPE_END_WRITE), &c, | 490 | (sigpipe, GNUNET_DISK_PIPE_END_WRITE), &c, |
479 | sizeof (c)); | 491 | sizeof (c)); |
480 | } | 492 | } |
493 | #endif | ||
481 | 494 | ||
482 | 495 | ||
483 | /** | 496 | /** |
484 | * Initialize a scheduler using this thread. This function will | 497 | * Initialize and run scheduler. This function will return when all |
485 | * return when either a shutdown was initiated (via signal) and all | 498 | * tasks have completed. On systems with signals, receiving a SIGTERM |
486 | * tasks marked to "run_on_shutdown" have been completed or when all | 499 | * (and other similar signals) will cause "GNUNET_SCHEDULER_shutdown" |
487 | * tasks in general have been completed. | 500 | * to be run after the active task is complete. As a result, SIGTERM |
501 | * causes all active tasks to be scheduled with reason | ||
502 | * "GNUNET_SCHEDULER_REASON_SHUTDOWN". (However, tasks added | ||
503 | * afterwards will execute normally!). Note that any particular signal | ||
504 | * will only shut down one scheduler; applications should always only | ||
505 | * create a single scheduler. | ||
488 | * | 506 | * |
489 | * @param task task to run immediately | 507 | * @param task task to run immediately |
490 | * @param cls closure of task | 508 | * @param task_cls closure of task |
491 | */ | 509 | */ |
492 | void | 510 | void |
493 | GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls) | 511 | GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *task_cls) |
494 | { | 512 | { |
495 | struct GNUNET_SCHEDULER_Handle sched; | 513 | struct GNUNET_SCHEDULER_Handle sched; |
496 | struct GNUNET_NETWORK_FDSet *rs; | 514 | struct GNUNET_NETWORK_FDSet *rs; |
@@ -501,12 +519,12 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls) | |||
501 | struct GNUNET_SIGNAL_Context *shc_term; | 519 | struct GNUNET_SIGNAL_Context *shc_term; |
502 | struct GNUNET_SIGNAL_Context *shc_quit; | 520 | struct GNUNET_SIGNAL_Context *shc_quit; |
503 | struct GNUNET_SIGNAL_Context *shc_hup; | 521 | struct GNUNET_SIGNAL_Context *shc_hup; |
504 | struct Task *tpos; | ||
505 | unsigned long long last_tr; | 522 | unsigned long long last_tr; |
506 | unsigned int busy_wait_warning; | 523 | unsigned int busy_wait_warning; |
507 | #ifndef MINGW | 524 | #ifndef MINGW |
508 | const struct GNUNET_DISK_FileHandle *pr; | 525 | const struct GNUNET_DISK_FileHandle *pr; |
509 | #endif | 526 | #endif |
527 | char c; | ||
510 | 528 | ||
511 | rs = GNUNET_NETWORK_fdset_create (); | 529 | rs = GNUNET_NETWORK_fdset_create (); |
512 | ws = GNUNET_NETWORK_fdset_create (); | 530 | ws = GNUNET_NETWORK_fdset_create (); |
@@ -516,38 +534,40 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls) | |||
516 | GNUNET_assert (sigpipe != NULL); | 534 | GNUNET_assert (sigpipe != NULL); |
517 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); | 535 | pr = GNUNET_DISK_pipe_handle (sigpipe, GNUNET_DISK_PIPE_END_READ); |
518 | GNUNET_assert (pr != NULL); | 536 | GNUNET_assert (pr != NULL); |
519 | shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown); | 537 | shc_int = GNUNET_SIGNAL_handler_install (SIGINT, &sighandler_shutdown); |
520 | shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown); | 538 | shc_term = GNUNET_SIGNAL_handler_install (SIGTERM, &sighandler_shutdown); |
521 | shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown); | 539 | shc_quit = GNUNET_SIGNAL_handler_install (SIGQUIT, &sighandler_shutdown); |
522 | shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown); | 540 | shc_hup = GNUNET_SIGNAL_handler_install (SIGHUP, &sighandler_shutdown); |
523 | #endif | 541 | #endif |
524 | memset (&sched, 0, sizeof (sched)); | 542 | memset (&sched, 0, sizeof (sched)); |
525 | sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; | 543 | sched.current_priority = GNUNET_SCHEDULER_PRIORITY_DEFAULT; |
526 | GNUNET_SCHEDULER_add_continuation (&sched, | 544 | GNUNET_SCHEDULER_add_continuation (&sched, |
527 | GNUNET_YES, | ||
528 | task, | 545 | task, |
529 | cls, GNUNET_SCHEDULER_REASON_STARTUP); | 546 | task_cls, |
547 | GNUNET_SCHEDULER_REASON_STARTUP); | ||
530 | last_tr = 0; | 548 | last_tr = 0; |
531 | busy_wait_warning = 0; | 549 | busy_wait_warning = 0; |
532 | while ((GNUNET_NO == sched.shutdown) && | 550 | while ( (sched.pending != NULL) || (sched.ready_count > 0) ) |
533 | ((sched.pending != NULL) || (sched.ready_count > 0))) | ||
534 | { | 551 | { |
535 | GNUNET_NETWORK_fdset_zero (rs); | 552 | GNUNET_NETWORK_fdset_zero (rs); |
536 | GNUNET_NETWORK_fdset_zero (ws); | 553 | GNUNET_NETWORK_fdset_zero (ws); |
537 | timeout = GNUNET_TIME_relative_get_forever (); | 554 | timeout = GNUNET_TIME_UNIT_FOREVER_REL; |
538 | update_sets (&sched, rs, ws, &timeout); | 555 | update_sets (&sched, rs, ws, &timeout); |
539 | #ifndef MINGW | ||
540 | GNUNET_NETWORK_fdset_handle_set (rs, pr); | 556 | GNUNET_NETWORK_fdset_handle_set (rs, pr); |
541 | #endif | ||
542 | if (sched.ready_count > 0) | 557 | if (sched.ready_count > 0) |
543 | { | 558 | { |
544 | /* no blocking, more work already ready! */ | 559 | /* no blocking, more work already ready! */ |
545 | timeout = GNUNET_TIME_relative_get_zero (); | 560 | timeout = GNUNET_TIME_UNIT_ZERO; |
546 | } | 561 | } |
547 | ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout); | 562 | ret = GNUNET_NETWORK_socket_select (rs, ws, NULL, timeout); |
548 | #ifndef MINGW | 563 | #ifndef MINGW |
549 | if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) | 564 | if (GNUNET_NETWORK_fdset_handle_isset (rs, pr)) |
550 | break; | 565 | { |
566 | /* consume the signal */ | ||
567 | GNUNET_DISK_file_read (pr, &c, sizeof(c)); | ||
568 | /* mark all active tasks as ready due to shutdown */ | ||
569 | GNUNET_SCHEDULER_shutdown (&sched); | ||
570 | } | ||
551 | #endif | 571 | #endif |
552 | if (last_tr == sched.tasks_run) | 572 | if (last_tr == sched.tasks_run) |
553 | { | 573 | { |
@@ -574,7 +594,6 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls) | |||
574 | check_ready (&sched, rs, ws); | 594 | check_ready (&sched, rs, ws); |
575 | run_ready (&sched); | 595 | run_ready (&sched); |
576 | } | 596 | } |
577 | sched.shutdown = GNUNET_YES; | ||
578 | #ifndef MINGW | 597 | #ifndef MINGW |
579 | GNUNET_SIGNAL_handler_uninstall (shc_int); | 598 | GNUNET_SIGNAL_handler_uninstall (shc_int); |
580 | GNUNET_SIGNAL_handler_uninstall (shc_term); | 599 | GNUNET_SIGNAL_handler_uninstall (shc_term); |
@@ -583,36 +602,11 @@ GNUNET_SCHEDULER_run (GNUNET_SCHEDULER_Task task, void *cls) | |||
583 | GNUNET_DISK_pipe_close (sigpipe); | 602 | GNUNET_DISK_pipe_close (sigpipe); |
584 | sigpipe = NULL; | 603 | sigpipe = NULL; |
585 | #endif | 604 | #endif |
586 | do | ||
587 | { | ||
588 | run_ready (&sched); | ||
589 | check_ready (&sched, NULL, NULL); | ||
590 | } | ||
591 | while (sched.ready_count > 0); | ||
592 | while (NULL != (tpos = sched.pending)) | ||
593 | { | ||
594 | sched.pending = tpos->next; | ||
595 | GNUNET_free (tpos); | ||
596 | } | ||
597 | GNUNET_NETWORK_fdset_destroy (rs); | 605 | GNUNET_NETWORK_fdset_destroy (rs); |
598 | GNUNET_NETWORK_fdset_destroy (ws); | 606 | GNUNET_NETWORK_fdset_destroy (ws); |
599 | } | 607 | } |
600 | 608 | ||
601 | 609 | ||
602 | /** | ||
603 | * Request the shutdown of a scheduler. This function can be used to | ||
604 | * stop a scheduling thread when created with the | ||
605 | * "GNUNET_SCHEDULER_init_thread" function or from within the signal | ||
606 | * handler for signals causing shutdowns. | ||
607 | * | ||
608 | * @param sched the scheduler | ||
609 | */ | ||
610 | void | ||
611 | GNUNET_SCHEDULER_shutdown (struct GNUNET_SCHEDULER_Handle *sched) | ||
612 | { | ||
613 | sched->shutdown = GNUNET_YES; | ||
614 | } | ||
615 | |||
616 | 610 | ||
617 | /** | 611 | /** |
618 | * Get information about the current load of this scheduler. Use this | 612 | * Get information about the current load of this scheduler. Use this |
@@ -715,102 +709,113 @@ GNUNET_SCHEDULER_cancel (struct GNUNET_SCHEDULER_Handle *sched, | |||
715 | * and the reason code can be specified. | 709 | * and the reason code can be specified. |
716 | * | 710 | * |
717 | * @param sched scheduler to use | 711 | * @param sched scheduler to use |
718 | * @param run_on_shutdown should this task be run if we are shutting down? | 712 | * @param task main function of the task |
719 | * @param main main function of the task | 713 | * @param task_cls closure for 'main' |
720 | * @param cls closure for 'main' | ||
721 | * @param reason reason for task invocation | 714 | * @param reason reason for task invocation |
722 | */ | 715 | */ |
723 | void | 716 | void |
724 | GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched, | 717 | GNUNET_SCHEDULER_add_continuation (struct GNUNET_SCHEDULER_Handle *sched, |
725 | int run_on_shutdown, | 718 | GNUNET_SCHEDULER_Task task, |
726 | GNUNET_SCHEDULER_Task main, | 719 | void *task_cls, |
727 | void *cls, | ||
728 | enum GNUNET_SCHEDULER_Reason reason) | 720 | enum GNUNET_SCHEDULER_Reason reason) |
729 | { | 721 | { |
730 | struct Task *task; | 722 | struct Task *t; |
731 | 723 | ||
732 | task = GNUNET_malloc (sizeof (struct Task)); | 724 | t = GNUNET_malloc (sizeof (struct Task)); |
733 | task->callback = main; | 725 | t->callback = task; |
734 | task->callback_cls = cls; | 726 | t->callback_cls = task_cls; |
735 | task->id = ++sched->last_id; | 727 | t->id = ++sched->last_id; |
736 | task->reason = reason; | 728 | t->reason = reason; |
737 | task->priority = sched->current_priority; | 729 | t->priority = sched->current_priority; |
738 | task->run_on_shutdown = run_on_shutdown; | ||
739 | #if DEBUG_TASKS | 730 | #if DEBUG_TASKS |
740 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 731 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
741 | "Adding continuation task: %llu / %p\n", | 732 | "Adding continuation task: %llu / %p\n", |
742 | task->id, task->callback_cls); | 733 | t->id, t->callback_cls); |
743 | #endif | 734 | #endif |
744 | queue_ready_task (sched, task); | 735 | queue_ready_task (sched, t); |
745 | } | 736 | } |
746 | 737 | ||
747 | 738 | ||
739 | |||
748 | /** | 740 | /** |
749 | * Schedule a new task to be run after the specified | 741 | * Schedule a new task to be run after the specified prerequisite task |
750 | * prerequisite task has completed. | 742 | * has completed. It will be run with the priority of the calling |
743 | * task. | ||
751 | * | 744 | * |
752 | * @param sched scheduler to use | 745 | * @param sched scheduler to use |
753 | * @param run_on_shutdown run on shutdown? | ||
754 | * @param prio how important is this task? | ||
755 | * @param prerequisite_task run this task after the task with the given | 746 | * @param prerequisite_task run this task after the task with the given |
756 | * task identifier completes (and any of our other | 747 | * task identifier completes (and any of our other |
757 | * conditions, such as delay, read or write-readyness | 748 | * conditions, such as delay, read or write-readyness |
758 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | 749 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency |
759 | * on completion of other tasks. | 750 | * on completion of other tasks (this will cause the task to run as |
760 | * @param main main function of the task | 751 | * soon as possible). |
761 | * @param cls closure for 'main' | 752 | * @param task main function of the task |
753 | * @param task_cls closure of task | ||
762 | * @return unique task identifier for the job | 754 | * @return unique task identifier for the job |
763 | * only valid until "main" is started! | 755 | * only valid until "task" is started! |
764 | */ | 756 | */ |
765 | GNUNET_SCHEDULER_TaskIdentifier | 757 | GNUNET_SCHEDULER_TaskIdentifier |
766 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, | 758 | GNUNET_SCHEDULER_add_after (struct GNUNET_SCHEDULER_Handle *sched, |
767 | int run_on_shutdown, | ||
768 | enum GNUNET_SCHEDULER_Priority prio, | ||
769 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, | 759 | GNUNET_SCHEDULER_TaskIdentifier prerequisite_task, |
770 | GNUNET_SCHEDULER_Task main, void *cls) | 760 | GNUNET_SCHEDULER_Task task, |
761 | void *task_cls) | ||
771 | { | 762 | { |
772 | return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | 763 | return GNUNET_SCHEDULER_add_select (sched, |
764 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
773 | prerequisite_task, | 765 | prerequisite_task, |
774 | GNUNET_TIME_UNIT_ZERO, | 766 | GNUNET_TIME_UNIT_ZERO, |
775 | NULL, NULL, main, cls); | 767 | NULL, NULL, task, task_cls); |
776 | } | 768 | } |
777 | 769 | ||
778 | 770 | ||
779 | /** | 771 | /** |
772 | * Schedule a new task to be run with a specified priority. | ||
773 | * | ||
774 | * @param sched scheduler to use | ||
775 | * @param prio how important is the new task? | ||
776 | * @param task main function of the task | ||
777 | * @param task_cls closure of task | ||
778 | * @return unique task identifier for the job | ||
779 | * only valid until "task" is started! | ||
780 | */ | ||
781 | GNUNET_SCHEDULER_TaskIdentifier | ||
782 | GNUNET_SCHEDULER_add_with_priority (struct GNUNET_SCHEDULER_Handle *sched, | ||
783 | enum GNUNET_SCHEDULER_Priority prio, | ||
784 | GNUNET_SCHEDULER_Task task, | ||
785 | void *task_cls) | ||
786 | { | ||
787 | return GNUNET_SCHEDULER_add_select (sched, | ||
788 | prio, | ||
789 | GNUNET_SCHEDULER_NO_TASK, | ||
790 | GNUNET_TIME_UNIT_ZERO, | ||
791 | NULL, NULL, task, task_cls); | ||
792 | } | ||
793 | |||
794 | |||
795 | |||
796 | /** | ||
780 | * Schedule a new task to be run with a specified delay. The task | 797 | * Schedule a new task to be run with a specified delay. The task |
781 | * will be scheduled for execution once the delay has expired and the | 798 | * will be scheduled for execution once the delay has expired. It |
782 | * prerequisite task has completed. | 799 | * will be run with the priority of the calling task. |
783 | * | 800 | * |
784 | * @param sched scheduler to use | 801 | * @param sched scheduler to use |
785 | * @param run_on_shutdown run on shutdown? You can use this | 802 | * @param delay when should this operation time out? Use |
786 | * argument to run a function only during shutdown | 803 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
787 | * by setting delay to -1. Set this | 804 | * @param task main function of the task |
788 | * argument to GNUNET_NO to skip this task if | 805 | * @param task_cls closure of task |
789 | * the user requested process termination. | ||
790 | * @param prio how important is this task? | ||
791 | * @param prerequisite_task run this task after the task with the given | ||
792 | * task identifier completes (and any of our other | ||
793 | * conditions, such as delay, read or write-readyness | ||
794 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
795 | * on completion of other tasks. | ||
796 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
797 | * @param main main function of the task | ||
798 | * @param cls closure of task | ||
799 | * @return unique task identifier for the job | 806 | * @return unique task identifier for the job |
800 | * only valid until "main" is started! | 807 | * only valid until "task" is started! |
801 | */ | 808 | */ |
802 | GNUNET_SCHEDULER_TaskIdentifier | 809 | GNUNET_SCHEDULER_TaskIdentifier |
803 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched, | 810 | GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle *sched, |
804 | int run_on_shutdown, | ||
805 | enum GNUNET_SCHEDULER_Priority prio, | ||
806 | GNUNET_SCHEDULER_TaskIdentifier | ||
807 | prerequisite_task, | ||
808 | struct GNUNET_TIME_Relative delay, | 811 | struct GNUNET_TIME_Relative delay, |
809 | GNUNET_SCHEDULER_Task main, void *cls) | 812 | GNUNET_SCHEDULER_Task task, |
813 | void *task_cls) | ||
810 | { | 814 | { |
811 | return GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | 815 | return GNUNET_SCHEDULER_add_select (sched, |
812 | prerequisite_task, delay, | 816 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
813 | NULL, NULL, main, cls); | 817 | GNUNET_SCHEDULER_NO_TASK, delay, |
818 | NULL, NULL, task, task_cls); | ||
814 | } | 819 | } |
815 | 820 | ||
816 | 821 | ||
@@ -819,34 +824,24 @@ GNUNET_SCHEDULER_add_delayed (struct GNUNET_SCHEDULER_Handle * sched, | |||
819 | * specified file descriptor is ready for reading. The delay can be | 824 | * specified file descriptor is ready for reading. The delay can be |
820 | * used as a timeout on the socket being ready. The task will be | 825 | * used as a timeout on the socket being ready. The task will be |
821 | * scheduled for execution once either the delay has expired or the | 826 | * scheduled for execution once either the delay has expired or the |
822 | * socket operation is ready. | 827 | * socket operation is ready. It will be run with the priority of |
828 | * the calling task. | ||
823 | * | 829 | * |
824 | * @param sched scheduler to use | 830 | * @param sched scheduler to use |
825 | * @param run_on_shutdown run on shutdown? Set this | 831 | * @param delay when should this operation time out? Use |
826 | * argument to GNUNET_NO to skip this task if | 832 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
827 | * the user requested process termination. | ||
828 | * @param prio how important is this task? | ||
829 | * @param prerequisite_task run this task after the task with the given | ||
830 | * task identifier completes (and any of our other | ||
831 | * conditions, such as delay, read or write-readyness | ||
832 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
833 | * on completion of other tasks. | ||
834 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
835 | * @param rfd read file-descriptor | 833 | * @param rfd read file-descriptor |
836 | * @param main main function of the task | 834 | * @param task main function of the task |
837 | * @param cls closure of task | 835 | * @param task_cls closure of task |
838 | * @return unique task identifier for the job | 836 | * @return unique task identifier for the job |
839 | * only valid until "main" is started! | 837 | * only valid until "task" is started! |
840 | */ | 838 | */ |
841 | GNUNET_SCHEDULER_TaskIdentifier | 839 | GNUNET_SCHEDULER_TaskIdentifier |
842 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched, | 840 | GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle *sched, |
843 | int run_on_shutdown, | 841 | struct GNUNET_TIME_Relative delay, |
844 | enum GNUNET_SCHEDULER_Priority prio, | 842 | struct GNUNET_NETWORK_Handle *rfd, |
845 | GNUNET_SCHEDULER_TaskIdentifier | 843 | GNUNET_SCHEDULER_Task task, |
846 | prerequisite_task, | 844 | void *task_cls) |
847 | struct GNUNET_TIME_Relative delay, | ||
848 | struct GNUNET_NETWORK_Handle * rfd, | ||
849 | GNUNET_SCHEDULER_Task main, void *cls) | ||
850 | { | 845 | { |
851 | struct GNUNET_NETWORK_FDSet *rs; | 846 | struct GNUNET_NETWORK_FDSet *rs; |
852 | GNUNET_SCHEDULER_TaskIdentifier ret; | 847 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -854,9 +849,11 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched, | |||
854 | GNUNET_assert (rfd != NULL); | 849 | GNUNET_assert (rfd != NULL); |
855 | rs = GNUNET_NETWORK_fdset_create (); | 850 | rs = GNUNET_NETWORK_fdset_create (); |
856 | GNUNET_NETWORK_fdset_set (rs, rfd); | 851 | GNUNET_NETWORK_fdset_set (rs, rfd); |
857 | ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | 852 | ret = GNUNET_SCHEDULER_add_select (sched, |
858 | prerequisite_task, delay, | 853 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
859 | rs, NULL, main, cls); | 854 | GNUNET_SCHEDULER_NO_TASK, |
855 | delay, | ||
856 | rs, NULL, task, task_cls); | ||
860 | GNUNET_NETWORK_fdset_destroy (rs); | 857 | GNUNET_NETWORK_fdset_destroy (rs); |
861 | return ret; | 858 | return ret; |
862 | } | 859 | } |
@@ -867,34 +864,24 @@ GNUNET_SCHEDULER_add_read_net (struct GNUNET_SCHEDULER_Handle * sched, | |||
867 | * specified file descriptor is ready for writing. The delay can be | 864 | * specified file descriptor is ready for writing. The delay can be |
868 | * used as a timeout on the socket being ready. The task will be | 865 | * used as a timeout on the socket being ready. The task will be |
869 | * scheduled for execution once either the delay has expired or the | 866 | * scheduled for execution once either the delay has expired or the |
870 | * socket operation is ready. | 867 | * socket operation is ready. It will be run with the priority of |
868 | * the calling task. | ||
871 | * | 869 | * |
872 | * @param sched scheduler to use | 870 | * @param sched scheduler to use |
873 | * @param run_on_shutdown run on shutdown? Set this | 871 | * @param delay when should this operation time out? Use |
874 | * argument to GNUNET_NO to skip this task if | 872 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" |
875 | * the user requested process termination. | ||
876 | * @param prio how important is this task? | ||
877 | * @param prerequisite_task run this task after the task with the given | ||
878 | * task identifier completes (and any of our other | ||
879 | * conditions, such as delay, read or write-readyness | ||
880 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
881 | * on completion of other tasks. | ||
882 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
883 | * @param wfd write file-descriptor | 873 | * @param wfd write file-descriptor |
884 | * @param main main function of the task | 874 | * @param task main function of the task |
885 | * @param cls closure of task | 875 | * @param task_cls closure of task |
886 | * @return unique task identifier for the job | 876 | * @return unique task identifier for the job |
887 | * only valid until "main" is started! | 877 | * only valid until "task" is started! |
888 | */ | 878 | */ |
889 | GNUNET_SCHEDULER_TaskIdentifier | 879 | GNUNET_SCHEDULER_TaskIdentifier |
890 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched, | 880 | GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle *sched, |
891 | int run_on_shutdown, | 881 | struct GNUNET_TIME_Relative delay, |
892 | enum GNUNET_SCHEDULER_Priority prio, | 882 | struct GNUNET_NETWORK_Handle *wfd, |
893 | GNUNET_SCHEDULER_TaskIdentifier | 883 | GNUNET_SCHEDULER_Task task, |
894 | prerequisite_task, | 884 | void *task_cls) |
895 | struct GNUNET_TIME_Relative delay, | ||
896 | struct GNUNET_NETWORK_Handle * wfd, | ||
897 | GNUNET_SCHEDULER_Task main, void *cls) | ||
898 | { | 885 | { |
899 | struct GNUNET_NETWORK_FDSet *ws; | 886 | struct GNUNET_NETWORK_FDSet *ws; |
900 | GNUNET_SCHEDULER_TaskIdentifier ret; | 887 | GNUNET_SCHEDULER_TaskIdentifier ret; |
@@ -902,14 +889,95 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched, | |||
902 | GNUNET_assert (wfd != NULL); | 889 | GNUNET_assert (wfd != NULL); |
903 | ws = GNUNET_NETWORK_fdset_create (); | 890 | ws = GNUNET_NETWORK_fdset_create (); |
904 | GNUNET_NETWORK_fdset_set (ws, wfd); | 891 | GNUNET_NETWORK_fdset_set (ws, wfd); |
905 | ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | 892 | ret = GNUNET_SCHEDULER_add_select (sched, |
906 | prerequisite_task, delay, | 893 | GNUNET_SCHEDULER_PRIORITY_KEEP, |
907 | NULL, ws, main, cls); | 894 | GNUNET_SCHEDULER_NO_TASK, delay, |
895 | NULL, ws, task, task_cls); | ||
896 | GNUNET_NETWORK_fdset_destroy (ws); | ||
897 | return ret; | ||
898 | } | ||
899 | |||
900 | |||
901 | /** | ||
902 | * Schedule a new task to be run with a specified delay or when the | ||
903 | * specified file descriptor is ready for reading. The delay can be | ||
904 | * used as a timeout on the socket being ready. The task will be | ||
905 | * scheduled for execution once either the delay has expired or the | ||
906 | * socket operation is ready. It will be run with the priority of | ||
907 | * the calling task. | ||
908 | * | ||
909 | * @param sched scheduler to use | ||
910 | * @param delay when should this operation time out? Use | ||
911 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" | ||
912 | * @param rfd read file-descriptor | ||
913 | * @param task main function of the task | ||
914 | * @param task_cls closure of task | ||
915 | * @return unique task identifier for the job | ||
916 | * only valid until "task" is started! | ||
917 | */ | ||
918 | GNUNET_SCHEDULER_TaskIdentifier | ||
919 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle *sched, | ||
920 | struct GNUNET_TIME_Relative delay, | ||
921 | const struct GNUNET_DISK_FileHandle *rfd, | ||
922 | GNUNET_SCHEDULER_Task task, | ||
923 | void *task_cls) | ||
924 | { | ||
925 | struct GNUNET_NETWORK_FDSet *rs; | ||
926 | GNUNET_SCHEDULER_TaskIdentifier ret; | ||
927 | |||
928 | GNUNET_assert (rfd != NULL); | ||
929 | rs = GNUNET_NETWORK_fdset_create (); | ||
930 | GNUNET_NETWORK_fdset_handle_set (rs, rfd); | ||
931 | ret = GNUNET_SCHEDULER_add_select (sched, | ||
932 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
933 | GNUNET_SCHEDULER_NO_TASK, delay, | ||
934 | rs, NULL, task, task_cls); | ||
935 | GNUNET_NETWORK_fdset_destroy (rs); | ||
936 | return ret; | ||
937 | } | ||
938 | |||
939 | |||
940 | /** | ||
941 | * Schedule a new task to be run with a specified delay or when the | ||
942 | * specified file descriptor is ready for writing. The delay can be | ||
943 | * used as a timeout on the socket being ready. The task will be | ||
944 | * scheduled for execution once either the delay has expired or the | ||
945 | * socket operation is ready. It will be run with the priority of | ||
946 | * the calling task. | ||
947 | * | ||
948 | * @param sched scheduler to use | ||
949 | * @param delay when should this operation time out? Use | ||
950 | * GNUNET_TIME_UNIT_FOREVER_REL for "on shutdown" | ||
951 | * @param wfd write file-descriptor | ||
952 | * @param task main function of the task | ||
953 | * @param task_cls closure of task | ||
954 | * @return unique task identifier for the job | ||
955 | * only valid until "task" is started! | ||
956 | */ | ||
957 | GNUNET_SCHEDULER_TaskIdentifier | ||
958 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle *sched, | ||
959 | struct GNUNET_TIME_Relative delay, | ||
960 | const struct GNUNET_DISK_FileHandle *wfd, | ||
961 | GNUNET_SCHEDULER_Task task, | ||
962 | void *task_cls) | ||
963 | { | ||
964 | struct GNUNET_NETWORK_FDSet *ws; | ||
965 | GNUNET_SCHEDULER_TaskIdentifier ret; | ||
966 | |||
967 | GNUNET_assert (wfd != NULL); | ||
968 | ws = GNUNET_NETWORK_fdset_create (); | ||
969 | GNUNET_NETWORK_fdset_handle_set (ws, wfd); | ||
970 | ret = GNUNET_SCHEDULER_add_select (sched, | ||
971 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
972 | GNUNET_SCHEDULER_NO_TASK, | ||
973 | delay, | ||
974 | NULL, ws, task, task_cls); | ||
908 | GNUNET_NETWORK_fdset_destroy (ws); | 975 | GNUNET_NETWORK_fdset_destroy (ws); |
909 | return ret; | 976 | return ret; |
910 | } | 977 | } |
911 | 978 | ||
912 | 979 | ||
980 | |||
913 | /** | 981 | /** |
914 | * Schedule a new task to be run with a specified delay or when any of | 982 | * Schedule a new task to be run with a specified delay or when any of |
915 | * the specified file descriptor sets is ready. The delay can be used | 983 | * the specified file descriptor sets is ready. The delay can be used |
@@ -928,160 +996,61 @@ GNUNET_SCHEDULER_add_write_net (struct GNUNET_SCHEDULER_Handle * sched, | |||
928 | * </code> | 996 | * </code> |
929 | * | 997 | * |
930 | * @param sched scheduler to use | 998 | * @param sched scheduler to use |
931 | * @param run_on_shutdown run on shutdown? Set this | ||
932 | * argument to GNUNET_NO to skip this task if | ||
933 | * the user requested process termination. | ||
934 | * @param prio how important is this task? | 999 | * @param prio how important is this task? |
935 | * @param prerequisite_task run this task after the task with the given | 1000 | * @param prerequisite_task run this task after the task with the given |
936 | * task identifier completes (and any of our other | 1001 | * task identifier completes (and any of our other |
937 | * conditions, such as delay, read or write-readyness | 1002 | * conditions, such as delay, read or write-readyness |
938 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | 1003 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency |
939 | * on completion of other tasks. | 1004 | * on completion of other tasks. |
940 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | 1005 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever", |
1006 | * which means that the task will only be run after we receive SIGTERM | ||
941 | * @param rs set of file descriptors we want to read (can be NULL) | 1007 | * @param rs set of file descriptors we want to read (can be NULL) |
942 | * @param ws set of file descriptors we want to write (can be NULL) | 1008 | * @param ws set of file descriptors we want to write (can be NULL) |
943 | * @param main main function of the task | 1009 | * @param task main function of the task |
944 | * @param cls closure of task | 1010 | * @param task_cls closure of task |
945 | * @return unique task identifier for the job | 1011 | * @return unique task identifier for the job |
946 | * only valid until "main" is started! | 1012 | * only valid until "task" is started! |
947 | */ | 1013 | */ |
948 | GNUNET_SCHEDULER_TaskIdentifier | 1014 | GNUNET_SCHEDULER_TaskIdentifier |
949 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle * sched, | 1015 | GNUNET_SCHEDULER_add_select (struct GNUNET_SCHEDULER_Handle *sched, |
950 | int run_on_shutdown, | ||
951 | enum GNUNET_SCHEDULER_Priority prio, | 1016 | enum GNUNET_SCHEDULER_Priority prio, |
952 | GNUNET_SCHEDULER_TaskIdentifier | 1017 | GNUNET_SCHEDULER_TaskIdentifier |
953 | prerequisite_task, | 1018 | prerequisite_task, |
954 | struct GNUNET_TIME_Relative delay, | 1019 | struct GNUNET_TIME_Relative delay, |
955 | const struct GNUNET_NETWORK_FDSet * rs, | 1020 | const struct GNUNET_NETWORK_FDSet * rs, |
956 | const struct GNUNET_NETWORK_FDSet * ws, | 1021 | const struct GNUNET_NETWORK_FDSet * ws, |
957 | GNUNET_SCHEDULER_Task main, void *cls) | 1022 | GNUNET_SCHEDULER_Task task, |
1023 | void *task_cls) | ||
958 | { | 1024 | { |
959 | struct Task *task; | 1025 | struct Task *t; |
960 | 1026 | ||
961 | task = GNUNET_malloc (sizeof (struct Task)); | 1027 | t = GNUNET_malloc (sizeof (struct Task)); |
962 | task->callback = main; | 1028 | t->callback = task; |
963 | task->callback_cls = cls; | 1029 | t->callback_cls = task_cls; |
964 | if (rs != NULL) | 1030 | if (rs != NULL) |
965 | { | 1031 | { |
966 | task->read_set = GNUNET_NETWORK_fdset_create (); | 1032 | t->read_set = GNUNET_NETWORK_fdset_create (); |
967 | GNUNET_NETWORK_fdset_copy (task->read_set, rs); | 1033 | GNUNET_NETWORK_fdset_copy (t->read_set, rs); |
968 | } | 1034 | } |
969 | if (ws != NULL) | 1035 | if (ws != NULL) |
970 | { | 1036 | { |
971 | task->write_set = GNUNET_NETWORK_fdset_create (); | 1037 | t->write_set = GNUNET_NETWORK_fdset_create (); |
972 | GNUNET_NETWORK_fdset_copy (task->write_set, ws); | 1038 | GNUNET_NETWORK_fdset_copy (t->write_set, ws); |
973 | } | 1039 | } |
974 | task->id = ++sched->last_id; | 1040 | t->id = ++sched->last_id; |
975 | task->prereq_id = prerequisite_task; | 1041 | t->prereq_id = prerequisite_task; |
976 | task->timeout = GNUNET_TIME_relative_to_absolute (delay); | 1042 | t->timeout = GNUNET_TIME_relative_to_absolute (delay); |
977 | task->priority = | 1043 | t->priority = |
978 | check_priority ((prio == | 1044 | check_priority ((prio == |
979 | GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->current_priority | 1045 | GNUNET_SCHEDULER_PRIORITY_KEEP) ? sched->current_priority |
980 | : prio); | 1046 | : prio); |
981 | task->run_on_shutdown = run_on_shutdown; | 1047 | t->next = sched->pending; |
982 | task->next = sched->pending; | 1048 | sched->pending = t; |
983 | sched->pending = task; | ||
984 | #if DEBUG_TASKS | 1049 | #if DEBUG_TASKS |
985 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 1050 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, |
986 | "Adding task: %llu / %p\n", task->id, task->callback_cls); | 1051 | "Adding task: %llu / %p\n", t->id, t->callback_cls); |
987 | #endif | 1052 | #endif |
988 | return task->id; | 1053 | return t->id; |
989 | } | 1054 | } |
990 | 1055 | ||
991 | /** | ||
992 | * Schedule a new task to be run with a specified delay or when the | ||
993 | * specified file descriptor is ready for reading. The delay can be | ||
994 | * used as a timeout on the socket being ready. The task will be | ||
995 | * scheduled for execution once either the delay has expired or the | ||
996 | * socket operation is ready. | ||
997 | * | ||
998 | * @param sched scheduler to use | ||
999 | * @param run_on_shutdown run on shutdown? Set this | ||
1000 | * argument to GNUNET_NO to skip this task if | ||
1001 | * the user requested process termination. | ||
1002 | * @param prio how important is this task? | ||
1003 | * @param prerequisite_task run this task after the task with the given | ||
1004 | * task identifier completes (and any of our other | ||
1005 | * conditions, such as delay, read or write-readyness | ||
1006 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
1007 | * on completion of other tasks. | ||
1008 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
1009 | * @param rfd read file-descriptor | ||
1010 | * @param main main function of the task | ||
1011 | * @param cls closure of task | ||
1012 | * @return unique task identifier for the job | ||
1013 | * only valid until "main" is started! | ||
1014 | */ | ||
1015 | GNUNET_SCHEDULER_TaskIdentifier | ||
1016 | GNUNET_SCHEDULER_add_read_file (struct GNUNET_SCHEDULER_Handle * sched, | ||
1017 | int run_on_shutdown, | ||
1018 | enum GNUNET_SCHEDULER_Priority prio, | ||
1019 | GNUNET_SCHEDULER_TaskIdentifier | ||
1020 | prerequisite_task, | ||
1021 | struct GNUNET_TIME_Relative delay, | ||
1022 | const struct GNUNET_DISK_FileHandle * rfd, | ||
1023 | GNUNET_SCHEDULER_Task main, void *cls) | ||
1024 | { | ||
1025 | struct GNUNET_NETWORK_FDSet *rs; | ||
1026 | GNUNET_SCHEDULER_TaskIdentifier ret; | ||
1027 | |||
1028 | GNUNET_assert (rfd != NULL); | ||
1029 | rs = GNUNET_NETWORK_fdset_create (); | ||
1030 | GNUNET_NETWORK_fdset_handle_set (rs, rfd); | ||
1031 | ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | ||
1032 | prerequisite_task, delay, | ||
1033 | rs, NULL, main, cls); | ||
1034 | GNUNET_NETWORK_fdset_destroy (rs); | ||
1035 | return ret; | ||
1036 | } | ||
1037 | |||
1038 | |||
1039 | /** | ||
1040 | * Schedule a new task to be run with a specified delay or when the | ||
1041 | * specified file descriptor is ready for writing. The delay can be | ||
1042 | * used as a timeout on the socket being ready. The task will be | ||
1043 | * scheduled for execution once either the delay has expired or the | ||
1044 | * socket operation is ready. | ||
1045 | * | ||
1046 | * @param sched scheduler to use | ||
1047 | * @param run_on_shutdown run on shutdown? Set this | ||
1048 | * argument to GNUNET_NO to skip this task if | ||
1049 | * the user requested process termination. | ||
1050 | * @param prio how important is this task? | ||
1051 | * @param prerequisite_task run this task after the task with the given | ||
1052 | * task identifier completes (and any of our other | ||
1053 | * conditions, such as delay, read or write-readyness | ||
1054 | * are satisfied). Use GNUNET_SCHEDULER_NO_TASK to not have any dependency | ||
1055 | * on completion of other tasks. | ||
1056 | * @param delay how long should we wait? Use GNUNET_TIME_UNIT_FOREVER_REL for "forever" | ||
1057 | * @param wfd write file-descriptor | ||
1058 | * @param main main function of the task | ||
1059 | * @param cls closure of task | ||
1060 | * @return unique task identifier for the job | ||
1061 | * only valid until "main" is started! | ||
1062 | */ | ||
1063 | GNUNET_SCHEDULER_TaskIdentifier | ||
1064 | GNUNET_SCHEDULER_add_write_file (struct GNUNET_SCHEDULER_Handle * sched, | ||
1065 | int run_on_shutdown, | ||
1066 | enum GNUNET_SCHEDULER_Priority prio, | ||
1067 | GNUNET_SCHEDULER_TaskIdentifier | ||
1068 | prerequisite_task, | ||
1069 | struct GNUNET_TIME_Relative delay, | ||
1070 | const struct GNUNET_DISK_FileHandle * wfd, | ||
1071 | GNUNET_SCHEDULER_Task main, void *cls) | ||
1072 | { | ||
1073 | struct GNUNET_NETWORK_FDSet *ws; | ||
1074 | GNUNET_SCHEDULER_TaskIdentifier ret; | ||
1075 | |||
1076 | GNUNET_assert (wfd != NULL); | ||
1077 | ws = GNUNET_NETWORK_fdset_create (); | ||
1078 | GNUNET_NETWORK_fdset_handle_set (ws, wfd); | ||
1079 | ret = GNUNET_SCHEDULER_add_select (sched, run_on_shutdown, prio, | ||
1080 | prerequisite_task, delay, | ||
1081 | NULL, ws, main, cls); | ||
1082 | GNUNET_NETWORK_fdset_destroy (ws); | ||
1083 | return ret; | ||
1084 | } | ||
1085 | |||
1086 | |||
1087 | /* end of scheduler.c */ | 1056 | /* end of scheduler.c */ |
diff --git a/src/util/server.c b/src/util/server.c index 42fa8c46c..ff9c8c192 100644 --- a/src/util/server.c +++ b/src/util/server.c | |||
@@ -349,7 +349,6 @@ process_listen_socket (void *cls, | |||
349 | GNUNET_NETWORK_fdset_set (r, server->listen_socket); | 349 | GNUNET_NETWORK_fdset_set (r, server->listen_socket); |
350 | GNUNET_NETWORK_fdset_handle_set (r, shutpipe); | 350 | GNUNET_NETWORK_fdset_handle_set (r, shutpipe); |
351 | GNUNET_SCHEDULER_add_select (server->sched, | 351 | GNUNET_SCHEDULER_add_select (server->sched, |
352 | GNUNET_YES, | ||
353 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 352 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
354 | GNUNET_SCHEDULER_NO_TASK, | 353 | GNUNET_SCHEDULER_NO_TASK, |
355 | GNUNET_TIME_UNIT_FOREVER_REL, | 354 | GNUNET_TIME_UNIT_FOREVER_REL, |
@@ -475,7 +474,7 @@ GNUNET_SERVER_create (struct GNUNET_SCHEDULER_Handle *sched, | |||
475 | GNUNET_NETWORK_fdset_handle_set (r, | 474 | GNUNET_NETWORK_fdset_handle_set (r, |
476 | GNUNET_DISK_pipe_handle (ret->shutpipe, | 475 | GNUNET_DISK_pipe_handle (ret->shutpipe, |
477 | GNUNET_DISK_PIPE_END_READ)); | 476 | GNUNET_DISK_PIPE_END_READ)); |
478 | GNUNET_SCHEDULER_add_select (sched, GNUNET_YES, | 477 | GNUNET_SCHEDULER_add_select (sched, |
479 | GNUNET_SCHEDULER_PRIORITY_HIGH, | 478 | GNUNET_SCHEDULER_PRIORITY_HIGH, |
480 | GNUNET_SCHEDULER_NO_TASK, | 479 | GNUNET_SCHEDULER_NO_TASK, |
481 | GNUNET_TIME_UNIT_FOREVER_REL, r, NULL, | 480 | GNUNET_TIME_UNIT_FOREVER_REL, r, NULL, |
@@ -1167,7 +1166,6 @@ GNUNET_SERVER_receive_done (struct GNUNET_SERVER_Client *client, int success) | |||
1167 | if (GNUNET_YES != client->shutdown_now) | 1166 | if (GNUNET_YES != client->shutdown_now) |
1168 | { | 1167 | { |
1169 | GNUNET_SCHEDULER_add_continuation (client->server->sched, | 1168 | GNUNET_SCHEDULER_add_continuation (client->server->sched, |
1170 | GNUNET_NO, | ||
1171 | &restart_processing, | 1169 | &restart_processing, |
1172 | client, | 1170 | client, |
1173 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 1171 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
diff --git a/src/util/service.c b/src/util/service.c index 0a33809be..173c0f566 100644 --- a/src/util/service.c +++ b/src/util/service.c | |||
@@ -1068,6 +1068,22 @@ write_pid_file (struct GNUNET_SERVICE_Context *sctx, pid_t pid) | |||
1068 | 1068 | ||
1069 | 1069 | ||
1070 | /** | 1070 | /** |
1071 | * Task run during shutdown. | ||
1072 | * | ||
1073 | * @param cls unused | ||
1074 | * @param tc unused | ||
1075 | */ | ||
1076 | static void | ||
1077 | shutdown_task (void *cls, | ||
1078 | const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
1079 | { | ||
1080 | struct GNUNET_SERVER_Handle *server = cls; | ||
1081 | |||
1082 | GNUNET_SERVER_destroy (server); | ||
1083 | } | ||
1084 | |||
1085 | |||
1086 | /** | ||
1071 | * Initial task for the service. | 1087 | * Initial task for the service. |
1072 | */ | 1088 | */ |
1073 | static void | 1089 | static void |
@@ -1092,6 +1108,10 @@ service_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
1092 | sctx->ret = GNUNET_SYSERR; | 1108 | sctx->ret = GNUNET_SYSERR; |
1093 | return; | 1109 | return; |
1094 | } | 1110 | } |
1111 | GNUNET_SCHEDULER_add_delayed (tc->sched, | ||
1112 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
1113 | &shutdown_task, | ||
1114 | sctx->server); | ||
1095 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); | 1115 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); |
1096 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); | 1116 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); |
1097 | i = 0; | 1117 | i = 0; |
@@ -1249,6 +1269,7 @@ pid_file_delete (struct GNUNET_SERVICE_Context *sctx) | |||
1249 | GNUNET_free (pif); | 1269 | GNUNET_free (pif); |
1250 | } | 1270 | } |
1251 | 1271 | ||
1272 | |||
1252 | /** | 1273 | /** |
1253 | * Run a standard GNUnet service startup sequence (initialize loggers | 1274 | * Run a standard GNUnet service startup sequence (initialize loggers |
1254 | * and configuration, parse options). | 1275 | * and configuration, parse options). |
@@ -1258,8 +1279,6 @@ pid_file_delete (struct GNUNET_SERVICE_Context *sctx) | |||
1258 | * @param serviceName our service name | 1279 | * @param serviceName our service name |
1259 | * @param task main task of the service | 1280 | * @param task main task of the service |
1260 | * @param task_cls closure for task | 1281 | * @param task_cls closure for task |
1261 | * @param term termination task of the service | ||
1262 | * @param term_cls closure for term | ||
1263 | * @return GNUNET_SYSERR on error, GNUNET_OK | 1282 | * @return GNUNET_SYSERR on error, GNUNET_OK |
1264 | * if we shutdown nicely | 1283 | * if we shutdown nicely |
1265 | */ | 1284 | */ |
@@ -1268,7 +1287,7 @@ GNUNET_SERVICE_run (int argc, | |||
1268 | char *const *argv, | 1287 | char *const *argv, |
1269 | const char *serviceName, | 1288 | const char *serviceName, |
1270 | GNUNET_SERVICE_Main task, | 1289 | GNUNET_SERVICE_Main task, |
1271 | void *task_cls, GNUNET_SERVICE_Term term, void *term_cls) | 1290 | void *task_cls) |
1272 | { | 1291 | { |
1273 | char *cfg_fn; | 1292 | char *cfg_fn; |
1274 | char *loglev; | 1293 | char *loglev; |
@@ -1347,12 +1366,8 @@ GNUNET_SERVICE_run (int argc, | |||
1347 | } | 1366 | } |
1348 | 1367 | ||
1349 | /* shutdown */ | 1368 | /* shutdown */ |
1350 | if (term != NULL) | ||
1351 | term (term_cls, sctx.cfg); | ||
1352 | if ((do_daemonize == 1) && (sctx.server != NULL)) | 1369 | if ((do_daemonize == 1) && (sctx.server != NULL)) |
1353 | pid_file_delete (&sctx); | 1370 | pid_file_delete (&sctx); |
1354 | if (sctx.server != NULL) | ||
1355 | GNUNET_SERVER_destroy (sctx.server); | ||
1356 | GNUNET_free_non_null (sctx.my_handlers); | 1371 | GNUNET_free_non_null (sctx.my_handlers); |
1357 | GNUNET_CONFIGURATION_destroy (cfg); | 1372 | GNUNET_CONFIGURATION_destroy (cfg); |
1358 | GNUNET_free_non_null (sctx.addr); | 1373 | GNUNET_free_non_null (sctx.addr); |
@@ -1413,8 +1428,6 @@ GNUNET_SERVICE_start (const char *serviceName, | |||
1413 | while ((sctx->my_handlers[i].callback != NULL)) | 1428 | while ((sctx->my_handlers[i].callback != NULL)) |
1414 | sctx->my_handlers[i++].callback_cls = sctx; | 1429 | sctx->my_handlers[i++].callback_cls = sctx; |
1415 | GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers); | 1430 | GNUNET_SERVER_add_handlers (sctx->server, sctx->my_handlers); |
1416 | |||
1417 | |||
1418 | return sctx; | 1431 | return sctx; |
1419 | } | 1432 | } |
1420 | 1433 | ||
diff --git a/src/util/test_connection.c b/src/util/test_connection.c index 0f4c46b3b..07b5e843d 100644 --- a/src/util/test_connection.c +++ b/src/util/test_connection.c | |||
@@ -175,9 +175,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
175 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n"); | 175 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Test prepares to accept\n"); |
176 | #endif | 176 | #endif |
177 | GNUNET_SCHEDULER_add_read_net (tc->sched, | 177 | GNUNET_SCHEDULER_add_read_net (tc->sched, |
178 | GNUNET_NO, | ||
179 | GNUNET_SCHEDULER_PRIORITY_HIGH, | ||
180 | GNUNET_SCHEDULER_NO_TASK, | ||
181 | GNUNET_TIME_UNIT_FOREVER_REL, | 178 | GNUNET_TIME_UNIT_FOREVER_REL, |
182 | ls, &run_accept, cls); | 179 | ls, &run_accept, cls); |
183 | } | 180 | } |
diff --git a/src/util/test_connection_addressing.c b/src/util/test_connection_addressing.c index 1b85dfac6..d6ac309f7 100644 --- a/src/util/test_connection_addressing.c +++ b/src/util/test_connection_addressing.c | |||
@@ -169,9 +169,6 @@ task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
169 | &make_hello, NULL)); | 169 | &make_hello, NULL)); |
170 | GNUNET_CONNECTION_destroy (csock); | 170 | GNUNET_CONNECTION_destroy (csock); |
171 | GNUNET_SCHEDULER_add_read_net (tc->sched, | 171 | GNUNET_SCHEDULER_add_read_net (tc->sched, |
172 | GNUNET_NO, | ||
173 | GNUNET_SCHEDULER_PRIORITY_HIGH, | ||
174 | GNUNET_SCHEDULER_NO_TASK, | ||
175 | GNUNET_TIME_UNIT_FOREVER_REL, | 172 | GNUNET_TIME_UNIT_FOREVER_REL, |
176 | ls, &run_accept, cls); | 173 | ls, &run_accept, cls); |
177 | } | 174 | } |
diff --git a/src/util/test_connection_receive_cancel.c b/src/util/test_connection_receive_cancel.c index 5856e27ed..b90191384 100644 --- a/src/util/test_connection_receive_cancel.c +++ b/src/util/test_connection_receive_cancel.c | |||
@@ -124,15 +124,9 @@ task_receive_cancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
124 | "localhost", PORT, 1024); | 124 | "localhost", PORT, 1024); |
125 | GNUNET_assert (csock != NULL); | 125 | GNUNET_assert (csock != NULL); |
126 | GNUNET_SCHEDULER_add_read_net (tc->sched, | 126 | GNUNET_SCHEDULER_add_read_net (tc->sched, |
127 | GNUNET_NO, | ||
128 | GNUNET_SCHEDULER_PRIORITY_HIGH, | ||
129 | GNUNET_SCHEDULER_NO_TASK, | ||
130 | GNUNET_TIME_UNIT_FOREVER_REL, | 127 | GNUNET_TIME_UNIT_FOREVER_REL, |
131 | ls, &run_accept_cancel, cls); | 128 | ls, &run_accept_cancel, cls); |
132 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 129 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
133 | GNUNET_NO, | ||
134 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
135 | GNUNET_SCHEDULER_NO_TASK, | ||
136 | GNUNET_TIME_UNIT_SECONDS, | 130 | GNUNET_TIME_UNIT_SECONDS, |
137 | &receive_cancel_task, cls); | 131 | &receive_cancel_task, cls); |
138 | } | 132 | } |
diff --git a/src/util/test_crypto_hash.c b/src/util/test_crypto_hash.c index 97ef4ec88..b650355c0 100644 --- a/src/util/test_crypto_hash.c +++ b/src/util/test_crypto_hash.c | |||
@@ -124,7 +124,7 @@ file_hasher (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
124 | { | 124 | { |
125 | GNUNET_CRYPTO_hash_file (tc->sched, | 125 | GNUNET_CRYPTO_hash_file (tc->sched, |
126 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | 126 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, |
127 | GNUNET_NO, FILENAME, 1024, &finished_task, cls); | 127 | FILENAME, 1024, &finished_task, cls); |
128 | } | 128 | } |
129 | 129 | ||
130 | 130 | ||
diff --git a/src/util/test_scheduler.c b/src/util/test_scheduler.c index 98dce6f97..3021dce19 100644 --- a/src/util/test_scheduler.c +++ b/src/util/test_scheduler.c | |||
@@ -30,14 +30,6 @@ | |||
30 | #define VERBOSE GNUNET_NO | 30 | #define VERBOSE GNUNET_NO |
31 | 31 | ||
32 | static void | 32 | static void |
33 | task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
34 | { | ||
35 | int *ok = cls; | ||
36 | GNUNET_assert (2 == *ok); | ||
37 | (*ok) = 3; | ||
38 | } | ||
39 | |||
40 | static void | ||
41 | task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 33 | task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
42 | { | 34 | { |
43 | int *ok = cls; | 35 | int *ok = cls; |
@@ -48,6 +40,19 @@ task3 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
48 | (*ok) = 4; | 40 | (*ok) = 4; |
49 | } | 41 | } |
50 | 42 | ||
43 | |||
44 | static void | ||
45 | task2 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
46 | { | ||
47 | int *ok = cls; | ||
48 | GNUNET_assert (2 == *ok); | ||
49 | (*ok) = 3; | ||
50 | /* t3 will go before t4: higher priority */ | ||
51 | GNUNET_SCHEDULER_add_with_priority (tc->sched, | ||
52 | GNUNET_SCHEDULER_PRIORITY_UI, | ||
53 | &task3, cls); | ||
54 | } | ||
55 | |||
51 | static void | 56 | static void |
52 | task4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 57 | task4 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
53 | { | 58 | { |
@@ -96,14 +101,9 @@ taskRd (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
96 | GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0])); | 101 | GNUNET_assert (GNUNET_NETWORK_fdset_handle_isset (tc->read_ready, fds[0])); |
97 | GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1)); | 102 | GNUNET_assert (1 == GNUNET_DISK_file_read (fds[0], &c, 1)); |
98 | (*ok) = 8; | 103 | (*ok) = 8; |
99 | GNUNET_SCHEDULER_add_after (tc->sched, | 104 | GNUNET_SCHEDULER_add_with_priority (tc->sched, |
100 | GNUNET_NO, | 105 | GNUNET_SCHEDULER_PRIORITY_IDLE, |
101 | GNUNET_SCHEDULER_PRIORITY_UI, | 106 | &taskLast, cls); |
102 | 0, &taskNeverRun, NULL); | ||
103 | GNUNET_SCHEDULER_add_after (tc->sched, | ||
104 | GNUNET_YES, | ||
105 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
106 | 0, &taskLast, cls); | ||
107 | GNUNET_SCHEDULER_shutdown (tc->sched); | 107 | GNUNET_SCHEDULER_shutdown (tc->sched); |
108 | } | 108 | } |
109 | 109 | ||
@@ -119,15 +119,9 @@ task5 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
119 | fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ); | 119 | fds[0] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_READ); |
120 | fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE); | 120 | fds[1] = GNUNET_DISK_pipe_handle (p, GNUNET_DISK_PIPE_END_WRITE); |
121 | GNUNET_SCHEDULER_add_read_file (tc->sched, | 121 | GNUNET_SCHEDULER_add_read_file (tc->sched, |
122 | GNUNET_NO, | ||
123 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
124 | GNUNET_SCHEDULER_NO_TASK, | ||
125 | GNUNET_TIME_UNIT_FOREVER_REL, | 122 | GNUNET_TIME_UNIT_FOREVER_REL, |
126 | fds[0], &taskRd, cls); | 123 | fds[0], &taskRd, cls); |
127 | GNUNET_SCHEDULER_add_write_file (tc->sched, | 124 | GNUNET_SCHEDULER_add_write_file (tc->sched, |
128 | GNUNET_NO, | ||
129 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
130 | GNUNET_SCHEDULER_NO_TASK, | ||
131 | GNUNET_TIME_UNIT_FOREVER_REL, | 125 | GNUNET_TIME_UNIT_FOREVER_REL, |
132 | fds[1], &taskWrt, cls); | 126 | fds[1], &taskWrt, cls); |
133 | } | 127 | } |
@@ -144,24 +138,13 @@ task1 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
144 | (*ok) = 2; | 138 | (*ok) = 2; |
145 | /* t2 will go first -- prereq for all */ | 139 | /* t2 will go first -- prereq for all */ |
146 | t2 = GNUNET_SCHEDULER_add_after (tc->sched, | 140 | t2 = GNUNET_SCHEDULER_add_after (tc->sched, |
147 | GNUNET_NO, | ||
148 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
149 | GNUNET_SCHEDULER_NO_TASK, &task2, cls); | 141 | GNUNET_SCHEDULER_NO_TASK, &task2, cls); |
150 | /* t3 will go before t4: higher priority */ | 142 | /* t4 will go after t2 ('add after') and after t3 (priority) */ |
151 | t4 = GNUNET_SCHEDULER_add_after (tc->sched, | 143 | t4 = GNUNET_SCHEDULER_add_after (tc->sched, |
152 | GNUNET_NO, | ||
153 | GNUNET_SCHEDULER_PRIORITY_IDLE, | ||
154 | t2, &task4, cls); | 144 | t2, &task4, cls); |
155 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 145 | /* t5 will go last (after p4) */ |
156 | GNUNET_NO, | ||
157 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
158 | t2, | ||
159 | GNUNET_TIME_relative_get_zero (), | ||
160 | &task3, cls); | ||
161 | /* t4 will go first: lower prio, but prereq! */ | ||
162 | GNUNET_SCHEDULER_add_after (tc->sched, | 146 | GNUNET_SCHEDULER_add_after (tc->sched, |
163 | GNUNET_NO, | 147 | t4, &task5, cls); |
164 | GNUNET_SCHEDULER_PRIORITY_UI, t4, &task5, cls); | ||
165 | } | 148 | } |
166 | 149 | ||
167 | 150 | ||
@@ -182,20 +165,47 @@ check () | |||
182 | 165 | ||
183 | 166 | ||
184 | static void | 167 | static void |
168 | taskShutdown (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | ||
169 | { | ||
170 | int *ok = cls; | ||
171 | GNUNET_assert (1 == *ok); | ||
172 | *ok = 8; | ||
173 | GNUNET_SCHEDULER_add_delayed (tc->sched, | ||
174 | GNUNET_TIME_UNIT_FOREVER_REL, | ||
175 | &taskLast, cls); | ||
176 | GNUNET_SCHEDULER_shutdown (tc->sched); | ||
177 | } | ||
178 | |||
179 | |||
180 | /** | ||
181 | * Main method, starts scheduler with task1, | ||
182 | * checks that "ok" is correct at the end. | ||
183 | */ | ||
184 | static int | ||
185 | checkShutdown () | ||
186 | { | ||
187 | int ok; | ||
188 | |||
189 | ok = 1; | ||
190 | GNUNET_SCHEDULER_run (&taskShutdown, &ok); | ||
191 | return ok; | ||
192 | } | ||
193 | |||
194 | |||
195 | static void | ||
185 | taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 196 | taskSig (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
186 | { | 197 | { |
187 | int *ok = cls; | 198 | int *ok = cls; |
188 | GNUNET_assert (1 == *ok); | 199 | GNUNET_assert (1 == *ok); |
189 | *ok = 8; | 200 | *ok = 8; |
190 | GNUNET_SCHEDULER_add_after (tc->sched, | 201 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
191 | GNUNET_NO, | 202 | GNUNET_TIME_UNIT_FOREVER_REL, |
192 | GNUNET_SCHEDULER_PRIORITY_UI, | 203 | &taskLast, cls); |
193 | 0, &taskNeverRun, NULL); | 204 | #ifndef MINGW |
194 | GNUNET_SCHEDULER_add_after (tc->sched, | ||
195 | GNUNET_YES, | ||
196 | GNUNET_SCHEDULER_PRIORITY_UI, | ||
197 | 0, &taskLast, cls); | ||
198 | GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM)); | 205 | GNUNET_break (0 == PLIBC_KILL (getpid (), SIGTERM)); |
206 | #else | ||
207 | GNUNET_SCHEDULER_shutdown (tc->sched); | ||
208 | #endif | ||
199 | } | 209 | } |
200 | 210 | ||
201 | 211 | ||
@@ -214,8 +224,6 @@ checkSignal () | |||
214 | } | 224 | } |
215 | 225 | ||
216 | 226 | ||
217 | |||
218 | |||
219 | static void | 227 | static void |
220 | taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 228 | taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
221 | { | 229 | { |
@@ -225,9 +233,7 @@ taskCancel (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
225 | *ok = 0; | 233 | *ok = 0; |
226 | GNUNET_SCHEDULER_cancel (tc->sched, | 234 | GNUNET_SCHEDULER_cancel (tc->sched, |
227 | GNUNET_SCHEDULER_add_after (tc->sched, | 235 | GNUNET_SCHEDULER_add_after (tc->sched, |
228 | GNUNET_NO, | 236 | GNUNET_SCHEDULER_NO_TASK, |
229 | GNUNET_SCHEDULER_PRIORITY_UI, | ||
230 | 0, | ||
231 | &taskNeverRun, NULL)); | 237 | &taskNeverRun, NULL)); |
232 | } | 238 | } |
233 | 239 | ||
@@ -256,6 +262,7 @@ main (int argc, char *argv[]) | |||
256 | GNUNET_log_setup ("test_scheduler", "WARNING", NULL); | 262 | GNUNET_log_setup ("test_scheduler", "WARNING", NULL); |
257 | ret += check (); | 263 | ret += check (); |
258 | ret += checkSignal (); | 264 | ret += checkSignal (); |
265 | ret += checkShutdown (); | ||
259 | ret += checkCancel (); | 266 | ret += checkCancel (); |
260 | GNUNET_DISK_pipe_close (p); | 267 | GNUNET_DISK_pipe_close (p); |
261 | 268 | ||
diff --git a/src/util/test_scheduler_delay.c b/src/util/test_scheduler_delay.c index f5477fd4c..d1d61c3e4 100644 --- a/src/util/test_scheduler_delay.c +++ b/src/util/test_scheduler_delay.c | |||
@@ -66,9 +66,6 @@ test_task (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
66 | return; | 66 | return; |
67 | } | 67 | } |
68 | GNUNET_SCHEDULER_add_delayed (tc->sched, | 68 | GNUNET_SCHEDULER_add_delayed (tc->sched, |
69 | GNUNET_NO, | ||
70 | GNUNET_SCHEDULER_PRIORITY_DEFAULT, | ||
71 | GNUNET_SCHEDULER_NO_TASK, | ||
72 | GNUNET_TIME_relative_multiply | 69 | GNUNET_TIME_relative_multiply |
73 | (GNUNET_TIME_UNIT_MILLISECONDS, i), | 70 | (GNUNET_TIME_UNIT_MILLISECONDS, i), |
74 | &test_task, NULL); | 71 | &test_task, NULL); |
diff --git a/src/util/test_server.c b/src/util/test_server.c index ae5609de0..95206c0f1 100644 --- a/src/util/test_server.c +++ b/src/util/test_server.c | |||
@@ -100,9 +100,6 @@ my_receive (void *cls, | |||
100 | stctx->cb = receiver; | 100 | stctx->cb = receiver; |
101 | stctx->cb_cls = receiver_cls; | 101 | stctx->cb_cls = receiver_cls; |
102 | ret = GNUNET_SCHEDULER_add_delayed (sched, | 102 | ret = GNUNET_SCHEDULER_add_delayed (sched, |
103 | GNUNET_NO, | ||
104 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
105 | GNUNET_SCHEDULER_NO_TASK, | ||
106 | timeout, &signal_timeout, stctx); | 103 | timeout, &signal_timeout, stctx); |
107 | break; | 104 | break; |
108 | default: | 105 | default: |
diff --git a/src/util/test_server_disconnect.c b/src/util/test_server_disconnect.c index c5ce5e736..30fc34b08 100644 --- a/src/util/test_server_disconnect.c +++ b/src/util/test_server_disconnect.c | |||
@@ -95,9 +95,6 @@ recv_cb (void *cls, | |||
95 | case 2: | 95 | case 2: |
96 | ok++; | 96 | ok++; |
97 | GNUNET_SCHEDULER_add_delayed (sched, | 97 | GNUNET_SCHEDULER_add_delayed (sched, |
98 | GNUNET_YES, | ||
99 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
100 | GNUNET_SCHEDULER_NO_TASK, | ||
101 | GNUNET_TIME_relative_multiply | 98 | GNUNET_TIME_relative_multiply |
102 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), | 99 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), |
103 | &send_done, argclient); | 100 | &send_done, argclient); |
@@ -105,9 +102,6 @@ recv_cb (void *cls, | |||
105 | case 4: | 102 | case 4: |
106 | ok++; | 103 | ok++; |
107 | GNUNET_SCHEDULER_add_delayed (sched, | 104 | GNUNET_SCHEDULER_add_delayed (sched, |
108 | GNUNET_YES, | ||
109 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
110 | GNUNET_SCHEDULER_NO_TASK, | ||
111 | GNUNET_TIME_relative_multiply | 105 | GNUNET_TIME_relative_multiply |
112 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), | 106 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), |
113 | &server_disconnect, argclient); | 107 | &server_disconnect, argclient); |
diff --git a/src/util/test_server_with_client.c b/src/util/test_server_with_client.c index 508c505b1..860ed3837 100644 --- a/src/util/test_server_with_client.c +++ b/src/util/test_server_with_client.c | |||
@@ -87,9 +87,6 @@ recv_cb (void *cls, | |||
87 | case 2: | 87 | case 2: |
88 | ok++; | 88 | ok++; |
89 | GNUNET_SCHEDULER_add_delayed (sched, | 89 | GNUNET_SCHEDULER_add_delayed (sched, |
90 | GNUNET_YES, | ||
91 | GNUNET_SCHEDULER_PRIORITY_KEEP, | ||
92 | GNUNET_SCHEDULER_NO_TASK, | ||
93 | GNUNET_TIME_relative_multiply | 90 | GNUNET_TIME_relative_multiply |
94 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), | 91 | (GNUNET_TIME_UNIT_MILLISECONDS, 50), |
95 | &send_done, argclient); | 92 | &send_done, argclient); |
diff --git a/src/util/test_service.c b/src/util/test_service.c index 93cafb4d2..fa35da6e9 100644 --- a/src/util/test_service.c +++ b/src/util/test_service.c | |||
@@ -30,6 +30,7 @@ | |||
30 | #include "gnunet_scheduler_lib.h" | 30 | #include "gnunet_scheduler_lib.h" |
31 | #include "gnunet_time_lib.h" | 31 | #include "gnunet_time_lib.h" |
32 | 32 | ||
33 | |||
33 | #define VERBOSE GNUNET_NO | 34 | #define VERBOSE GNUNET_NO |
34 | 35 | ||
35 | #define PORT 12435 | 36 | #define PORT 12435 |
@@ -40,6 +41,9 @@ static struct GNUNET_SCHEDULER_Handle *sched; | |||
40 | 41 | ||
41 | static struct GNUNET_SERVICE_Context *sctx; | 42 | static struct GNUNET_SERVICE_Context *sctx; |
42 | 43 | ||
44 | static int ok = 1; | ||
45 | |||
46 | |||
43 | static void | 47 | static void |
44 | end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 48 | end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
45 | { | 49 | { |
@@ -47,8 +51,11 @@ end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | |||
47 | 51 | ||
48 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n"); | 52 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n"); |
49 | GNUNET_CLIENT_service_shutdown (client); | 53 | GNUNET_CLIENT_service_shutdown (client); |
50 | if (sctx != NULL) | 54 | if (sctx != NULL) |
51 | GNUNET_SERVICE_stop (sctx); | 55 | GNUNET_SERVICE_stop (sctx); |
56 | else | ||
57 | GNUNET_SCHEDULER_shutdown (sched); | ||
58 | ok = 0; | ||
52 | } | 59 | } |
53 | 60 | ||
54 | 61 | ||
@@ -63,7 +70,6 @@ build_msg (void *cls, size_t size, void *buf) | |||
63 | msg->type = htons (MY_TYPE); | 70 | msg->type = htons (MY_TYPE); |
64 | msg->size = htons (sizeof (struct GNUNET_MessageHeader)); | 71 | msg->size = htons (sizeof (struct GNUNET_MessageHeader)); |
65 | GNUNET_SCHEDULER_add_continuation (sched, | 72 | GNUNET_SCHEDULER_add_continuation (sched, |
66 | GNUNET_YES, | ||
67 | &end_it, | 73 | &end_it, |
68 | client, | 74 | client, |
69 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); | 75 | GNUNET_SCHEDULER_REASON_PREREQ_DONE); |
@@ -103,6 +109,9 @@ static struct GNUNET_SERVER_MessageHandler myhandlers[] = { | |||
103 | {NULL, NULL, 0, 0} | 109 | {NULL, NULL, 0, 0} |
104 | }; | 110 | }; |
105 | 111 | ||
112 | |||
113 | |||
114 | |||
106 | static void | 115 | static void |
107 | runner (void *cls, | 116 | runner (void *cls, |
108 | struct GNUNET_SCHEDULER_Handle *sched, | 117 | struct GNUNET_SCHEDULER_Handle *sched, |
@@ -117,12 +126,6 @@ runner (void *cls, | |||
117 | (void *) cfg); | 126 | (void *) cfg); |
118 | } | 127 | } |
119 | 128 | ||
120 | static void | ||
121 | term (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) | ||
122 | { | ||
123 | int *ok = cls; | ||
124 | *ok = 0; | ||
125 | } | ||
126 | 129 | ||
127 | /** | 130 | /** |
128 | * Main method, starts scheduler with task1, | 131 | * Main method, starts scheduler with task1, |
@@ -131,7 +134,7 @@ term (void *cls, const struct GNUNET_CONFIGURATION_Handle *cfg) | |||
131 | static int | 134 | static int |
132 | check () | 135 | check () |
133 | { | 136 | { |
134 | int ok = 1; | 137 | ok = 1; |
135 | char *const argv[] = { | 138 | char *const argv[] = { |
136 | "test_service", | 139 | "test_service", |
137 | "-c", | 140 | "-c", |
@@ -149,12 +152,12 @@ check () | |||
149 | GNUNET_SERVICE_run (5, | 152 | GNUNET_SERVICE_run (5, |
150 | argv, | 153 | argv, |
151 | "test_service", | 154 | "test_service", |
152 | &runner, &ok, &term, &ok)); | 155 | &runner, &ok)); |
153 | GNUNET_assert (0 == ok); | 156 | GNUNET_assert (0 == ok); |
154 | return ok; | 157 | return ok; |
155 | } | 158 | } |
156 | 159 | ||
157 | static void | 160 | static void |
158 | ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) | 161 | ready6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) |
159 | { | 162 | { |
160 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; | 163 | const struct GNUNET_CONFIGURATION_Handle *cfg = cls; |
@@ -193,7 +196,6 @@ runner6 (void *cls, | |||
193 | static int | 196 | static int |
194 | check6 () | 197 | check6 () |
195 | { | 198 | { |
196 | int ok = 1; | ||
197 | char *const argv[] = { | 199 | char *const argv[] = { |
198 | "test_service6", | 200 | "test_service6", |
199 | "-c", | 201 | "-c", |
@@ -211,7 +213,7 @@ check6 () | |||
211 | GNUNET_SERVICE_run (5, | 213 | GNUNET_SERVICE_run (5, |
212 | argv, | 214 | argv, |
213 | "test_service6", | 215 | "test_service6", |
214 | &runner6, &ok, &term, &ok)); | 216 | &runner6, &ok)); |
215 | GNUNET_assert (0 == ok); | 217 | GNUNET_assert (0 == ok); |
216 | return ok; | 218 | return ok; |
217 | } | 219 | } |
@@ -224,7 +226,7 @@ check6 () | |||
224 | static int | 226 | static int |
225 | check6d () | 227 | check6d () |
226 | { | 228 | { |
227 | int ok = 1; | 229 | ok = 1; |
228 | char *const argv[] = { | 230 | char *const argv[] = { |
229 | "test_service6", | 231 | "test_service6", |
230 | "-c", | 232 | "-c", |
@@ -243,7 +245,7 @@ check6d () | |||
243 | GNUNET_SERVICE_run (6, | 245 | GNUNET_SERVICE_run (6, |
244 | argv, | 246 | argv, |
245 | "test_service6", | 247 | "test_service6", |
246 | &runner6, &ok, &term, &ok)); | 248 | &runner6, &ok)); |
247 | GNUNET_break (0 == ok); | 249 | GNUNET_break (0 == ok); |
248 | return ok; | 250 | return ok; |
249 | } | 251 | } |