/** Encode EAP session data from attributes
*
*/
-static unlang_action_t mod_encode(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, UNUSED void *rctx)
+static unlang_action_t mod_encode(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_module_conf_t);
eap_session_t *eap_session = eap_session_get(request->parent);
#define STATE(_x) static inline unlang_action_t state_ ## _x(rlm_rcode_t *p_result, \
module_ctx_t const *mctx, \
- request_t *request,\
- eap_aka_sim_session_t *eap_aka_sim_session)
+ request_t *request)
#define STATE_GUARD(_x) static unlang_action_t guard_ ## _x(rlm_rcode_t *p_result, \
module_ctx_t const *mctx, \
- request_t *request, \
- eap_aka_sim_session_t *eap_aka_sim_session)
+ request_t *request)
#define RESUME(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, \
module_ctx_t const *mctx, \
- request_t *request, \
- void *rctx)
+ request_t *request)
-#define STATE_TRANSITION(_x) guard_ ## _x(p_result, mctx, request, eap_aka_sim_session);
+#define STATE_TRANSITION(_x) guard_ ## _x(p_result, mctx, request);
#define CALL_SECTION(_x) unlang_module_yield_to_section(p_result, \
request, \
RLM_MODULE_NOOP, \
resume_ ## _x, \
mod_signal, \
- eap_aka_sim_session)
+ talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t))
/*
* Declare all state and guard functions to
*
* @param[in] mctx UNUSED.
* @param[in] request The current request.
- * @param[in] rctx the eap_session_t
* @param[in] action to perform.
*/
-static void mod_signal(UNUSED module_ctx_t const *mctx, request_t *request, void *rctx,
- fr_state_signal_t action)
+static void mod_signal(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
if (action != FR_SIGNAL_CANCEL) return;
* Remove data from the request to
* avoid double free.
*/
- if (!fr_cond_assert(request_data_get(request, (void *)eap_aka_sim_state_machine_process, 0) == rctx)) return;
+ if (!fr_cond_assert(request_data_get(request, (void *)eap_aka_sim_state_machine_process, 0) == mctx->rctx)) return;
- TALLOC_FREE(rctx);
+ talloc_free(mctx->rctx);
}
/** Warn the user that the rcode they provided is being ignored in this section
*/
static inline CC_HINT(always_inline) void state_set(request_t *request,
eap_aka_sim_session_t *eap_aka_sim_session,
- eap_aka_sim_state_t new_state)
+ module_method_t new_state)
{
- eap_aka_sim_state_t old_state = eap_aka_sim_session->state;
+ module_method_t old_state = eap_aka_sim_session->state;
if (new_state != old_state) {
RDEBUG2("Changed state %s -> %s",
eap_aka_sim_session->state = new_state;
}
-#define STATE_SET(_new_state) state_set(request, eap_aka_sim_session, state_ ## _new_state)
+#define STATE_SET(_new_state) state_set(request, talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t), state_ ## _new_state)
/** Determine if we're after authentication
*
*/
RESUME(store_session)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
switch (unlang_interpret_stack_result(request)) {
/*
pair_delete_request(attr_eap_aka_sim_next_reauth_id);
- return eap_aka_sim_session->next(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->next(p_result, mctx, request);
}
/** Resume after 'store pseudonym { ... }'
RESUME(store_pseudonym)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
fr_pair_t *new;
* We didn't store any fast-reauth data
*/
done:
- return eap_aka_sim_session->next(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->next(p_result, mctx, request);
}
/** Implements a set of states for storing pseudonym and fastauth identities
static unlang_action_t session_and_pseudonym_store(rlm_rcode_t *p_result, module_ctx_t const *mctx,
request_t *request,
eap_aka_sim_session_t *eap_aka_sim_session,
- eap_aka_sim_next_t next)
+ module_method_t next)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
fr_pair_t *vp;
RWDEBUG("Found empty Pseudonym-Id, and told not to generate one. "
"Skipping store pseudonym { ... } section");
- return resume_store_pseudonym(p_result, mctx, request, eap_aka_sim_session);
+ return resume_store_pseudonym(p_result, mctx, request);
}
MEM(identity = talloc_array(vp, char, inst->ephemeral_id_length + 2));
return CALL_SECTION(store_pseudonym);
}
- return resume_store_pseudonym(p_result, mctx, request, eap_aka_sim_session);
+ return resume_store_pseudonym(p_result, mctx, request);
}
/** Resume after 'clear session { ... }'
*/
RESUME(clear_session)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
pair_delete_request(attr_session_id);
- return eap_aka_sim_session->next(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->next(p_result, mctx, request);
}
/** Resume after 'clear pseudonym { ... }'
RESUME(clear_pseudonym)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
pair_delete_request(attr_eap_aka_sim_next_pseudonym);
return CALL_SECTION(clear_session);
}
- return eap_aka_sim_session->next(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->next(p_result, mctx, request);
}
/** Implements a set of states for clearing out pseudonym and fastauth identities
static unlang_action_t session_and_pseudonym_clear(rlm_rcode_t *p_result, module_ctx_t const *mctx,
request_t *request,
eap_aka_sim_session_t *eap_aka_sim_session,
- eap_aka_sim_next_t next)
+ module_method_t next)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
return CALL_SECTION(clear_pseudonym);
}
- return resume_clear_pseudonym(p_result, mctx, request, eap_aka_sim_session);
+ return resume_clear_pseudonym(p_result, mctx, request);
}
/** Export EAP-SIM/AKA['] attributes
/** Called after 'store session { ... }' and 'store pseudonym { ... }'
*
*/
-static unlang_action_t common_reauthentication_request_send(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request,
- eap_aka_sim_session_t *eap_aka_sim_session)
+static unlang_action_t common_reauthentication_request_send(rlm_rcode_t *p_result,
+ module_ctx_t const *mctx, request_t *request)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+
/*
* Return reply attributes - AT_IV is handled automatically by the encoder
*/
/** Called after 'store session { ... }' and 'store pseudonym { ... }'
*
*/
-static unlang_action_t aka_challenge_request_send(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, eap_aka_sim_session_t *eap_aka_sim_session)
+static unlang_action_t aka_challenge_request_send(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+
/*
* Encode the packet - AT_IV is handled automatically
* by the encoder.
/** Called after 'store session { ... }' and 'store pseudonym { ... }'
*
*/
-static unlang_action_t sim_challenge_request_send(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, eap_aka_sim_session_t *eap_aka_sim_session)
+static unlang_action_t sim_challenge_request_send(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
uint8_t sres_cat[AKA_SIM_VECTOR_GSM_SRES_SIZE * 3];
uint8_t *p = sres_cat;
*/
STATE(eap_failure)
{
- if (!fr_cond_assert(request && mctx && eap_aka_sim_session)) RETURN_MODULE_FAIL; /* unused args */
+ if (!fr_cond_assert(request && mctx && mctx->rctx)) RETURN_MODULE_FAIL; /* unused args */
fr_assert(0); /* Should never actually be called */
*/
RESUME(send_eap_failure)
{
- if (!fr_cond_assert(mctx && rctx)) RETURN_MODULE_FAIL; /* unused args */
+ if (!fr_cond_assert(mctx && mctx->rctx)) RETURN_MODULE_FAIL; /* unused args */
SECTION_RCODE_IGNORED;
STATE_GUARD(eap_failure)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
/*
* Free anything we were going to send out...
*/
RESUME(recv_common_failure_notification_ack)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
-
SECTION_RCODE_IGNORED;
/*
RESUME(send_common_failure_notification)
{
fr_pair_t *vp, *notification_vp;
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx,
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx,
eap_aka_sim_session_t);
if (!fr_cond_assert(mctx)) RETURN_MODULE_FAIL; /* quiet unused warning */
STATE_GUARD(common_failure_notification)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
/*
* If we're failing, then any identities
*/
STATE(eap_success)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+
if (!fr_cond_assert(request && mctx && eap_aka_sim_session)) RETURN_MODULE_FAIL; /* unused args */
fr_assert(0); /* Should never actually be called */
*/
RESUME(send_eap_success)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
uint8_t *p;
RDEBUG2("Sending EAP-Success");
*/
RESUME(recv_common_success_notification_ack)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
-
SECTION_RCODE_IGNORED;
/*
*/
RESUME(send_common_success_notification)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
SECTION_RCODE_PROCESS;
*/
RESUME(recv_common_client_error)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
-
SECTION_RCODE_IGNORED;
return STATE_TRANSITION(eap_failure);
*/
RESUME(recv_common_reauthentication_response)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
SECTION_RCODE_PROCESS;
STATE(common_reauthentication)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *subtype_vp = NULL;
subtype_vp = fr_pair_find_by_da(&request->request_pairs, attr_eap_aka_sim_subtype, 0);
*/
RESUME(send_common_reauthentication_request)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
switch (unlang_interpret_stack_result(request)) {
/*
RESUME(load_pseudonym)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
pair_delete_request(attr_eap_aka_sim_next_reauth_id);
*/
if (!inst->actions.load_pseudonym) {
next_state:
- return eap_aka_sim_session->next(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->next(p_result, mctx, request);
}
switch (unlang_interpret_stack_result(request)) {
RESUME(load_session)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
pair_delete_request(attr_session_id);
STATE_GUARD(common_reauthentication)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp = NULL;
STATE_SET(common_reauthentication);
RESUME(recv_aka_syncronization_failure)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
SECTION_RCODE_PROCESS;
*/
RESUME(recv_aka_authentication_reject)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
-
SECTION_RCODE_IGNORED;
/*
*/
RESUME(recv_aka_challenge_response)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp = NULL;
SECTION_RCODE_PROCESS;
STATE(aka_challenge)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *subtype_vp = NULL;
fr_pair_t *vp;
*/
RESUME(send_aka_challenge_request)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
fr_aka_sim_vector_src_t src = AKA_SIM_VECTOR_SRC_AUTO;
STATE_GUARD(aka_challenge)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
/*
*/
RESUME(recv_sim_challenge_response)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
uint8_t sres_cat[AKA_SIM_VECTOR_GSM_SRES_SIZE * 3];
uint8_t *p = sres_cat;
STATE(sim_challenge)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- fr_pair_t *subtype_vp = NULL;
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+ fr_pair_t *subtype_vp = NULL;
subtype_vp = fr_pair_find_by_da(&request->request_pairs, attr_eap_aka_sim_subtype, 0);
if (!subtype_vp) {
*/
RESUME(send_sim_challenge_request)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
fr_aka_sim_vector_src_t src = AKA_SIM_VECTOR_SRC_AUTO;
STATE_GUARD(sim_challenge)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
/*
*/
STATE_GUARD(common_challenge)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+
switch (eap_aka_sim_session->type) {
case FR_EAP_METHOD_SIM:
return STATE_TRANSITION(sim_challenge);
RESUME(recv_aka_identity_response)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
bool user_set_id_req;
fr_pair_t *identity_type;
STATE(aka_identity)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *subtype_vp = NULL;
subtype_vp = fr_pair_find_by_da(&request->request_pairs, attr_eap_aka_sim_subtype, 0);
*/
RESUME(send_aka_identity_request)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
SECTION_RCODE_PROCESS;
*/
STATE_GUARD(aka_identity)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
STATE_SET(aka_identity);
RESUME(recv_sim_start_response)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
bool user_set_id_req;
fr_pair_t *identity_type;
STATE(sim_start)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *subtype_vp = NULL;
subtype_vp = fr_pair_find_by_da(&request->request_pairs, attr_eap_aka_sim_subtype, 0);
*/
RESUME(send_sim_start)
{
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
uint8_t *p, *end;
STATE_GUARD(sim_start)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
STATE_SET(sim_start);
*/
STATE_GUARD(common_identity)
{
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
+
switch (eap_aka_sim_session->type) {
case FR_EAP_METHOD_SIM:
return STATE_TRANSITION(sim_start);
RESUME(recv_common_identity_response)
{
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
- eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(rctx, eap_aka_sim_session_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *eap_type, *method, *identity_type;
fr_aka_sim_method_hint_t running, hinted;
{
eap_session_t *eap_session = eap_session_get(request->parent);
eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->instance, eap_aka_sim_process_conf_t);
+ eap_aka_sim_session_t *eap_aka_sim_session = talloc_get_type_abort(mctx->rctx, eap_aka_sim_session_t);
fr_pair_t *vp;
fr_aka_sim_id_type_t type;
eap_aka_sim_session_t *eap_aka_sim_session = request_data_reference(request,
(void *)eap_aka_sim_state_machine_process,
0);
+ module_ctx_t our_mctx = *mctx;
+
/*
* A new EAP-SIM/AKA/AKA' session!
*/
if (!eap_aka_sim_session) {
+
/*
* Must be allocated in the NULL ctx as this will
* need to persist over multiple rounds of EAP.
}
eap_aka_sim_session->type = inst->type;
- return state_init(p_result, mctx, request, eap_aka_sim_session);
+ our_mctx.rctx = eap_aka_sim_session;
+
+ return state_init(p_result, &our_mctx, request);
}
+ /*
+ * This function is called without a resume ctx as it's the
+ * entry point for each new round of EAP-AKA.
+ */
+ our_mctx.rctx = eap_aka_sim_session;
+
if (!fr_cond_assert(eap_aka_sim_session->state)) RETURN_MODULE_FAIL;
- return eap_aka_sim_session->state(p_result, mctx, request, eap_aka_sim_session);
+ return eap_aka_sim_session->state(p_result, &our_mctx, request);
}
typedef struct eap_aka_sim_session_s eap_aka_sim_session_t;
-/** The state function which should receive any incoming packets
- *
- */
-typedef unlang_action_t (*eap_aka_sim_state_t)(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, eap_aka_sim_session_t *eap_aka_sim_session);
-
-/** The function to execute after common code has completed
- *
- * Mostly used to set functions to run after pseudonym and session
- * loading/clearing/storing is complete.
- */
-typedef unlang_action_t (*eap_aka_sim_next_t)(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, eap_aka_sim_session_t *eap_aka_sim_session);
-
struct eap_aka_sim_session_s {
/*
* State machine management
*/
- eap_aka_sim_state_t state; //!< The process function to run when we
+ module_method_t state; //!< The process function to run when we
///< receive the next round of EAP-SIM/AKA/AKA'.
- eap_aka_sim_next_t next; //!< Resumption function to call after
+ module_method_t next; //!< Resumption function to call after
///< executing common code.
eap_type_t type; //!< Either FR_TYPE_AKA, or FR_TYPE_AKA_PRIME.
static fr_process_state_t const process_state[];
#define RECV(_x) static inline unlang_action_t recv_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
-#define SEND(_x) static inline unlang_action_t send_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, void *rctx)
-#define RESUME(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, void *rctx)
-#define SEND_NO_RCTX(_x) static inline unlang_action_t send_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, UNUSED void *rctx)
-#define RESUME_NO_RCTX(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, UNUSED void *rctx)
-#define RESUME_NO_MCTX(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request, UNUSED void *rctx)
+#define SEND(_x) static inline unlang_action_t send_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
+#define RESUME(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
+#define SEND_NO_RCTX(_x) static inline unlang_action_t send_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
+#define RESUME_NO_RCTX(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
+#define RESUME_NO_MCTX(_x) static inline unlang_action_t resume_ ## _x(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request)
/** Call a named recv function directly
*/
/** Call a named send function directly
*/
-#define CALL_SEND(_x) send_ ## _x(p_result, mctx, request, rctx)
+#define CALL_SEND(_x) send_ ## _x(p_result, mctx, request)
/** Call a named resume function directly
*/
-#define CALL_RESUME(_x) resume_ ## _x(p_result, mctx, request, rctx)
+#define CALL_RESUME(_x) resume_ ## _x(p_result, mctx, request)
/** Call the send function for the current state
*/
-#define CALL_SEND_STATE(_state) state->send(p_result, mctx, request, rctx)
+#define CALL_SEND_STATE(_state) state->send(p_result, mctx, request)
/** Set the current reply code, and call the send function for that state
*/
-#define CALL_SEND_TYPE(_x) call_send_type(process_state[(request->reply->code = _x)].send, p_result, mctx, request, rctx)
+#define CALL_SEND_TYPE(_x) call_send_type(process_state[(request->reply->code = _x)].send, p_result, mctx, request)
static inline unlang_action_t call_send_type(unlang_module_resume_t send, \
rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+ request_t *request)
{
/*
* Stupid hack to stop this being honoured
* by send_generic.
*/
pair_delete_reply(attr_packet_type);
- return send(p_result, mctx, request, rctx);
+ return send(p_result, mctx, request);
}
RECV(generic)
if (cs) RDEBUG("Running '%s %s' from file %s", cf_section_name1(cs), cf_section_name2(cs), cf_filename(cs));
return unlang_module_yield_to_section(p_result, request,
cs, state->rcode, state->resume,
- NULL, NULL);
+ NULL, mctx->rctx);
}
RESUME(recv_generic)
fr_assert(state->send != NULL);
return unlang_module_yield_to_section(p_result, request,
cs, state->rcode, state->send,
- NULL, rctx);
+ NULL, mctx->rctx);
}
RESUME_NO_MCTX(recv_no_send)
return unlang_module_yield_to_section(p_result, request,
cs, state->rcode, state->resume,
- NULL, rctx);
+ NULL, mctx->rctx);
}
RESUME(send_generic)
return unlang_module_yield_to_section(p_result, request,
cs, state->rcode, state->send,
- NULL, rctx);
+ NULL, mctx->rctx);
}
fr_assert(!state->packet_type[rcode] || (state->packet_type[rcode] == request->reply->code));
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
- ev->fd_read(&(module_ctx_t){ .instance = mutable_inst, .thread = ev->thread }, ev->request, mutable_ctx, fd);
+ ev->fd_read(&(module_ctx_t){
+ .instance = mutable_inst,
+ .thread = ev->thread,
+ .rctx = mutable_ctx },
+ ev->request, fd);
}
/** Frees an unlang event, removing it from the request's event loop
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
- ev->timeout(&(module_ctx_t){ .instance = mutable_inst, .thread = ev->thread }, ev->request, mutable_ctx, now);
+ ev->timeout(&(module_ctx_t){
+ .instance = mutable_inst,
+ .thread = ev->thread,
+ .rctx = mutable_ctx
+ }, ev->request, now);
talloc_free(ev);
}
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
- ev->fd_write(&(module_ctx_t){ .instance = mutable_inst, .thread = ev->thread }, ev->request, mutable_ctx, fd);
+ ev->fd_write(&(module_ctx_t){
+ .instance = mutable_inst,
+ .thread = ev->thread,
+ .rctx = mutable_ctx },
+ ev->request, fd);
}
/** Call the callback registered for an I/O error event
memcpy(&mutable_ctx, &ev->ctx, sizeof(mutable_ctx));
memcpy(&mutable_inst, &ev->inst, sizeof(mutable_inst));
- ev->fd_error(&(module_ctx_t){ .instance = mutable_inst, .thread = ev->thread }, ev->request, mutable_ctx, fd);
+ ev->fd_error(&(module_ctx_t){
+ .instance = mutable_inst,
+ .thread = ev->thread,
+ .rctx = mutable_ctx
+ }, ev->request, fd);
}
return resume(p_result,
&(module_ctx_t){
.instance = mc->instance->dl_inst->data,
- .thread = module_thread(mc->instance)->data
- }, request, rctx);
+ .thread = module_thread(mc->instance)->data,
+ .rctx = rctx
+ }, request);
}
/*
safe_lock(mc->instance);
state->signal(&(module_ctx_t){
.instance = mc->instance->dl_inst->data,
- .thread = state->thread->data
+ .thread = state->thread->data,
+ .rctx = state->rctx
},
- request, state->rctx, action);
+ request, action);
safe_unlock(mc->instance);
request->module = caller;
ua = resume(&state->rcode,
&(module_ctx_t){
.instance = mc->instance->dl_inst->data,
- .thread = state->thread->data
- }, request, state->rctx);
+ .thread = state->thread->data,
+ .rctx = state->rctx,
+ }, request);
safe_unlock(mc->instance);
request->rcode = state->rcode;
*
* @param[in] mctx calling context for the module.
* Contains global, thread-specific, and call-specific data for a module.
- * @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 (*unlang_module_timeout_t)(module_ctx_t const *mctx, request_t *request, void *rctx, fr_time_t fired);
+typedef void (*unlang_module_timeout_t)(module_ctx_t const *mctx, request_t *request, fr_time_t fired);
/** A callback when the FD is ready for reading
*
* @param[in] mctx calling context for the module.
* Contains global, thread-specific, and call-specific data for a module.
* @param[in] request the current request.
- * @param[in] rctx a local context for the callback.
* @param[in] fd the file descriptor.
*/
-typedef void (*unlang_module_fd_event_t)(module_ctx_t const *mctx, request_t *request, void *rctx, int fd);
+typedef void (*unlang_module_fd_event_t)(module_ctx_t const *mctx, request_t *request, int fd);
/** A callback for when the request is resumed.
*
* @param[in] mctx calling context for the module.
* Contains global, thread-specific, and call-specific data for a module.
* @param[in] request the current request.
- * @param[in] rctx a local context for the callback.
* @return an instruction for the interpreter.
*/
-typedef unlang_action_t (*unlang_module_resume_t)(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx);
+typedef unlang_action_t (*unlang_module_resume_t)(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request);
/** A callback when the request gets a fr_state_signal_t.
*
*
* @param[in] mctx calling context for the module.
* Contains global, thread-specific, and call-specific data for a module.
- * @param[in] rctx Resume ctx for the callback.
* @param[in] request The current request.
* @param[in] action which is signalling the request.
*/
-typedef void (*unlang_module_signal_t)(module_ctx_t const *mctx, request_t *request,
- void *rctx, fr_state_signal_t action);
+typedef void (*unlang_module_signal_t)(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action);
int unlang_module_timeout_add(request_t *request, unlang_module_timeout_t callback,
void const *ctx, fr_time_t when);
*
* Marks the request as resumable, and prints the delayed delay time.
*/
-static void _delay_done(UNUSED module_ctx_t const *mctx, request_t *request, void *rctx, fr_time_t fired)
+static void _delay_done(module_ctx_t const *mctx, request_t *request, fr_time_t fired)
{
- fr_time_t *yielded = talloc_get_type_abort(rctx, fr_time_t);
+ fr_time_t *yielded = talloc_get_type_abort(mctx->rctx, fr_time_t);
RDEBUG2("Delay done");
/** Called resume_at the delay is complete, and we're running from the interpreter
*
*/
-static unlang_action_t mod_delay_return(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_delay_return(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- fr_time_t *yielded = talloc_get_type_abort(rctx, fr_time_t);
+ fr_time_t *yielded = talloc_get_type_abort(mctx->rctx, fr_time_t);
/*
* Print how long the delay *really* was.
RETURN_MODULE_OK;
}
-static void mod_delay_cancel(UNUSED module_ctx_t const *mctx, request_t *request, void *rctx,
- fr_state_signal_t action)
+static void mod_delay_cancel(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
if (action != FR_SIGNAL_CANCEL) return;
RDEBUG2("Cancelling delay");
- (void) unlang_module_timeout_delete(request, rctx);
+ (void) unlang_module_timeout_delete(request, mctx->rctx);
}
static unlang_action_t CC_HINT(nonnull) mod_delay(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
return 0;
}
-static unlang_action_t dhcpv4_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- UNUSED request_t *request, void *rctx)
+static unlang_action_t dhcpv4_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, UNUSED request_t *request)
{
- rlm_dhcpv4_delay_t *d = talloc_get_type_abort(rctx, rlm_dhcpv4_delay_t);
+ rlm_dhcpv4_delay_t *d = talloc_get_type_abort(mctx->rctx, rlm_dhcpv4_delay_t);
if (!d->sent) {
talloc_free(d);
*
* @param[in] mctx module calling ctx.
* @param[in] request The current request.
- * @param[in] rctx the eap_session_t
* @param[in] action to perform.
*/
-static void mod_authenticate_cancel(UNUSED module_ctx_t const *mctx, request_t *request, void *rctx,
- fr_state_signal_t action)
+static void mod_authenticate_cancel(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
eap_session_t *eap_session;
RDEBUG2("Request cancelled - Destroying EAP-Session");
- eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
TALLOC_FREE(eap_session->subrequest);
* @param[out] p_result The result of the operation.
* @param[in] mctx module calling ctx.
* @param[in] request the current request.
- * @param[in] rctx the eap_session_t.
* @return The result of this round of authentication.
*/
static unlang_action_t mod_authenticate_result_async(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+ request_t *request)
{
- eap_session_t *eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session_t *eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
return mod_authenticate_result(p_result, mctx, request, eap_session, eap_session->submodule_rcode);
}
return 1;
}
-static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- eap_session_t *eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session_t *eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
return t;
}
-static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_eap_peap_t *inst = talloc_get_type(mctx->instance, rlm_eap_peap_t);
rlm_rcode_t rcode;
- eap_session_t *eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session_t *eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
peap_tunnel_t *peap = talloc_get_type_abort(tls_session->opaque, peap_tunnel_t);
};
static unlang_action_t mod_handshake_done(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- UNUSED request_t *request, UNUSED void *rctx)
+ UNUSED request_t *request)
{
RETURN_MODULE_OK;
}
-static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- eap_session_t *eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session_t *eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
* Result is always OK, even if we fail to persist the
* session data.
*/
- unlang_module_yield(request, mod_handshake_done, NULL, NULL);
+ unlang_module_yield(request, mod_handshake_done, NULL, mctx->rctx);
/*
* Write the session to the session cache
*
return t;
}
-static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_handshake_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- eap_session_t *eap_session = talloc_get_type_abort(rctx, eap_session_t);
+ eap_session_t *eap_session = talloc_get_type_abort(mctx->rctx, eap_session_t);
eap_tls_session_t *eap_tls_session = talloc_get_type_abort(eap_session->opaque, eap_tls_session_t);
fr_tls_session_t *tls_session = eap_tls_session->tls_session;
*
*/
static unlang_action_t mod_exec_nowait_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+ request_t *request)
{
rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_exec_t);
- fr_value_box_list_t *box = talloc_get_type_abort(rctx, fr_value_box_list_t);
+ fr_value_box_list_t *box = talloc_get_type_abort(mctx->rctx, fr_value_box_list_t);
fr_pair_list_t *env_pairs = NULL;
/*
return rcode;
}
-static unlang_action_t mod_exec_wait_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_exec_wait_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
int status;
- rlm_exec_ctx_t *m = talloc_get_type_abort(rctx, rlm_exec_ctx_t);
rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_exec_t);
+ rlm_exec_ctx_t *m = talloc_get_type_abort(mctx->rctx, rlm_exec_ctx_t);
rlm_rcode_t rcode;
/*
fr_value_box_list_t *box = talloc_zero(ctx, fr_value_box_list_t);
fr_value_box_list_init(box);
- return unlang_module_yield_to_xlat(request, box, request, tmpl_xlat(inst->tmpl), mod_exec_nowait_resume, NULL, box);
+ return unlang_module_yield_to_xlat(request, box, request, tmpl_xlat(inst->tmpl),
+ mod_exec_nowait_resume, NULL, box);
}
/*
* If it wasn't we returns REJECT, if it was we returns OK
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+ request_t *request)
{
rlm_imap_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_imap_t);
- fr_curl_io_request_t *randle = rctx;
+ fr_curl_io_request_t *randle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
fr_curl_tls_t const *tls;
long curl_out;
long curl_out_valid;
}
-static void mod_radius_signal(module_ctx_t const *mctx, request_t *request, void *rctx, fr_state_signal_t action)
+static void mod_radius_signal(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_radius_t);
rlm_radius_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_radius_thread_t);
if (!inst->io->signal) return;
- inst->io->signal(&(module_ctx_t){.instance = inst->io_instance, .thread = t->io_thread }, request, rctx, action);
+ inst->io->signal(&(module_ctx_t){
+ .instance = inst->io_instance,
+ .thread = t->io_thread,
+ .rctx = mctx->rctx
+ }, request, action);
}
/** Continue after unlang_interpret_mark_runnable()
*
*/
-static unlang_action_t mod_radius_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, void *ctx)
+static unlang_action_t mod_radius_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_radius_t);
rlm_radius_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_radius_thread_t);
- return inst->io->resume(p_result, &(module_ctx_t){.instance = inst->io_instance, .thread = t->io_thread }, request, ctx);
+ return inst->io->resume(p_result,
+ &(module_ctx_t){
+ .instance = inst->io_instance,
+ .thread = t->io_thread,
+ .rctx = mctx->rctx
+ }, request);
}
/** Do any RADIUS-layer fixups for proxying.
/** Resume execution of the request, returning the rcode set during trunk execution
*
*/
-static unlang_action_t mod_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, UNUSED request_t *request, void *rctx)
+static unlang_action_t mod_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, UNUSED request_t *request)
{
- udp_result_t *r = talloc_get_type_abort(rctx, udp_result_t);
+ udp_result_t *r = talloc_get_type_abort(mctx->rctx, udp_result_t);
rlm_rcode_t rcode = r->rcode;
- talloc_free(rctx);
+ talloc_free(r);
RETURN_MODULE_RCODE(rcode);
}
-static void mod_signal(module_ctx_t const *mctx, UNUSED request_t *request,
- void *rctx, fr_state_signal_t action)
+static void mod_signal(module_ctx_t const *mctx, UNUSED request_t *request, fr_state_signal_t action)
{
udp_thread_t *t = talloc_get_type_abort(mctx->thread, udp_thread_t);
- udp_result_t *r = talloc_get_type_abort(rctx, udp_result_t);
+ udp_result_t *r = talloc_get_type_abort(mctx->rctx, udp_result_t);
/*
* If we don't have a treq associated with the
* (don't use it).
*/
if (!r->treq) {
- talloc_free(rctx);
+ talloc_free(r);
return;
}
* 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.
*/
-void rest_io_module_action(module_ctx_t const *mctx, request_t *request, void *rctx, fr_state_signal_t action)
+void rest_io_module_action(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
- fr_curl_io_request_t *randle = talloc_get_type_abort(rctx, fr_curl_io_request_t);
+ fr_curl_io_request_t *randle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
CURLMcode ret;
rlm_rest_xlat_rctx_t *our_rctx = talloc_get_type_abort(rctx, rlm_rest_xlat_rctx_t);
fr_curl_io_request_t *randle = talloc_get_type_abort(our_rctx->handle, fr_curl_io_request_t);
- rest_io_module_action(&(module_ctx_t){ .instance = mod_inst, .thread = t }, request, randle, action);
+ rest_io_module_action(&(module_ctx_t){ .instance = mod_inst, .thread = t, .rctx = randle }, request, action);
}
/*
* Async IO helpers
*/
-void rest_io_module_action(module_ctx_t const *mctx, request_t *request, void *rctx, fr_state_signal_t action);
+void rest_io_module_action(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action);
void rest_io_xlat_signal(request_t *request, void *xlat_inst, void *xlat_thread_inst, void *rctx, fr_state_signal_t action);
return unlang_xlat_yield(request, rest_xlat_resume, rest_io_xlat_signal, rctx);
}
-static unlang_action_t mod_authorize_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, void *rctx)
+static unlang_action_t mod_authorize_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
rlm_rest_section_t const *section = &inst->authenticate;
- fr_curl_io_request_t *handle = talloc_get_type_abort(rctx, fr_curl_io_request_t);
+ fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
int hcode;
rlm_rcode_t rcode = RLM_MODULE_OK;
}
static unlang_action_t mod_authenticate_result(rlm_rcode_t *p_result,
- module_ctx_t const *mctx, request_t *request, void *rctx)
+ module_ctx_t const *mctx, request_t *request)
{
rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
rlm_rest_section_t const *section = &inst->authenticate;
- fr_curl_io_request_t *handle = talloc_get_type_abort(rctx, fr_curl_io_request_t);
+ fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
int hcode;
int rcode = RLM_MODULE_OK;
return unlang_module_yield(request, mod_authenticate_result, NULL, handle);
}
-static unlang_action_t mod_accounting_result(rlm_rcode_t *p_result,
- module_ctx_t const *mctx, request_t *request, void *rctx)
+static unlang_action_t mod_accounting_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
rlm_rest_section_t const *section = &inst->authenticate;
- fr_curl_io_request_t *handle = rctx;
+ fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
int hcode;
int rcode = RLM_MODULE_OK;
return unlang_module_yield(request, mod_accounting_result, NULL, handle);
}
-static unlang_action_t mod_post_auth_result(rlm_rcode_t *p_result, module_ctx_t const *mctx,
- request_t *request, void *rctx)
+static unlang_action_t mod_post_auth_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
rlm_rest_section_t const *section = &inst->authenticate;
- fr_curl_io_request_t *handle = rctx;
+ fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
int hcode;
int rcode = RLM_MODULE_OK;
fr_time_t time;
char time_str[60];
curl_mime *mime;
-} fr_mail_ctx;
+} fr_mail_ctx_t;
/*
* Used to ensure that only strings are being set to the tmpl_t ** output
/*
* Adds every element associated with a dict_attr to a curl_slist
*/
-static int da_to_slist(fr_mail_ctx *uctx, struct curl_slist **out, const fr_dict_attr_t *dict_attr)
+static int da_to_slist(fr_mail_ctx_t *uctx, struct curl_slist **out, const fr_dict_attr_t *dict_attr)
{
- request_t *request = ((fr_mail_ctx *)uctx)->request;
+ request_t *request = ((fr_mail_ctx_t *)uctx)->request;
fr_pair_t *vp;
int elems_added = 0;
/*
* Takes a TMPL_TYPE_ATTR and adds it to an slist
*/
-static int tmpl_attr_to_slist(fr_mail_ctx *uctx, struct curl_slist **out, tmpl_t * const tmpl)
+static int tmpl_attr_to_slist(fr_mail_ctx_t *uctx, struct curl_slist **out, tmpl_t * const tmpl)
{
- request_t *request = ((fr_mail_ctx *)uctx)->request;
+ request_t *request = ((fr_mail_ctx_t *)uctx)->request;
fr_pair_t *vp;
tmpl_pair_cursor_ctx_t cc;
int count = 0;
/*
* Parse through an array of tmpl * elements and add them to an slist
*/
-static int tmpl_arr_to_slist (rlm_smtp_thread_t *t, fr_mail_ctx *uctx, struct curl_slist **out, tmpl_t ** const tmpl)
+static int tmpl_arr_to_slist (rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, struct curl_slist **out, tmpl_t ** const tmpl)
{
request_t *request = uctx->request;
int count = 0;
/*
* Adds every element associated with a tmpl_attr to an sbuff
*/
-static ssize_t tmpl_attr_to_sbuff (fr_mail_ctx *uctx, fr_sbuff_t *out, tmpl_t const *vpt, char const *delimeter)
+static ssize_t tmpl_attr_to_sbuff (fr_mail_ctx_t *uctx, fr_sbuff_t *out, tmpl_t const *vpt, char const *delimeter)
{
fr_pair_t *vp;
tmpl_pair_cursor_ctx_t cc;
/*
* Adds every value in a dict_attr to a curl_slist as a comma separated list with a preposition
*/
-static int tmpl_arr_to_header (rlm_smtp_thread_t *t, fr_mail_ctx *uctx, struct curl_slist **out, tmpl_t ** const tmpl,
+static int tmpl_arr_to_header (rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, struct curl_slist **out, tmpl_t ** const tmpl,
const char *preposition)
{
request_t *request = uctx->request;
/*
* Takes a string value and adds it as a file path to upload as an attachment
*/
-static int str_to_attachments (fr_mail_ctx *uctx, curl_mime *mime, char const * str, size_t len,
+static int str_to_attachments (fr_mail_ctx_t *uctx, curl_mime *mime, char const * str, size_t len,
fr_sbuff_t *path_buffer, fr_sbuff_marker_t *m)
{
int attachments_set = 0;
/*
* Parse a tmpl attr into a file attachment path and add it as a mime part
*/
-static int tmpl_attr_to_attachment (fr_mail_ctx *uctx, curl_mime *mime, const tmpl_t * tmpl,
+static int tmpl_attr_to_attachment (fr_mail_ctx_t *uctx, curl_mime *mime, const tmpl_t * tmpl,
fr_sbuff_t *path_buffer, fr_sbuff_marker_t *m)
{
fr_pair_t *vp;
/*
* Adds every element in a tmpl** to an attachment path, then adds it to the email
*/
-static int tmpl_arr_to_attachments (rlm_smtp_thread_t *t, fr_mail_ctx *uctx, curl_mime *mime, tmpl_t ** const tmpl,
+static int tmpl_arr_to_attachments (rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, curl_mime *mime, tmpl_t ** const tmpl,
fr_sbuff_t *path_buffer, fr_sbuff_marker_t *m)
{
request_t *request = uctx->request;
/*
* Generate the FROM: header
*/
-static int generate_from_header (rlm_smtp_thread_t *t, fr_mail_ctx *uctx, struct curl_slist **out, rlm_smtp_t const *inst)
+static int generate_from_header (rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, struct curl_slist **out, rlm_smtp_t const *inst)
{
char const *from = "FROM: ";
fr_sbuff_t sbuff;
/*
* Generates a curl_slist of recipients
*/
-static int recipients_source(rlm_smtp_thread_t *t, fr_mail_ctx *uctx, rlm_smtp_t const *inst)
+static int recipients_source(rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, rlm_smtp_t const *inst)
{
request_t *request = uctx->request;
int recipients_set = 0;
/*
* Generates a curl_slist of header elements header elements
*/
-static int header_source(rlm_smtp_thread_t *t, fr_mail_ctx *uctx, rlm_smtp_t const *inst)
+static int header_source(rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, rlm_smtp_t const *inst)
{
fr_sbuff_t time_out;
char const *to = "TO: ";
*/
static size_t body_source(char *ptr, size_t size, size_t nmemb, void *mail_ctx)
{
- fr_mail_ctx *uctx = mail_ctx;
+ fr_mail_ctx_t *uctx = mail_ctx;
fr_dbuff_t out;
request_t *request = uctx->request;
fr_pair_t *vp;
/*
* Initialize all the body elements to be uploaded later
*/
-static int body_init (fr_mail_ctx *uctx, curl_mime *mime)
+static int body_init (fr_mail_ctx_t *uctx, curl_mime *mime)
{
fr_pair_t *vp;
request_t *request = uctx->request;
/*
* Adds every SMTP_Attachments file to the email as a MIME part
*/
-static int attachments_source(rlm_smtp_thread_t *t, fr_mail_ctx *uctx, curl_mime *mime, rlm_smtp_t const *inst)
+static int attachments_source(rlm_smtp_thread_t *t, fr_mail_ctx_t *uctx, curl_mime *mime, rlm_smtp_t const *inst)
{
request_t *request = uctx->request;
int attachments_set = 0;
/*
* Free the curl slists
*/
-static int _free_mail_ctx(fr_mail_ctx *uctx)
+static int _free_mail_ctx(fr_mail_ctx_t *uctx)
{
curl_mime_free(uctx->mime);
curl_slist_free_all(uctx->header);
/*
* Check if the email was successfully sent, and if the certificate information was extracted
*/
-static unlang_action_t mod_authorize_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, void *rctx)
+static unlang_action_t mod_authorize_result(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- fr_mail_ctx *mail_ctx = rctx;
+ fr_mail_ctx_t *mail_ctx = talloc_get_type_abort(mctx->rctx, fr_mail_ctx_t);
rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_smtp_t);
fr_curl_io_request_t *randle = mail_ctx->randle;
fr_curl_tls_t const *tls;
rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_smtp_t);
rlm_smtp_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_smtp_thread_t);
fr_curl_io_request_t *randle;
- fr_mail_ctx *mail_ctx;
+ fr_mail_ctx_t *mail_ctx;
const char *envelope_address;
fr_pair_t const *smtp_body, *username, *password;
}
/* Initialize the uctx to perform the email */
- mail_ctx = talloc_zero(randle, fr_mail_ctx);
- *mail_ctx = (fr_mail_ctx) {
+ mail_ctx = talloc_zero(randle, fr_mail_ctx_t);
+ *mail_ctx = (fr_mail_ctx_t) {
.request = request,
.randle = randle,
.mime = curl_mime_init(randle->candle),
* If the response was not OK, we REJECT the request
* This does not confirm an email may be sent, only that the provided login credentials are valid for the server
*/
-static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_result,
- module_ctx_t const *mctx, request_t *request, void *rctx)
+static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_smtp_t);
- fr_curl_io_request_t *randle = rctx;
+ fr_curl_io_request_t *randle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
fr_curl_tls_t const *tls;
long curl_out;
long curl_out_valid;
RETURN_MODULE_OK;
}
-static void mod_retry_signal(module_ctx_t const *mctx, request_t *request, void *rctx, fr_state_signal_t action);
+static void mod_retry_signal(module_ctx_t const *mctx, request_t *request, fr_state_signal_t action);
/** Continue after marked runnable
*
*/
-static unlang_action_t mod_retry_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request, UNUSED void *ctx)
+static unlang_action_t mod_retry_resume(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request)
{
RDEBUG("Test called main retry handler - that's a failure");
/** Continue after FR_SIGNAL_RETRY
*
*/
-static unlang_action_t mod_retry_resume_retry(UNUSED rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request, UNUSED void *ctx)
+static unlang_action_t mod_retry_resume_retry(UNUSED rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request)
{
RDEBUG("Test retry");
/** Continue after FR_SIGNAL_TIMEOUT
*
*/
-static unlang_action_t mod_retry_resume_timeout(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request, UNUSED void *ctx)
+static unlang_action_t mod_retry_resume_timeout(rlm_rcode_t *p_result, UNUSED module_ctx_t const *mctx, request_t *request)
{
RDEBUG("Test timed out as expected");
RETURN_MODULE_OK;
}
-static void mod_retry_signal(UNUSED module_ctx_t const *mctx, request_t *request, UNUSED void *rctx, fr_state_signal_t action)
+static void mod_retry_signal(UNUSED module_ctx_t const *mctx, request_t *request, fr_state_signal_t action)
{
switch (action) {
case FR_SIGNAL_RETRY:
*/
RESUME(send_to_client)
{
- process_dhcpv6_client_fields_t *fields = talloc_get_type_abort(rctx, process_dhcpv6_client_fields_t);
+ process_dhcpv6_client_fields_t *fields = talloc_get_type_abort(mctx->rctx, process_dhcpv6_client_fields_t);
fr_process_state_t const *state;
*/
RESUME(send_to_relay)
{
- process_dhcpv6_relay_fields_t *fields = talloc_get_type_abort(rctx, process_dhcpv6_relay_fields_t);
+ process_dhcpv6_relay_fields_t *fields = talloc_get_type_abort(mctx->rctx, process_dhcpv6_relay_fields_t);
fr_process_state_t const *state;
UPDATE_STATE(reply);
RECV(access_request)
{
process_radius_t const *inst = talloc_get_type_abort_const(mctx->instance, process_radius_t);
- void *rctx = NULL;
/*
* Only reject if the state has already been thawed.
RDEBUG("Running 'authenticate %s' from file %s", cf_section_name2(cs), cf_filename(cs));
return unlang_module_yield_to_section(p_result, request,
cs, RLM_MODULE_NOOP, resume_auth_type,
- NULL, rctx);
+ NULL, mctx->rctx);
}
RESUME(auth_type)
fr_table_str_by_value(rcode_table, rcode, "???"));
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
/*
UPDATE_STATE(reply);
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
RESUME_NO_RCTX(access_accept)
fr_table_str_by_value(rcode_table, rcode, "???"));
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
request->reply->code = FR_RADIUS_CODE_ACCOUNTING_RESPONSE;
UPDATE_STATE(reply);
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
RESUME(accounting_request)
*/
return unlang_module_yield_to_section(p_result, request,
cs, RLM_MODULE_NOOP, resume_acct_type,
- NULL, rctx);
+ NULL, mctx->rctx);
}
#if 0
UPDATE_STATE(reply);
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
RESUME(recv_tacacs)
return unlang_module_yield_to_section(p_result, request,
subcs, RLM_MODULE_NOOP, resume_tacacs_type,
- NULL, rctx);
+ NULL, mctx->rctx);
}
break;
rlm_rcode_t rcode = request->rcode;
fr_pair_t *vp;
CONF_SECTION *cs;
- fr_dict_enum_value_t const *dv;
+ fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
process_ttls_t const *inst = talloc_get_type_abort_const(mctx->instance, process_ttls_t);
RDEBUG("Running 'authenticate %s' from file %s", cf_section_name2(cs), cf_filename(cs));
return unlang_module_yield_to_section(p_result, request,
cs, RLM_MODULE_NOOP, resume_auth_type,
- NULL, rctx);
+ NULL, mctx->rctx);
}
RESUME(auth_type)
fr_table_str_by_value(rcode_table, rcode, "???"));
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
/*
UPDATE_STATE(reply);
fr_assert(state->send != NULL);
- return state->send(p_result, mctx, request, rctx);
+ return state->send(p_result, mctx, request);
}
RESUME_NO_RCTX(access_accept)
projects / thirdparty / freeradius-server.git / commitdiff
