From f6bad19e765e73886a1e5b6d32f0a7551e5757ba Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Tue, 11 May 2010 13:16:00 +0000 Subject: moving code where it belongs: --- src/arm/arm_api.c | 206 +++++++++++++++++++++++++++++++++++- src/arm/test_exponential_backoff.c | 211 ++++++++++++++++++++++++++++++++++++- src/include/gnunet_client_lib.h | 23 ---- src/util/client.c | 202 ----------------------------------- src/util/test_service.c | 18 ++-- 5 files changed, 418 insertions(+), 242 deletions(-) (limited to 'src') diff --git a/src/arm/arm_api.c b/src/arm/arm_api.c index ee53fd87b..f15c9ab53 100644 --- a/src/arm/arm_api.c +++ b/src/arm/arm_api.c @@ -64,6 +64,206 @@ struct GNUNET_ARM_Handle }; +/** + * Context for handling the shutdown of a service. + */ +struct ShutdownContext +{ + /** + * Scheduler to be used to call continuation + */ + struct GNUNET_SCHEDULER_Handle *sched; + /** + * Connection to the service that is being shutdown. + */ + struct GNUNET_CLIENT_Connection *sock; + + /** + * Time allowed for shutdown to happen. + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * Task set up to cancel the shutdown request on timeout. + */ + GNUNET_SCHEDULER_TaskIdentifier cancel_task; + + /** + * Task to call once shutdown complete + */ + GNUNET_CLIENT_ShutdownTask cont; + + /** + * Closure for shutdown continuation + */ + void *cont_cls; + + /** + * We received a confirmation that the service will shut down. + */ + int confirmed; + +}; + +/** + * Handler receiving response to service shutdown requests. + * First call with NULL: service misbehaving, or something. + * First call with GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK: + * - service will shutdown + * Second call with NULL: + * - service has now really shut down. + * + * @param cls closure + * @param msg NULL, indicating socket closure. + */ +static void +service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg) +{ + struct ShutdownContext *shutdown_ctx = cls; + + if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES)) + { + /* Means the other side closed the connection and never confirmed a shutdown */ + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Service handle shutdown before ACK!\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + } + else if ((msg == NULL) && (shutdown_ctx->confirmed == GNUNET_YES)) + { + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Service shutdown complete.\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO); + + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + } + else + { + GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader)); + switch (ntohs(msg->type)) + { + case GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK: + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Received confirmation for service shutdown.\n"); + shutdown_ctx->confirmed = GNUNET_YES; + GNUNET_CLIENT_receive (shutdown_ctx->sock, + &service_shutdown_handler, + shutdown_ctx, + GNUNET_TIME_UNIT_FOREVER_REL); + break; + default: /* Fall through */ + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Service shutdown refused!\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES); + + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + break; + } + } +} + +/** + * Shutting down took too long, cancel receive and return error. + * + * @param cls closure + * @param tc context information (why was this task triggered now) + */ +void service_shutdown_cancel (void *cls, + const struct GNUNET_SCHEDULER_TaskContext * tc) +{ + struct ShutdownContext *shutdown_ctx = cls; + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n"); + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); +} + + +/** + * If possible, write a shutdown message to the target + * buffer and destroy the client connection. + * + * @param cls the "struct GNUNET_CLIENT_Connection" to destroy + * @param size number of bytes available in buf + * @param buf NULL on error, otherwise target buffer + * @return number of bytes written to buf + */ +static size_t +write_shutdown (void *cls, size_t size, void *buf) +{ + struct GNUNET_MessageHeader *msg; + struct ShutdownContext *shutdown_ctx = cls; + + if (size < sizeof (struct GNUNET_MessageHeader)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Failed to transmit shutdown request to client.\n")); + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + return 0; /* client disconnected */ + } + + GNUNET_CLIENT_receive (shutdown_ctx->sock, + &service_shutdown_handler, shutdown_ctx, + GNUNET_TIME_UNIT_FOREVER_REL); + shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, + GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout), + &service_shutdown_cancel, + shutdown_ctx); + msg = (struct GNUNET_MessageHeader *) buf; + msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN); + msg->size = htons (sizeof (struct GNUNET_MessageHeader)); + return sizeof (struct GNUNET_MessageHeader); +} + + +/** + * Request that the service should shutdown. + * Afterwards, the connection will automatically be + * disconnected. Hence the "sock" should not + * be used by the caller after this call + * (calling this function frees "sock" after a while). + * + * @param sched the scheduler to use for calling shutdown continuation + * @param sock the socket connected to the service + * @param timeout how long to wait before giving up on transmission + * @param cont continuation to call once the service is really down + * @param cont_cls closure for continuation + * + */ +static void +arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched, + struct GNUNET_CLIENT_Connection *sock, + struct GNUNET_TIME_Relative timeout, + GNUNET_CLIENT_ShutdownTask cont, + void *cont_cls) +{ + struct ShutdownContext *shutdown_ctx; + shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext)); + shutdown_ctx->sched = sched; + shutdown_ctx->cont = cont; + shutdown_ctx->cont_cls = cont_cls; + shutdown_ctx->sock = sock; + shutdown_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout); + GNUNET_CLIENT_notify_transmit_ready (sock, + sizeof (struct + GNUNET_MessageHeader), + timeout, + GNUNET_NO, + &write_shutdown, shutdown_ctx); +} + + /** * Setup a context for communicating with ARM. Note that this * can be done even if the ARM service is not yet running. @@ -498,7 +698,7 @@ GNUNET_ARM_stop_service (struct GNUNET_ARM_Handle *h, arm_shutdown_ctx = GNUNET_malloc(sizeof(struct ARM_ShutdownContext)); arm_shutdown_ctx->cb = cb; arm_shutdown_ctx->cb_cls = cb_cls; - GNUNET_CLIENT_service_shutdown (h->sched, h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx); + arm_service_shutdown (h->sched, h->client, timeout, &arm_shutdown_callback, arm_shutdown_ctx); h->client = NULL; return; } @@ -669,4 +869,8 @@ GNUNET_ARM_stop_services (const struct GNUNET_CONFIGURATION_Handle *cfg, } + + + + /* end of arm_api.c */ diff --git a/src/arm/test_exponential_backoff.c b/src/arm/test_exponential_backoff.c index 8657563fc..0ff0ebdad 100644 --- a/src/arm/test_exponential_backoff.c +++ b/src/arm/test_exponential_backoff.c @@ -26,6 +26,7 @@ #include "gnunet_client_lib.h" #include "gnunet_configuration_lib.h" #include "gnunet_program_lib.h" +#include "gnunet_protocols.h" #define VERBOSE GNUNET_NO #define START_ARM GNUNET_YES @@ -49,6 +50,206 @@ static char *killLogFileName; #endif +/** + * Context for handling the shutdown of a service. + */ +struct ShutdownContext +{ + /** + * Scheduler to be used to call continuation + */ + struct GNUNET_SCHEDULER_Handle *sched; + /** + * Connection to the service that is being shutdown. + */ + struct GNUNET_CLIENT_Connection *sock; + + /** + * Time allowed for shutdown to happen. + */ + struct GNUNET_TIME_Absolute timeout; + + /** + * Task set up to cancel the shutdown request on timeout. + */ + GNUNET_SCHEDULER_TaskIdentifier cancel_task; + + /** + * Task to call once shutdown complete + */ + GNUNET_CLIENT_ShutdownTask cont; + + /** + * Closure for shutdown continuation + */ + void *cont_cls; + + /** + * We received a confirmation that the service will shut down. + */ + int confirmed; + +}; + +/** + * Handler receiving response to service shutdown requests. + * First call with NULL: service misbehaving, or something. + * First call with GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK: + * - service will shutdown + * Second call with NULL: + * - service has now really shut down. + * + * @param cls closure + * @param msg NULL, indicating socket closure. + */ +static void +service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg) +{ + struct ShutdownContext *shutdown_ctx = cls; + + if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES)) + { + /* Means the other side closed the connection and never confirmed a shutdown */ + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Service handle shutdown before ACK!\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + } + else if ((msg == NULL) && (shutdown_ctx->confirmed == GNUNET_YES)) + { + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Service shutdown complete.\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO); + + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + } + else + { + GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader)); + switch (ntohs(msg->type)) + { + case GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN_ACK: + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Received confirmation for service shutdown.\n"); + shutdown_ctx->confirmed = GNUNET_YES; + GNUNET_CLIENT_receive (shutdown_ctx->sock, + &service_shutdown_handler, + shutdown_ctx, + GNUNET_TIME_UNIT_FOREVER_REL); + break; + default: /* Fall through */ + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, + "Service shutdown refused!\n"); + if (shutdown_ctx->cont != NULL) + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES); + + GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + break; + } + } +} + +/** + * Shutting down took too long, cancel receive and return error. + * + * @param cls closure + * @param tc context information (why was this task triggered now) + */ +void service_shutdown_cancel (void *cls, + const struct GNUNET_SCHEDULER_TaskContext * tc) +{ + struct ShutdownContext *shutdown_ctx = cls; + GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n"); + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); +} + + +/** + * If possible, write a shutdown message to the target + * buffer and destroy the client connection. + * + * @param cls the "struct GNUNET_CLIENT_Connection" to destroy + * @param size number of bytes available in buf + * @param buf NULL on error, otherwise target buffer + * @return number of bytes written to buf + */ +static size_t +write_shutdown (void *cls, size_t size, void *buf) +{ + struct GNUNET_MessageHeader *msg; + struct ShutdownContext *shutdown_ctx = cls; + + if (size < sizeof (struct GNUNET_MessageHeader)) + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + _("Failed to transmit shutdown request to client.\n")); + shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); + GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); + GNUNET_free(shutdown_ctx); + return 0; /* client disconnected */ + } + + GNUNET_CLIENT_receive (shutdown_ctx->sock, + &service_shutdown_handler, shutdown_ctx, + GNUNET_TIME_UNIT_FOREVER_REL); + shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, + GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout), + &service_shutdown_cancel, + shutdown_ctx); + msg = (struct GNUNET_MessageHeader *) buf; + msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN); + msg->size = htons (sizeof (struct GNUNET_MessageHeader)); + return sizeof (struct GNUNET_MessageHeader); +} + + +/** + * Request that the service should shutdown. + * Afterwards, the connection will automatically be + * disconnected. Hence the "sock" should not + * be used by the caller after this call + * (calling this function frees "sock" after a while). + * + * @param sched the scheduler to use for calling shutdown continuation + * @param sock the socket connected to the service + * @param timeout how long to wait before giving up on transmission + * @param cont continuation to call once the service is really down + * @param cont_cls closure for continuation + * + */ +static void +arm_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched, + struct GNUNET_CLIENT_Connection *sock, + struct GNUNET_TIME_Relative timeout, + GNUNET_CLIENT_ShutdownTask cont, + void *cont_cls) +{ + struct ShutdownContext *shutdown_ctx; + shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext)); + shutdown_ctx->sched = sched; + shutdown_ctx->cont = cont; + shutdown_ctx->cont_cls = cont_cls; + shutdown_ctx->sock = sock; + shutdown_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout); + GNUNET_CLIENT_notify_transmit_ready (sock, + sizeof (struct + GNUNET_MessageHeader), + timeout, + GNUNET_NO, + &write_shutdown, shutdown_ctx); +} + + static void arm_notify_stop (void *cls, int success) { @@ -141,6 +342,8 @@ shutdown_cont (void *cls, int reason) &do_test, NULL); } + + static void kill_task (void *cbData, const struct GNUNET_SCHEDULER_TaskContext *tc) @@ -178,10 +381,10 @@ kill_task (void *cbData, } /* Use the created connection to kill the doNothingTask */ - GNUNET_CLIENT_service_shutdown(sched, - doNothingConnection, - TIMEOUT, - &shutdown_cont, NULL); + arm_service_shutdown(sched, + doNothingConnection, + TIMEOUT, + &shutdown_cont, NULL); } diff --git a/src/include/gnunet_client_lib.h b/src/include/gnunet_client_lib.h index 56f6915a4..49ccc6c6b 100644 --- a/src/include/gnunet_client_lib.h +++ b/src/include/gnunet_client_lib.h @@ -207,29 +207,6 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *sock, void *rn_cls); - -/** - * Request that the service should shutdown. - * Afterwards, the connection will automatically be - * disconnected. Hence the "sock" shoud not - * be used by the caller after this call - * (calling this function frees "sock" after a while). - * - * @param sched the scheduler to use for calling shutdown continuation - * @param sock the socket connected to the service - * @param timeout how long to wait before giving up on transmission - * @param cont continuation to call once the service is really down - * @param cont_cls closure for continuation - * - */ -void -GNUNET_CLIENT_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched, - struct GNUNET_CLIENT_Connection *sock, - struct GNUNET_TIME_Relative timeout, - GNUNET_CLIENT_ShutdownTask cont, - void *cont_cls); - - /** * Wait until the service is running. * diff --git a/src/util/client.c b/src/util/client.c index c87d239e6..8a93bae9b 100644 --- a/src/util/client.c +++ b/src/util/client.c @@ -136,47 +136,6 @@ struct TransmitGetResponseContext void *rn_cls; }; -/** - * Context for handling the shutdown of a service. - */ -struct ShutdownContext -{ - /** - * Scheduler to be used to call continuation - */ - struct GNUNET_SCHEDULER_Handle *sched; - /** - * Connection to the service that is being shutdown. - */ - struct GNUNET_CLIENT_Connection *sock; - - /** - * Time allowed for shutdown to happen. - */ - struct GNUNET_TIME_Absolute timeout; - - /** - * Task set up to cancel the shutdown request on timeout. - */ - GNUNET_SCHEDULER_TaskIdentifier cancel_task; - - /** - * Task to call once shutdown complete - */ - GNUNET_CLIENT_ShutdownTask cont; - - /** - * Closure for shutdown continuation - */ - void *cont_cls; - - /** - * We received a confirmation that the service will shut down. - */ - int confirmed; - -}; - /** * Struct to refer to a GNUnet TCP connection. * This is more than just a socket because if the server @@ -580,167 +539,6 @@ GNUNET_CLIENT_receive (struct GNUNET_CLIENT_Connection *sock, } -/** - * Handler receiving response to service shutdown requests. - * First call with NULL: service misbehaving, or something. - * First call with GNUNET_MESSAGE_TYPE_SHUTDOWN_ACK: - * - service will shutdown - * First call with GNUNET_MESSAGE_TYPE_SHUTDOWN_REFUSE: - * - service will not be stopped! - * - * Second call with NULL: - * - service has now really shut down. - * - * @param cls closure - * @param msg NULL, indicating socket closure. - */ -static void -service_shutdown_handler (void *cls, const struct GNUNET_MessageHeader *msg) -{ - struct ShutdownContext *shutdown_ctx = cls; - - if ((msg == NULL) && (shutdown_ctx->confirmed != GNUNET_YES)) - { - /* Means the other side closed the connection and never confirmed a shutdown */ - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - "Service handle shutdown before ACK!\n"); - if (shutdown_ctx->cont != NULL) - shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); - GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); - GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); - GNUNET_free(shutdown_ctx); - } - else if ((msg == NULL) && (shutdown_ctx->confirmed == GNUNET_YES)) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Service shutdown complete.\n"); - if (shutdown_ctx->cont != NULL) - shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_NO); - - GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); - GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); - GNUNET_free(shutdown_ctx); - } - else - { - GNUNET_assert(ntohs(msg->size) == sizeof(struct GNUNET_MessageHeader)); - switch (ntohs(msg->type)) - { - case GNUNET_MESSAGE_TYPE_SHUTDOWN_ACK: - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Received confirmation for service shutdown.\n"); - shutdown_ctx->confirmed = GNUNET_YES; - GNUNET_CLIENT_receive (shutdown_ctx->sock, - &service_shutdown_handler, - shutdown_ctx, - GNUNET_TIME_UNIT_FOREVER_REL); - break; - default: /* Fall through */ - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Service shutdown refused!\n"); - if (shutdown_ctx->cont != NULL) - shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_YES); - - GNUNET_SCHEDULER_cancel(shutdown_ctx->sched, shutdown_ctx->cancel_task); - GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); - GNUNET_free(shutdown_ctx); - break; - } - } -} - -/** - * Shutting down took too long, cancel receive and return error. - * - * @param cls closure - * @param tc context information (why was this task triggered now) - */ -void service_shutdown_cancel (void *cls, - const struct GNUNET_SCHEDULER_TaskContext * tc) -{ - struct ShutdownContext *shutdown_ctx = cls; - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, "service_shutdown_cancel called!\n"); - shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); - GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); - GNUNET_free(shutdown_ctx); -} - - -/** - * If possible, write a shutdown message to the target - * buffer and destroy the client connection. - * - * @param cls the "struct GNUNET_CLIENT_Connection" to destroy - * @param size number of bytes available in buf - * @param buf NULL on error, otherwise target buffer - * @return number of bytes written to buf - */ -static size_t -write_shutdown (void *cls, size_t size, void *buf) -{ - struct GNUNET_MessageHeader *msg; - struct ShutdownContext *shutdown_ctx = cls; - - if (size < sizeof (struct GNUNET_MessageHeader)) - { - GNUNET_log (GNUNET_ERROR_TYPE_WARNING, - _("Failed to transmit shutdown request to client.\n")); - shutdown_ctx->cont(shutdown_ctx->cont_cls, GNUNET_SYSERR); - GNUNET_CLIENT_disconnect (shutdown_ctx->sock, GNUNET_NO); - GNUNET_free(shutdown_ctx); - return 0; /* client disconnected */ - } - - GNUNET_CLIENT_receive (shutdown_ctx->sock, - &service_shutdown_handler, shutdown_ctx, - GNUNET_TIME_UNIT_FOREVER_REL); - shutdown_ctx->cancel_task = GNUNET_SCHEDULER_add_delayed (shutdown_ctx->sched, - GNUNET_TIME_absolute_get_remaining(shutdown_ctx->timeout), - &service_shutdown_cancel, - shutdown_ctx); - msg = (struct GNUNET_MessageHeader *) buf; - msg->type = htons (GNUNET_MESSAGE_TYPE_ARM_SHUTDOWN); - msg->size = htons (sizeof (struct GNUNET_MessageHeader)); - return sizeof (struct GNUNET_MessageHeader); -} - - -/** - * Request that the service should shutdown. - * Afterwards, the connection will automatically be - * disconnected. Hence the "sock" should not - * be used by the caller after this call - * (calling this function frees "sock" after a while). - * - * @param sched the scheduler to use for calling shutdown continuation - * @param sock the socket connected to the service - * @param timeout how long to wait before giving up on transmission - * @param cont continuation to call once the service is really down - * @param cont_cls closure for continuation - * - */ -void -GNUNET_CLIENT_service_shutdown (struct GNUNET_SCHEDULER_Handle *sched, - struct GNUNET_CLIENT_Connection *sock, - struct GNUNET_TIME_Relative timeout, - GNUNET_CLIENT_ShutdownTask cont, - void *cont_cls) -{ - struct ShutdownContext *shutdown_ctx; - shutdown_ctx = GNUNET_malloc(sizeof(struct ShutdownContext)); - shutdown_ctx->sched = sched; - shutdown_ctx->cont = cont; - shutdown_ctx->cont_cls = cont_cls; - shutdown_ctx->sock = sock; - shutdown_ctx->timeout = GNUNET_TIME_relative_to_absolute(timeout); - GNUNET_CONNECTION_notify_transmit_ready (sock->sock, - sizeof (struct - GNUNET_MessageHeader), - timeout, - &write_shutdown, shutdown_ctx); -} - - /** * Report service unavailable. */ diff --git a/src/util/test_service.c b/src/util/test_service.c index 544f86fba..5f3146205 100644 --- a/src/util/test_service.c +++ b/src/util/test_service.c @@ -43,24 +43,18 @@ static struct GNUNET_SERVICE_Context *sctx; static int ok = 1; -void -end_cont (void *cls, - int reason) -{ - if (sctx != NULL) - GNUNET_SERVICE_stop (sctx); - else - GNUNET_SCHEDULER_shutdown (sched); - ok = 0; -} - static void end_it (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc) { struct GNUNET_CLIENT_Connection *client = cls; GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Shutting down service\n"); - GNUNET_CLIENT_service_shutdown (sched, client, GNUNET_TIME_UNIT_FOREVER_REL, &end_cont, NULL); + GNUNET_CLIENT_disconnect (client, GNUNET_NO); + if (sctx != NULL) + { + GNUNET_SERVICE_stop (sctx); + sctx = NULL; + } } -- cgit v1.2.3