Fix argument order for async callbacks

diff --git a/src/lib/server/xlat.h b/src/lib/server/xlat.h
index 4c664ab6e4df5cde23a30bd74e0c59a94ec4a792..052d5df7745d88fc8c52a3fc37a6d041f83b852f 100644 (file)
--- a/src/lib/server/xlat.h
+++ b/src/lib/server/xlat.h
@@ -85,12 +85,12 @@ typedef size_t (*xlat_escape_t)(REQUEST *request, char *out, size_t outlen, char
  *     on a registered FD occurs before the timeout event fires.
  *
  * @param[in] request          the request.
- * @param[in] instance         the xlat instance.
- * @param[in] thread           data specific to this xlat instance.
+ * @param[in] xlat_inst                the xlat instance.
+ * @param[in] xlat_thread_inst data specific to this xlat instance.
  * @param[in] rctx             Resume ctx provided when the xlat last yielded.
  * @param[in] fired            the time the timeout event actually fired.
  */
-typedef        void (*fr_unlang_xlat_timeout_t)(REQUEST *request, void *instance, void *thread, void *rctx,
+typedef        void (*fr_unlang_xlat_timeout_t)(REQUEST *request, void *xlat_inst, void *xlat_thread_inst, void *rctx,
                                         struct timeval *fired);
 
 /** A callback when the FD is ready for reading

diff --git a/src/lib/unlang/module.c b/src/lib/unlang/module.c
index 94b548e948e3d8254d1d8a398e31ede87448e786..94de64525e98284bc6b4227bc36c54390e7df429 100644 (file)
--- a/src/lib/unlang/module.c
+++ b/src/lib/unlang/module.c
@@ -623,7 +623,7 @@ static unlang_action_t unlang_module(REQUEST *request, rlm_rcode_t *presult, int
        caller = request->module;
        request->module = sp->module_instance->name;
        safe_lock(sp->module_instance); /* Noop unless instance->mutex set */
-       rcode = sp->method(sp->module_instance->dl_inst->data, ms->thread->data, request);
+       rcode = sp->method(request, sp->module_instance->dl_inst->data, ms->thread->data);
        safe_unlock(sp->module_instance);
        request->module = caller;
 
@@ -715,8 +715,7 @@ static void unlang_module_signal(REQUEST *request, void *rctx, fr_state_signal_t
 
        caller = request->module;
        request->module = mc->module_instance->name;
-       ((fr_unlang_module_signal_t)mr->signal)(request,
-                                               mc->module_instance->dl_inst->data, ms->thread->data,
+       ((fr_unlang_module_signal_t)mr->signal)(mc->module_instance->dl_inst->data, ms->thread->data, request,
                                                rctx, action);
        request->module = caller;
 }
@@ -744,9 +743,8 @@ static unlang_action_t unlang_module_resume(REQUEST *request, rlm_rcode_t *presu
        caller = request->module;
        request->module = mc->module_instance->name;
        safe_lock(mc->module_instance);
-       rcode = request->rcode = ((fr_unlang_module_resume_t)mr->resume)(request,
-                                                                        mc->module_instance->dl_inst->data,
-                                                                        ms->thread->data, mr->rctx);
+       rcode = request->rcode = ((fr_unlang_module_resume_t)mr->resume)(mc->module_instance->dl_inst->data,
+                                                                        ms->thread->data, request, mr->rctx);
        safe_unlock(mc->module_instance);
        request->module = caller;
 

diff --git a/src/lib/unlang/module.h b/src/lib/unlang/module.h
index 604a7d55357d455cdfe363401b62502478d9c53f..6c459fb2ab49b40b99e74e7bdd9cc51b30598a72 100644 (file)
--- a/src/lib/unlang/module.h
+++ b/src/lib/unlang/module.h
@@ -40,13 +40,13 @@ extern "C" {
  * @note The callback is automatically removed on unlang_interpret_resumable(), i.e. if an event
  *     on a registered FD occurs before the timeout event fires.
  *
- * @param[in] request          the request.
  * @param[in] instance         the module instance.
  * @param[in] thread           data specific to this module instance.
  * @param[in] rctx             a local context for the callback.
+ * @param[in] request          the request.
  * @param[in] fired            the time the timeout event actually fired.
  */
-typedef        void (*fr_unlang_module_timeout_t)(REQUEST *request, void *instance, void *thread, void *rctx,
+typedef        void (*fr_unlang_module_timeout_t)(void *instance, void *thread, REQUEST *request, void *rctx,
                                           struct timeval *fired);
 
 /** A callback when the FD is ready for reading
@@ -56,25 +56,25 @@ typedef     void (*fr_unlang_module_timeout_t)(REQUEST *request, void *instance, voi
  *
  * @note The callback is automatically removed on unlang_interpret_resumable(), so
  *
- * @param[in] request          the current request.
  * @param[in] instance         the module instance.
  * @param[in] thread           data specific to this module instance.
+ * @param[in] request          the current request.
  * @param[in] rctx             a local context for the callback.
  * @param[in] fd               the file descriptor.
  */
-typedef void (*fr_unlang_module_fd_event_t)(REQUEST *request, void *instance, void *thread, void *rctx, int fd);
+typedef void (*fr_unlang_module_fd_event_t)(void *instance, void *thread, REQUEST *request, void *rctx, int fd);
 
 /** A callback for when the request is resumed.
  *
  * The resumed request cannot call the normal "authorize", etc. method.  It needs a separate callback.
  *
- * @param[in] request          the current request.
  * @param[in] instance         The module instance.
  * @param[in] thread           data specific to this module instance.
+ * @param[in] request          the current request.
  * @param[in] rctx             a local context for the callback.
  * @return a normal rlm_rcode_t.
  */
-typedef rlm_rcode_t (*fr_unlang_module_resume_t)(REQUEST *request, void *instance, void *thread, void *rctx);
+typedef rlm_rcode_t (*fr_unlang_module_resume_t)(void *instance, void *thread, REQUEST *request, void *rctx);
 
 /** A callback when the request gets a fr_state_signal_t.
  *
@@ -83,13 +83,13 @@ typedef rlm_rcode_t (*fr_unlang_module_resume_t)(REQUEST *request, void *instanc
  *
  * @note The callback is automatically removed on unlang_interpret_resumable().
  *
- * @param[in] request          The current request.
  * @param[in] instance         The module instance.
  * @param[in] thread           data specific to this module instance.
  * @param[in] rctx             Resume ctx for the callback.
+ * @param[in] request          The current request.
  * @param[in] action           which is signalling the request.
  */
-typedef void (*fr_unlang_module_signal_t)(REQUEST *request, void *instance, void *thread,
+typedef void (*fr_unlang_module_signal_t)(void *instance, void *thread, REQUEST *request,
                                          void *rctx, fr_state_signal_t action);
 
 int            unlang_module_timeout_add(REQUEST *request, fr_unlang_module_timeout_t callback,

diff --git a/src/modules/rlm_delay/rlm_delay.c b/src/modules/rlm_delay/rlm_delay.c
index 0e32a0cca6bb92ce18d7372519e6d26e9c6c6424..a63bcb41a6c2b4a9badc9a6b220de6bdd87b389d 100644 (file)
--- a/src/modules/rlm_delay/rlm_delay.c
+++ b/src/modules/rlm_delay/rlm_delay.c
@@ -51,13 +51,29 @@ static const CONF_PARSER module_config[] = {
  *
  * Marks the request as resumable, and prints the delayed delay time.
  *
- * @param[in] request          The current request.
  * @param[in] instance         This instance of the delay module.
  * @param[in] thread           Thread specific module instance.
+ * @param[in] request          The current request.
  * @param[in] rctx             Scheduled end of the delay.
  * @param[in] fired            When request processing was resumed.
  */
-static void _delay_done(REQUEST *request, UNUSED void *instance, UNUSED void *thread, void *rctx, struct timeval *fired)
+static void _delay_done(UNUSED void *instance, UNUSED void *thread, REQUEST *request, void *rctx, struct timeval *fired)
+{
+       struct timeval *yielded = talloc_get_type_abort(rctx, struct timeval);
+
+       RDEBUG2("Delay done");
+
+       /*
+        *      timeout should never be *before* the scheduled time,
+        *      if it is, something is very broken.
+        */
+       if (!fr_cond_assert(fr_timeval_cmp(fired, yielded) >= 0)) REDEBUG("Unexpected resume time");
+
+       unlang_interpret_resumable(request);
+}
+
+static void _xlat_delay_done(REQUEST *request,
+                            UNUSED void *xlat_inst, UNUSED void *xlat_thread_inst, void *rctx, struct timeval *fired)
 {
        struct timeval *yielded = talloc_get_type_abort(rctx, struct timeval);
 
@@ -113,8 +129,7 @@ static int delay_add(REQUEST *request, struct timeval *resume_at, struct timeval
 /** Called resume_at the delay is complete, and we're running from the interpreter
  *
  */
-static rlm_rcode_t mod_delay_return(REQUEST *request,
-                                   UNUSED void *instance, UNUSED void *thread, void *rctx)
+static rlm_rcode_t mod_delay_return(UNUSED void *instance, UNUSED void *thread, REQUEST *request, void *rctx)
 {
        struct timeval *yielded = talloc_get_type_abort(rctx, struct timeval);
 
@@ -134,7 +149,7 @@ static rlm_rcode_t mod_delay_return(REQUEST *request,
        return RLM_MODULE_OK;
 }
 
-static void mod_delay_cancel(REQUEST *request, UNUSED void *instance, UNUSED void *thread, void *rctx,
+static void mod_delay_cancel(UNUSED void *instance, UNUSED void *thread, REQUEST *request, void *rctx,
                             fr_state_signal_t action)
 {
        if (action != FR_SIGNAL_CANCEL) return;
@@ -269,7 +284,7 @@ static xlat_action_t xlat_delay(TALLOC_CTX *ctx, UNUSED fr_cursor_t *out,
 yield:
        RDEBUG3("Current time %pV, resume time %pV", fr_box_timeval(*yielded_at), fr_box_timeval(resume_at));
 
-       if (unlang_xlat_event_timeout_add(request, _delay_done, yielded_at, &resume_at) < 0) {
+       if (unlang_xlat_event_timeout_add(request, _xlat_delay_done, yielded_at, &resume_at) < 0) {
                RPEDEBUG("Adding event failed");
                return XLAT_ACTION_FAIL;
        }

diff --git a/src/modules/rlm_eap/rlm_eap.c b/src/modules/rlm_eap/rlm_eap.c
index d09448c7ac708051d07080ed06037e7711dc21f8..1c3ed8316a6326b83bee771fcf41f410dc989f22 100644 (file)
--- a/src/modules/rlm_eap/rlm_eap.c
+++ b/src/modules/rlm_eap/rlm_eap.c
@@ -416,7 +416,7 @@ finish:
  * @param[in] rctx     the eap_session_t.
  * @return The result of this round of authentication.
  */
-static rlm_rcode_t mod_authenticate_result_async(REQUEST *request, void *instance, void *thread, void *rctx)
+static rlm_rcode_t mod_authenticate_result_async(void *instance, void *thread, REQUEST *request, void *rctx)
 {
        eap_session_t   *eap_session = talloc_get_type_abort(rctx, eap_session_t);
 
@@ -431,7 +431,7 @@ static rlm_rcode_t mod_authenticate_result_async(REQUEST *request, void *instanc
  * @param[in] rctx     the eap_session_t
  * @param[in] action   to perform.
  */
-static void mod_authenticate_cancel(REQUEST *request, UNUSED void *instance, UNUSED void *thread, void *rctx,
+static void mod_authenticate_cancel(UNUSED void *instance, UNUSED void *thread, REQUEST *request, void *rctx,
                                    fr_state_signal_t action)
 {
        eap_session_t   *eap_session;

diff --git a/src/modules/rlm_radius/rlm_radius.c b/src/modules/rlm_radius/rlm_radius.c
index 82b7a0d63a594eaf231a7ab17ef2efebb9bb7aa4..368ddcd85b5f2f210ce9ac1870e129cd3deed5be 100644 (file)
--- a/src/modules/rlm_radius/rlm_radius.c
+++ b/src/modules/rlm_radius/rlm_radius.c
@@ -412,7 +412,7 @@ static void mod_radius_signal(REQUEST *request, void *instance, void *thread, vo
 /** Continue after unlang_interpret_resumable()
  *
  */
-static rlm_rcode_t mod_radius_resume(REQUEST *request, void *instance, void *thread, void *ctx)
+static rlm_rcode_t mod_radius_resume(void *instance, void *thread, REQUEST *request, void *ctx)
 {
        rlm_radius_t const *inst = talloc_get_type_abort_const(instance, rlm_radius_t);
        rlm_radius_thread_t *t = talloc_get_type_abort(thread, rlm_radius_thread_t);

diff --git a/src/modules/rlm_radius/rlm_radius_udp.c b/src/modules/rlm_radius/rlm_radius_udp.c
index 198b0b7e94c7043d7e4717af28db79891bdd567e..ab80027b0dc5bc85f0be1278feb2c920c66fd0ae 100644 (file)
--- a/src/modules/rlm_radius/rlm_radius_udp.c
+++ b/src/modules/rlm_radius/rlm_radius_udp.c
@@ -708,7 +708,7 @@ static int conn_thread_instantiate(fr_io_connection_thread_t *t, fr_event_list_t
        return 0;
 }
 
-static rlm_rcode_t conn_request_resume(UNUSED REQUEST *request, UNUSED void *instance, UNUSED void *thread, void *ctx)
+static rlm_rcode_t conn_request_resume(UNUSED void *instance, UNUSED void *thread, UNUSED REQUEST *request, void *ctx)
 {
        fr_io_request_t *u = talloc_get_type_abort(ctx, fr_io_request_t);
        rlm_rcode_t rcode;

diff --git a/src/modules/rlm_rest/io.c b/src/modules/rlm_rest/io.c
index 9dd54a8b0e784f149e14ca13b2b627f03844cc79..8d7cf21105198e44bb3cda10ac69905eed19d614 100644 (file)
--- a/src/modules/rlm_rest/io.c
+++ b/src/modules/rlm_rest/io.c
@@ -369,13 +369,13 @@ static int _rest_io_event_modify(UNUSED CURL *easy, curl_socket_t fd, int what,
  * If we're signalled that the request has been cancelled (FR_SIGNAL_CANCEL).
  * Cleanup any pending state and release the connection handle back into the pool.
  *
- * @param[in] request  being cancelled.
  * @param[in] instance of rlm_rest.
  * @param[in] thread   Thread specific module instance.
+ * @param[in] request  being cancelled.
  * @param[in] rctx     rlm_rest_handle_t currently used by the request.
  * @param[in] action   What happened.
  */
-void rest_io_module_action(REQUEST *request, void *instance, void *thread, void *rctx, fr_state_signal_t action)
+void rest_io_module_action(void *instance, void *thread, REQUEST *request, void *rctx, fr_state_signal_t action)
 {
        rlm_rest_handle_t       *randle = talloc_get_type_abort(rctx, rlm_rest_handle_t);
        rlm_rest_thread_t       *t = thread;
@@ -416,7 +416,7 @@ void rest_io_xlat_action(REQUEST *request, UNUSED void *instance, void *thread,
        rlm_rest_xlat_rctx_t            *our_rctx = talloc_get_type_abort(rctx, rlm_rest_xlat_rctx_t);
        rlm_rest_handle_t               *randle = talloc_get_type_abort(our_rctx->handle, rlm_rest_handle_t);
 
-       rest_io_module_action(request, mod_inst, t, randle, action);
+       rest_io_module_action(mod_inst, t, request, randle, action);
 }
 
 /** Sends a REST (HTTP) request.

diff --git a/src/modules/rlm_rest/rest.h b/src/modules/rlm_rest/rest.h
index 001dfe4ac54144cc33ae0f56f4d6ca038180d974..ced526403a47ec9f7c6d4cac903e9419778dc166 100644 (file)
--- a/src/modules/rlm_rest/rest.h
+++ b/src/modules/rlm_rest/rest.h
@@ -347,8 +347,8 @@ ssize_t rest_uri_host_unescape(char **out, UNUSED rlm_rest_t const *mod_inst, RE
 /*
  *     Async IO helpers
  */
-void rest_io_module_action(REQUEST *request, void *instance, void *thread, void *rctx, fr_state_signal_t action);
-void rest_io_xlat_action(REQUEST *request, void *instance, void *thread, void *rctx, fr_state_signal_t action);
+void rest_io_module_action(void *instance, void *thread, REQUEST *request, void *rctx, fr_state_signal_t action);
+void rest_io_xlat_action(REQUEST *request, void *xlat_inst, void *xlat_thread_inst, void *rctx, fr_state_signal_t action);
 int rest_io_request_enqueue(rlm_rest_thread_t *thread, REQUEST *request, void *handle);
 int rest_io_init(rlm_rest_thread_t *thread, bool multiplex);
 

diff --git a/src/modules/rlm_rest/rlm_rest.c b/src/modules/rlm_rest/rlm_rest.c
index d3553d2edbc677cba704fa248f824b5bfaf221ee..27ad91c5aa64cd78941693de848aa51715247621 100644 (file)
--- a/src/modules/rlm_rest/rlm_rest.c
+++ b/src/modules/rlm_rest/rlm_rest.c
@@ -423,7 +423,7 @@ static xlat_action_t rest_xlat(TALLOC_CTX *ctx, UNUSED fr_cursor_t *out,
        return unlang_xlat_yield(request, rest_xlat_resume, rest_io_xlat_action, rctx);
 }
 
-static rlm_rcode_t mod_authorize_result(REQUEST *request, void *instance, void *thread, void *ctx)
+static rlm_rcode_t mod_authorize_result(void *instance, void *thread, REQUEST *request, void *ctx)
 {
        rlm_rest_t const                *inst = instance;
        rlm_rest_thread_t               *t = thread;
@@ -537,7 +537,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_authorize(void *instance, void *thread,
        return unlang_module_yield(request, mod_authorize_result, rest_io_module_action, handle);
 }
 
-static rlm_rcode_t mod_authenticate_result(REQUEST *request, void *instance, void *thread, void *rctx)
+static rlm_rcode_t mod_authenticate_result(void *instance, void *thread, REQUEST *request, void *rctx)
 {
        rlm_rest_t const                *inst = instance;
        rlm_rest_thread_t               *t = thread;
@@ -666,7 +666,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_authenticate(void *instance, void *threa
        return unlang_module_yield(request, mod_authenticate_result, NULL, handle);
 }
 
-static rlm_rcode_t mod_accounting_result(REQUEST *request, void *instance, void *thread, void *rctx)
+static rlm_rcode_t mod_accounting_result(void *instance, void *thread, REQUEST *request, void *rctx)
 {
        rlm_rest_t const                *inst = instance;
        rlm_rest_thread_t               *t = thread;
@@ -745,7 +745,7 @@ static rlm_rcode_t CC_HINT(nonnull) mod_accounting(void *instance, void *thread,
        return unlang_module_yield(request, mod_accounting_result, NULL, handle);
 }
 
-static rlm_rcode_t mod_post_auth_result(REQUEST *request, void *instance, void *thread, void *rctx)
+static rlm_rcode_t mod_post_auth_result(void *instance, void *thread, REQUEST *request, void *rctx)
 {
        rlm_rest_t const                *inst = instance;
        rlm_rest_thread_t               *t = thread;