*/
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->inst->data, eap_aka_sim_module_conf_t);
+ eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_module_conf_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_aka_sim_mod_session_t *mod_session = talloc_get_type_abort(eap_session->opaque,
eap_aka_sim_mod_session_t);
*/
unlang_action_t eap_aka_sim_process(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->inst->data, eap_aka_sim_module_conf_t);
+ eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_module_conf_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_aka_sim_mod_session_t *mod_session = talloc_get_type_abort(eap_session->opaque,
eap_aka_sim_mod_session_t);
*/
RESUME(store_pseudonym)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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_pair_t *new;
eap_aka_sim_session_t *eap_aka_sim_session,
module_method_t next)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
fr_pair_t *vp;
fr_pair_t *new;
*/
RESUME(clear_pseudonym)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
pair_delete_request(attr_eap_aka_sim_next_pseudonym);
eap_aka_sim_session_t *eap_aka_sim_session,
module_method_t next)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
if (!fr_cond_assert(next)) return STATE_TRANSITION(common_failure_notification);
*/
STATE_GUARD(eap_failure)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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(common_failure_notification)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
fr_pair_t *subtype_vp = NULL;
subtype_vp = fr_pair_find_by_da(&request->request_pairs, NULL, attr_eap_aka_sim_subtype);
*/
STATE_GUARD(common_failure_notification)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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_GUARD(eap_success)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
STATE_SET(eap_success);
*/
STATE(common_success_notification)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
/*
* Because the server uses the AT_NOTIFICATION code "Success" (32768) to
*/
STATE_GUARD(common_success_notification)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
STATE_SET(common_success_notification);
*/
STATE(common_reauthentication)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
RESUME(load_pseudonym)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
pair_delete_request(attr_eap_aka_sim_next_reauth_id);
*/
RESUME(load_session)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
pair_delete_request(attr_session_id);
*/
STATE_GUARD(common_reauthentication)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
RESUME(recv_aka_synchronization_failure)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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(aka_challenge)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
STATE_GUARD(aka_challenge)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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(sim_challenge)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
STATE_GUARD(sim_challenge)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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_aka_identity_response)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
bool user_set_id_req;
*/
STATE(aka_identity)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
STATE_GUARD(aka_identity)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
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->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
STATE_GUARD(sim_start)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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);
*/
RESUME(recv_common_identity_response)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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 *eap_type, *method, *identity_type;
fr_aka_sim_method_hint_t running, hinted;
STATE(init)
{
eap_session_t *eap_session = eap_session_get(request->parent);
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, 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;
*/
unlang_action_t eap_aka_sim_state_machine_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
eap_aka_sim_session_t *eap_aka_sim_session = request_data_reference(request,
(void *)eap_aka_sim_state_machine_process,
0);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- fr_io_instance_t *inst = mctx->inst->data;
- CONF_SECTION *conf = mctx->inst->conf;
+ fr_io_instance_t *inst = mctx->mi->data;
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Find and bootstrap the application IO handler.
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- fr_io_instance_t *inst = mctx->inst->data;
- CONF_SECTION *conf = mctx->inst->conf;
+ fr_io_instance_t *inst = mctx->mi->data;
+ CONF_SECTION *conf = mctx->mi->conf;
fr_assert(inst->app_io != NULL);
if (mi->parent) module_detach_parent(UNCONST(module_instance_t *, mi->parent));
if (mi->exported->detach) {
- mi->exported->detach(&(module_detach_ctx_t){ .inst = mi });
+ mi->exported->detach(&(module_detach_ctx_t){ .mi = mi });
mi->detached = true;
}
}
if (mi->exported->thread_detach) {
mi->exported->thread_detach(&(module_thread_inst_ctx_t const ){
- .inst = ti->mi,
+ .mi = ti->mi,
.thread = ti->data,
.el = ti->el
});
*/
typedef int (*module_instantiate_t)(module_inst_ctx_t const *mctx);
-/** Wrapper structure around module_instance_t to allow us to pass more arguments into module_detach_ctx_t in future
- */
-typedef struct {
- module_instance_t const *inst; //!< Module instance to detach.
-} module_detach_ctx_t;
-
/** Module detach callback
*
* Is called just before the server exits, and after re-instantiation on HUP,
*
*/
typedef struct {
- module_instance_t const *inst; //!< Dynamic loader API handle for the module.
+ module_instance_t const *mi; //!< Instance of the module being instantiated.
void *thread; //!< Thread specific instance data.
void *env_data; //!< Per call environment data.
void *rctx; //!< Resume ctx that a module previously set.
*
*/
typedef struct {
- module_instance_t const *inst; //!< Dynamic loader API handle for the module.
+ module_instance_t const *mi; //!< Instance of the module being instantiated.
} module_inst_ctx_t;
+/** Temporary structure to hold arguments for detach calls
+ */
+typedef struct {
+ module_instance_t const *mi; //!< Module instance to detach.
+} module_detach_ctx_t;
+
/** Temporary structure to hold arguments for thread_instantiation calls
*
*/
typedef struct {
- module_instance_t const *inst; //!< Dynamic loader API handle for the module.
+ module_instance_t const *mi; //!< Instance of the module being instantiated.
///< Must come first to allow cast between
///< module_inst_ctx.
void *thread; //!< Thread instance data.
nmctx = talloc_zero(ctx, module_ctx_t);
if (unlikely(!nmctx)) return NULL;
- nmctx->inst = mctx->inst;
+ nmctx->mi = mctx->mi;
return nmctx;
}
nmctx = talloc_zero(ctx, module_ctx_t);
if (unlikely(!nmctx)) return NULL;
- nmctx->inst = mctx->inst;
+ nmctx->mi = mctx->mi;
nmctx->thread = mctx->thread;
return nmctx;
* @param[in] _env_data Call environment data.
* @param[in] _rctx Resume ctx (if any).
*/
-#define MODULE_CTX(_mi, _thread, _env_data, _rctx) &(module_ctx_t){ .inst = _mi, .thread = _thread, .env_data = _env_data, .rctx = _rctx }
+#define MODULE_CTX(_mi, _thread, _env_data, _rctx) &(module_ctx_t){ .mi = _mi, .thread = _thread, .env_data = _env_data, .rctx = _rctx }
/** Wrapper to create a module_ctx_t as a compound literal from a module_inst_ctx_t
*
*
* @param[in] _mctx to copy fields from.
*/
-#define MODULE_CTX_FROM_INST(_mctx) &(module_ctx_t){ .inst = (_mctx)->inst }
+#define MODULE_CTX_FROM_INST(_mctx) &(module_ctx_t){ .mi = (_mctx)->mi }
/** Wrapper to create a module_ctx_t as a compound literal from a module_inst_ctx_t
*
*
* @param[in] _mctx to copy fields from.
*/
-#define MODULE_CTX_FROM_THREAD_INST(_mctx) &(module_ctx_t){ .inst = (_mctx)->inst, .thread = (_mctx)->thread, .env_data = (_mctx)->env_data }
+#define MODULE_CTX_FROM_THREAD_INST(_mctx) &(module_ctx_t){ .mi = (_mctx)->mi, .thread = (_mctx)->thread, .env_data = (_mctx)->env_data }
/** Wrapper to create a module_inst_ctx_t as a compound literal
*
*
* @param[in] _mi of the module being called..
*/
-#define MODULE_INST_CTX(_mi) &(module_inst_ctx_t){ .inst = _mi }
+#define MODULE_INST_CTX(_mi) &(module_inst_ctx_t){ .mi = _mi }
/** Wrapper to create a module_thread_inst_ctx_t as a compound literal
*
* @param[in] _thread instance of the module being called.
* @param[in] _el Thread specific event list.
*/
-#define MODULE_THREAD_INST_CTX(_mi, _thread, _el) &(module_thread_inst_ctx_t){ .inst = _mi, .thread = _thread, .el = _el }
+#define MODULE_THREAD_INST_CTX(_mi, _thread, _el) &(module_thread_inst_ctx_t){ .mi = _mi, .thread = _thread, .el = _el }
/** Wrapper to create a module_inst_ctx_t as a comound listeral from a module_thread_ctx_t
*
*
* @param[in] _mctx to extract module_thread_inst_ctx_t from.
*/
-#define MODULE_THREAD_INST_CTX_FROM_INST_CTX(_mctx) &(module_ctx_t){ .inst = (_mctx)->inst }
+#define MODULE_THREAD_INST_CTX_FROM_INST_CTX(_mctx) &(module_ctx_t){ .mi = (_mctx)->mi }
#ifdef __cplusplus
}
{
CONF_SECTION *cs;
fr_process_state_t const *state;
- PROCESS_INST const *inst = mctx->inst->data;
+ PROCESS_INST const *inst = mctx->mi->data;
PROCESS_TRACE;
fr_pair_t *vp;
CONF_SECTION *cs;
fr_process_state_t const *state;
- PROCESS_INST const *inst = mctx->inst->data;
+ PROCESS_INST const *inst = mctx->mi->data;
PROCESS_TRACE;
rlm_rcode_t rcode = *p_result;
CONF_SECTION *cs;
fr_process_state_t const *state;
- PROCESS_INST const *inst = mctx->inst->data;
+ PROCESS_INST const *inst = mctx->mi->data;
PROCESS_TRACE;
{
rlm_rcode_t rcode = *p_result;
CONF_SECTION *cs;
- PROCESS_INST const *inst = mctx->inst->data;
+ PROCESS_INST const *inst = mctx->mi->data;
switch (rcode) {
case RLM_MODULE_OK:
static inline unlang_action_t new_client(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
CONF_SECTION *cs;
- PROCESS_INST const *inst = mctx->inst->data;
+ PROCESS_INST const *inst = mctx->mi->data;
PROCESS_TRACE;
fr_assert(inst->sections.new_client != NULL);
{
unlang_module_t *single = unlang_generic_to_module(c);
- DEBUG("%.*s%s", depth, unlang_spaces, single->instance->name);
+ DEBUG("%.*s%s", depth, unlang_spaces, single->mi->name);
}
break;
}
MEM(single = talloc_zero(parent, unlang_module_t));
- single->instance = inst;
+ single->mi = inst;
single->method = method;
c = unlang_module_to_generic(single);
c->parent = parent;
single->call_env = call_env_alloc(single, single->self.name, method_env,
unlang_ctx->rules, inst->conf,
unlang_ctx->section_name1, unlang_ctx->section_name2,
- single->instance->data);
+ single->mi->data);
if (!single->call_env) {
error:
talloc_free(c);
.request = request,
.fd = -1,
.timeout = callback,
- .mi = mc->instance,
+ .mi = mc->mi,
.thread = state->thread,
.env_data = state->env_data,
.rctx = rctx
ev->fd_read = read;
ev->fd_write = write;
ev->fd_error = error;
- ev->mi = mc->instance;
+ ev->mi = mc->mi;
ev->thread = state->thread;
ev->env_data = state->env_data;
ev->rctx = rctx;
*
* @param[out] p_result Where to write the result of calling the module.
* @param[in] request The current request.
- * @param[in] module_instance Instance of the module to call.
+ * @param[in] mi Instance of the module to call.
* @param[in] method to call.
* @param[in] top_frame Set to UNLANG_TOP_FRAME if the interpreter should return.
* Set to UNLANG_SUB_FRAME if the interprer should continue.
* - -1 on failure.
*/
int unlang_module_push(rlm_rcode_t *p_result, request_t *request,
- module_instance_t *module_instance, module_method_t method, bool top_frame)
+ module_instance_t *mi, module_method_t method, bool top_frame)
{
unlang_stack_t *stack = request->stack;
unlang_stack_frame_t *frame;
*mc = (unlang_module_t){
.self = {
.type = UNLANG_TYPE_MODULE,
- .name = module_instance->name,
- .debug_name = module_instance->name,
+ .name = mi->name,
+ .debug_name = mi->name,
.actions = {
.actions = {
[RLM_MODULE_REJECT] = 0,
.retry = RETRY_INIT,
},
},
- .instance = module_instance,
+ .mi = mi,
.method = method
};
state = frame->state;
*state = (unlang_frame_state_module_t){
.p_result = p_result,
- .thread = module_thread(module_instance)
+ .thread = module_thread(mi)
};
/*
state = talloc_get_type_abort(frame->state, unlang_frame_state_module_t);
return resume(p_result,
- MODULE_CTX(mc->instance, module_thread(mc->instance)->data,
+ MODULE_CTX(mc->mi, module_thread(mc->mi)->data,
state->env_data, rctx),
request);
}
* Async calls can't push anything onto the unlang stack, so we just use a local "caller" here.
*/
caller = request->module;
- request->module = mc->instance->name;
- safe_lock(mc->instance);
- if (!(action & state->sigmask)) state->signal(MODULE_CTX(mc->instance, state->thread->data, state->env_data, state->rctx), request, action);
- safe_unlock(mc->instance);
+ request->module = mc->mi->name;
+ safe_lock(mc->mi);
+ if (!(action & state->sigmask)) state->signal(MODULE_CTX(mc->mi, state->thread->data, state->env_data, state->rctx), request, action);
+ safe_unlock(mc->mi);
request->module = caller;
/*
/*
* Lock is noop unless instance->mutex is set.
*/
- safe_lock(mc->instance);
- ua = resume(&state->rcode, MODULE_CTX(mc->instance, state->thread->data,
+ safe_lock(mc->mi);
+ ua = resume(&state->rcode, MODULE_CTX(mc->mi, state->thread->data,
state->env_data, state->rctx), request);
- safe_unlock(mc->instance);
+ safe_unlock(mc->mi);
if (request->master_state == REQUEST_STOP_PROCESSING) ua = UNLANG_ACTION_STOP_PROCESSING;
switch (ua) {
case UNLANG_ACTION_STOP_PROCESSING:
- RWARN("Module %s or worker signalled to stop processing request", mc->instance->module->exported->name);
+ RWARN("Module %s or worker signalled to stop processing request", mc->mi->module->exported->name);
if (state->p_result) *state->p_result = state->rcode;
state->thread->active_callers--;
*p_result = state->rcode;
fr_assert(mc);
RDEBUG4("[%i] %s - %s (%s)", stack_depth_current(request), __FUNCTION__,
- mc->instance->module->exported->name, mc->instance->name);
+ mc->mi->module->exported->name, mc->mi->name);
state->p_result = NULL;
/*
* Return administratively configured return code
*/
- if (mc->instance->force) {
- state->rcode = mc->instance->code;
+ if (mc->mi->force) {
+ state->rcode = mc->mi->code;
ua = UNLANG_ACTION_CALCULATE_RESULT;
goto done;
}
/*
* Grab the thread/module specific data if any exists.
*/
- state->thread = module_thread(mc->instance);
+ state->thread = module_thread(mc->mi);
fr_assert(state->thread != NULL);
/*
*/
if (fr_time_delta_ispos(frame->instruction->actions.retry.irt)) now = fr_time();
- request->module = mc->instance->name;
- safe_lock(mc->instance); /* Noop unless instance->mutex set */
+ request->module = mc->mi->name;
+ safe_lock(mc->mi); /* Noop unless instance->mutex set */
ua = mc->method(&state->rcode,
- MODULE_CTX(mc->instance, state->thread->data, state->env_data, NULL),
+ MODULE_CTX(mc->mi, state->thread->data, state->env_data, NULL),
request);
- safe_unlock(mc->instance);
+ safe_unlock(mc->mi);
if (request->master_state == REQUEST_STOP_PROCESSING) ua = UNLANG_ACTION_STOP_PROCESSING;
* must have been blocked.
*/
case UNLANG_ACTION_STOP_PROCESSING:
- RWARN("Module %s became unblocked", mc->instance->name);
+ RWARN("Module %s became unblocked", mc->mi->name);
if (state->p_result) *state->p_result = state->rcode;
*p_result = state->rcode;
request->module = state->previous_module;
*/
typedef struct {
unlang_t self; //!< Common fields in all #unlang_t tree nodes.
- module_instance_t *instance; //!< Global instance of the module we're calling.
+ module_instance_t *mi; //!< Global instance of the module we're calling.
module_method_t method; //!< The entry point into the module.
call_env_t const *call_env; //!< The per call parsed call environment.
} unlang_module_t;
* Name xlats other than those which are just the module instance
* as <instance name>.<function name>
*/
- if (mctx && name != mctx->inst->name) {
- snprintf(inst_name, sizeof(inst_name), "%s.%s", mctx->inst->name, name);
+ if (mctx && name != mctx->mi->name) {
+ snprintf(inst_name, sizeof(inst_name), "%s.%s", mctx->mi->name, name);
name = inst_name;
}
xlat_t *c;
char inst_name[256];
- fr_assert_msg(name != mctx->inst->name, "`name` must not be the same as the module "
+ fr_assert_msg(name != mctx->mi->name, "`name` must not be the same as the module "
"instance name. Pass a NULL `name` arg if this is required");
if (!name) {
- name = mctx->inst->name;
+ name = mctx->mi->name;
} else {
- if ((size_t)snprintf(inst_name, sizeof(inst_name), "%s.%s", mctx->inst->name, name) >= sizeof(inst_name)) {
+ if ((size_t)snprintf(inst_name, sizeof(inst_name), "%s.%s", mctx->mi->name, name) >= sizeof(inst_name)) {
ERROR("%s: Instance name too long", __FUNCTION__);
return NULL;
}
c;
c = fr_rb_iter_next_inorder(&iter)) {
if (!c->mctx) continue;
- if (c->mctx->inst != inst) continue;
+ if (c->mctx->mi != inst) continue;
fr_rb_iter_delete_inorder(&iter);
}
module_ctx_t *mctx;
mctx = module_ctx_from_inst(xt, call->func->mctx);
- mctx->thread = module_rlm_thread_by_data(mctx->inst->data)->data;
+ mctx->thread = module_rlm_thread_by_data(mctx->mi->data)->data;
xt->mctx = mctx;
}
if (call->func->call_env_method) {
fr_assert_msg(call->func->call_env_method->inst_size,
"Method environment for module %s, xlat %s declared, "
- "but no inst_size set", call->func->mctx->inst->name, call->func->name);
+ "but no inst_size set", call->func->mctx->mi->name, call->func->name);
/*
* FIXME - This is wrong, we should pass in the tmpl_rule_t
.dict_def = call->dict,
.list_def = request_attr_request
}
- }, call->func->mctx->inst->conf, NULL, NULL, call->func->mctx->inst->data);
+ }, call->func->mctx->mi->conf, NULL, NULL, call->func->mctx->mi->data);
if (!xi->call_env) {
talloc_free(xi);
return NULL;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_arp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_arp_t);
+ proto_arp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_arp_t);
if (!inst->num_messages) inst->num_messages = 256;
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_arp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_arp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_arp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_arp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
module_instance_t *parent_inst;
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_arp_ethernet_t *inst = talloc_get_type_abort(mctx->inst->data, proto_arp_ethernet_t);
+ proto_arp_ethernet_t *inst = talloc_get_type_abort(mctx->mi->data, proto_arp_ethernet_t);
- inst->cs = mctx->inst->conf;
+ inst->cs = mctx->mi->conf;
return 0;
}
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_bfd_t *inst = talloc_get_type_abort(mctx->inst->data, proto_bfd_t);
+ proto_bfd_t *inst = talloc_get_type_abort(mctx->mi->data, proto_bfd_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_bfd_t *inst = talloc_get_type_abort(mctx->inst->data, proto_bfd_t);
+ proto_bfd_t *inst = talloc_get_type_abort(mctx->mi->data, proto_bfd_t);
CONF_SECTION *server;
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->io.server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
/*
* No IO module, it's an empty listener.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
server = inst->io.server_cs;
inst->peers = cf_data_value(cf_data_find(server, fr_rb_tree_t, "peers"));
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_bfd_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_bfd_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_bfd_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_bfd_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_control_t *inst = talloc_get_type_abort(mctx->inst->data, proto_control_t);
+ proto_control_t *inst = talloc_get_type_abort(mctx->mi->data, proto_control_t);
fr_assert(inst->io.submodule != NULL);
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_control_t *inst = talloc_get_type_abort(mctx->inst->data, proto_control_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_control_t *inst = talloc_get_type_abort(mctx->mi->data, proto_control_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Ensure that the server CONF_SECTION is always set.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_control_unix_t *inst = talloc_get_type_abort(mctx->inst->data, proto_control_unix_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_control_unix_t *inst = talloc_get_type_abort(mctx->mi->data, proto_control_unix_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->cs = conf;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_cron_t *inst = talloc_get_type_abort(mctx->inst->data, proto_cron_t);
+ proto_cron_t *inst = talloc_get_type_abort(mctx->mi->data, proto_cron_t);
fr_assert(inst->io.submodule);
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_cron_t *inst = talloc_get_type_abort(mctx->inst->data, proto_cron_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_cron_t *inst = talloc_get_type_abort(mctx->mi->data, proto_cron_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Ensure that the server CONF_SECTION is always set.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_cron_crontab_t *inst = talloc_get_type_abort(mctx->inst->data, proto_cron_crontab_t);
+ proto_cron_crontab_t *inst = talloc_get_type_abort(mctx->mi->data, proto_cron_crontab_t);
- inst->parent = talloc_get_type_abort(mctx->inst->parent->data, proto_cron_t);
- inst->cs = mctx->inst->conf;
+ inst->parent = talloc_get_type_abort(mctx->mi->parent->data, proto_cron_t);
+ inst->cs = mctx->mi->conf;
return 0;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_cron_crontab_t *inst = talloc_get_type_abort(mctx->inst->data, proto_cron_crontab_t);
- CONF_SECTION *conf = mctx->inst->data;
+ proto_cron_crontab_t *inst = talloc_get_type_abort(mctx->mi->data, proto_cron_crontab_t);
+ CONF_SECTION *conf = mctx->mi->data;
fr_client_t *client;
fr_pair_t *vp;
FILE *fp;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_detail_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_detail_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Instantiate the I/O module. But DON'T instantiate the
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_detail_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_detail_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* The listener is inside of a virtual server.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_detail_file_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_file_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_detail_file_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_file_t);
+ CONF_SECTION *conf = mctx->mi->conf;
module_instance_t const *mi;
char *p;
* so we can find out what the parent of our instance
* was.
*/
- mi = mctx->inst;
+ mi = mctx->mi;
#ifndef __linux__
/*
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_detail_file_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_file_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_detail_file_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_file_t);
+ CONF_SECTION *conf = mctx->mi->conf;
pthread_mutex_lock(&detail_file_mutex);
if (!detail_file_tree) {
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_detail_work_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_work_t);
+ proto_detail_work_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_work_t);
fr_client_t *client;
client = inst->client = talloc_zero(inst, fr_client_t);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_detail_work_t *inst = talloc_get_type_abort(mctx->inst->data, proto_detail_work_t);
- CONF_SECTION *cs = mctx->inst->conf;
- module_instance_t const *mi = mctx->inst;
+ proto_detail_work_t *inst = talloc_get_type_abort(mctx->mi->data, proto_detail_work_t);
+ CONF_SECTION *cs = mctx->mi->conf;
+ module_instance_t const *mi = mctx->mi;
inst->parent = talloc_get_type_abort(mi->parent->data, proto_detail_t);
inst->cs = cs;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_dhcpv4_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv4_t);
+ proto_dhcpv4_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv4_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dhcpv4_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv4_t);
+ proto_dhcpv4_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv4_t);
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->io.server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
fr_assert(dict_dhcpv4 != NULL);
fr_assert(attr_message_type != NULL);
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dhcpv4_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv4_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_dhcpv4_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv4_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_dhcpv6_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv6_t);
+ proto_dhcpv6_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv6_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dhcpv6_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv6_t);
+ proto_dhcpv6_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv6_t);
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->io.server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
fr_assert(dict_dhcpv6 != NULL);
fr_assert(attr_packet_type != NULL);
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dhcpv6_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dhcpv6_udp_t);
+ proto_dhcpv6_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dhcpv6_udp_t);
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
fr_client_t *client;
- CONF_SECTION *conf = mctx->inst->conf;
+ CONF_SECTION *conf = mctx->mi->conf;
inst->cs = conf;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_dns_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dns_t);
+ proto_dns_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dns_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dns_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dns_t);
+ proto_dns_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dns_t);
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_section_find_parent(mctx->inst->conf, "server", CF_IDENT_ANY);
+ inst->io.server_cs = cf_section_find_parent(mctx->mi->conf, "server", CF_IDENT_ANY);
fr_assert(dict_dns != NULL);
fr_assert(attr_packet_type != NULL);
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_dns_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_dns_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_dns_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_dns_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_SECTION *server_cs;
fr_client_t *client;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_ldap_sync_t *inst = talloc_get_type_abort(mctx->inst->data, proto_ldap_sync_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_ldap_sync_t *inst = talloc_get_type_abort(mctx->mi->data, proto_ldap_sync_t);
+ CONF_SECTION *conf = mctx->mi->conf;
CONF_SECTION *sync_cs;
sync_config_t *sync_conf;
size_t i;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_ldap_sync_t *inst = talloc_get_type_abort(mctx->inst->data, proto_ldap_sync_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_ldap_sync_t *inst = talloc_get_type_abort(mctx->mi->data, proto_ldap_sync_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->server_cs = cf_item_to_section(cf_parent(conf));
inst->cs = conf;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_ldap_sync_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, proto_ldap_sync_ldap_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_ldap_sync_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, proto_ldap_sync_ldap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
char const *server;
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_ldap_sync_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, proto_ldap_sync_ldap_t);
- CONF_SECTION *conf = mctx->inst->conf;
- module_instance_t const *mi = mctx->inst;
+ proto_ldap_sync_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, proto_ldap_sync_ldap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
+ module_instance_t const *mi = mctx->mi;
inst->parent = talloc_get_type_abort(mi->parent->data, proto_ldap_sync_t);
inst->cs = conf;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_load_t *inst = talloc_get_type_abort(mctx->inst->data, proto_load_t);
+ proto_load_t *inst = talloc_get_type_abort(mctx->mi->data, proto_load_t);
fr_assert(inst->io.submodule);
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_load_t *inst = talloc_get_type_abort(mctx->inst->data, proto_load_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_load_t *inst = talloc_get_type_abort(mctx->mi->data, proto_load_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Ensure that the server CONF_SECTION is always set.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_load_step_t *inst = talloc_get_type_abort(mctx->inst->data, proto_load_step_t);
- CONF_SECTION *conf = mctx->inst->conf;
- module_instance_t const *mi = mctx->inst;
+ proto_load_step_t *inst = talloc_get_type_abort(mctx->mi->data, proto_load_step_t);
+ CONF_SECTION *conf = mctx->mi->conf;
+ module_instance_t const *mi = mctx->mi;
inst->parent = talloc_get_type_abort(mi->parent->data, proto_load_t);
inst->cs = conf;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_load_step_t *inst = talloc_get_type_abort(mctx->inst->data, proto_load_step_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_load_step_t *inst = talloc_get_type_abort(mctx->mi->data, proto_load_step_t);
+ CONF_SECTION *conf = mctx->mi->conf;
fr_client_t *client;
fr_pair_t *vp;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_radius_t *inst = talloc_get_type_abort(mctx->inst->data, proto_radius_t);
+ proto_radius_t *inst = talloc_get_type_abort(mctx->mi->data, proto_radius_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_radius_t *inst = talloc_get_type_abort(mctx->inst->data, proto_radius_t);
+ proto_radius_t *inst = talloc_get_type_abort(mctx->mi->data, proto_radius_t);
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->io.server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
/*
* No IO module, it's an empty listener.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_radius_tcp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_radius_tcp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_radius_tcp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_radius_tcp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t i, num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_radius_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_radius_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_radius_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_radius_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_tacacs_t *inst = talloc_get_type_abort(mctx->inst->data, proto_tacacs_t);
+ proto_tacacs_t *inst = talloc_get_type_abort(mctx->mi->data, proto_tacacs_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_tacacs_t *inst = talloc_get_type_abort(mctx->inst->data, proto_tacacs_t);
+ proto_tacacs_t *inst = talloc_get_type_abort(mctx->mi->data, proto_tacacs_t);
/*
* Ensure that the server CONF_SECTION is always set.
*/
- inst->io.server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->io.server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
fr_assert(dict_tacacs != NULL);
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_tacacs_tcp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_tacacs_tcp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- proto_vmps_t *inst = talloc_get_type_abort(mctx->inst->data, proto_vmps_t);
+ proto_vmps_t *inst = talloc_get_type_abort(mctx->mi->data, proto_vmps_t);
/*
* No IO module, it's an empty listener.
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_vmps_t *inst = talloc_get_type_abort(mctx->inst->data, proto_vmps_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_vmps_t *inst = talloc_get_type_abort(mctx->mi->data, proto_vmps_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Ensure that the server CONF_SECTION is always set.
/*
* We will need this for dynamic clients and connected sockets.
*/
- inst->io.mi = mctx->inst;
+ inst->io.mi = mctx->mi;
/*
* Bootstrap the master IO handler.
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- proto_vmps_udp_t *inst = talloc_get_type_abort(mctx->inst->data, proto_vmps_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ proto_vmps_udp_t *inst = talloc_get_type_abort(mctx->mi->data, proto_vmps_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
size_t num;
CONF_ITEM *ci;
CONF_SECTION *server_cs;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_always_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_always_t);
+ rlm_always_t *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_always_t);
module_instance_t *mi = inst->mi;
char const *status;
char const *p;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_always_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_always_t);
+ rlm_always_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_always_t);
xlat_t *xlat;
- inst->mi = module_rlm_by_name(NULL, mctx->inst->name);
+ inst->mi = module_rlm_by_name(NULL, mctx->mi->name);
if (!inst->mi) {
- cf_log_err(mctx->inst->conf, "Can't find the module instance data for this module: %s", mctx->inst->name);
+ cf_log_err(mctx->mi->conf, "Can't find the module instance data for this module: %s", mctx->mi->name);
return -1;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_always_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_always_t);
+ rlm_always_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_always_t);
/*
* Convert the rcode string to an int
*/
inst->rcode = fr_table_value_by_str(rcode_table, inst->rcode_str, RLM_MODULE_NOT_SET);
if (inst->rcode == RLM_MODULE_NOT_SET) {
- cf_log_err(mctx->inst->conf, "rcode value \"%s\" is invalid", inst->rcode_str);
+ cf_log_err(mctx->mi->conf, "rcode value \"%s\" is invalid", inst->rcode_str);
return -1;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_always_return(rlm_rcode_t *p_result, module_ctx_t const *mctx, UNUSED request_t *request)
{
- rlm_always_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_always_t);
+ rlm_always_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_always_t);
RETURN_MODULE_RCODE(inst->rcode);
}
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_attr_filter_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_attr_filter_t);
+ rlm_attr_filter_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_attr_filter_t);
int rcode;
pairlist_list_init(&inst->attrs);
module_ctx_t const *mctx, request_t *request,
fr_packet_t *packet, fr_pair_list_t *list)
{
- rlm_attr_filter_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_attr_filter_t);
+ rlm_attr_filter_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_attr_filter_t);
fr_pair_list_t output;
PAIR_LIST *pl = NULL;
int found = 0;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <talloc.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *args)
{
- rlm_brotli_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_brotli_t);
+ rlm_brotli_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_brotli_t);
fr_value_box_t const *data_vb;
BrotliEncoderState *state;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *args)
{
- rlm_brotli_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_brotli_t);
+ rlm_brotli_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_brotli_t);
fr_value_box_t const *data_vb;
BrotliDecoderState *state;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_cache_memcached_t *driver = talloc_get_type_abort(mctx->inst->data, rlm_cache_memcached_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_cache_memcached_t *driver = talloc_get_type_abort(mctx->mi->data, rlm_cache_memcached_t);
+ CONF_SECTION *conf = mctx->mi->conf;
memcached_return_t ret;
char buffer[256];
- rlm_cache_config_t const *config = talloc_get_type_abort(mctx->inst->parent->data, rlm_cache_config_t);
+ rlm_cache_config_t const *config = talloc_get_type_abort(mctx->mi->parent->data, rlm_cache_config_t);
fr_assert(config);
- snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", mctx->inst->parent->name);
+ snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", mctx->mi->parent->name);
ret = libmemcached_check_configuration(driver->options, talloc_array_length(driver->options) -1,
buffer, sizeof(buffer));
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(mctx->inst->data, rlm_cache_rbtree_t);
+ rlm_cache_rbtree_t *driver = talloc_get_type_abort(mctx->mi->data, rlm_cache_rbtree_t);
if (driver->cache) {
fr_rb_iter_inorder_t iter;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_cache_rbtree_t *driver = talloc_get_type_abort(mctx->inst->data, rlm_cache_rbtree_t);
+ rlm_cache_rbtree_t *driver = talloc_get_type_abort(mctx->mi->data, rlm_cache_rbtree_t);
int ret;
/*
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_cache_redis_t *driver = talloc_get_type_abort(mctx->inst->data, rlm_cache_redis_t);
+ rlm_cache_redis_t *driver = talloc_get_type_abort(mctx->mi->data, rlm_cache_redis_t);
char buffer[256];
buffer[0] = '\0';
- if (cf_section_rules_push(mctx->inst->conf, driver_config) < 0) return -1;
- if (cf_section_parse(driver, driver, mctx->inst->conf) < 0) return -1;
+ if (cf_section_rules_push(mctx->mi->conf, driver_config) < 0) return -1;
+ if (cf_section_parse(driver, driver, mctx->mi->conf) < 0) return -1;
- snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", mctx->inst->parent->name);
+ snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", mctx->mi->parent->name);
- driver->cluster = fr_redis_cluster_alloc(driver, mctx->inst->conf, &driver->conf, true,
+ driver->cluster = fr_redis_cluster_alloc(driver, mctx->mi->conf, &driver->conf, true,
buffer, "modules.cache.pool", NULL);
if (!driver->cluster) {
ERROR("Cluster failure");
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
static unlang_action_t CC_HINT(nonnull) mod_cache_it(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_cache_entry_t *c = NULL;
- rlm_cache_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_cache_handle_t *handle;
request_t *request, fr_value_box_list_t *in)
{
rlm_cache_entry_t *c = NULL;
- rlm_cache_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_cache_t);
+ rlm_cache_t *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(xctx->env_data, cache_call_env_t);
rlm_cache_handle_t *handle = NULL;
{
rlm_cache_entry_t *c = NULL;
- rlm_cache_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_cache_t);
+ rlm_cache_t *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(xctx->env_data, cache_call_env_t);
rlm_cache_handle_t *handle = NULL;
*/
static unlang_action_t CC_HINT(nonnull) mod_method_status(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
rlm_cache_entry_t *entry = NULL;
*/
static unlang_action_t CC_HINT(nonnull) mod_method_load(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
rlm_cache_entry_t *entry = NULL;
*/
static unlang_action_t CC_HINT(nonnull) mod_method_update(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
fr_time_delta_t ttl;
*/
static unlang_action_t CC_HINT(nonnull) mod_method_store(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
fr_time_delta_t ttl;
*/
static unlang_action_t CC_HINT(nonnull) mod_method_clear(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
rlm_cache_entry_t *entry = NULL;
rlm_cache_handle_t *handle = NULL;
- DEBUG3("Calling %s.clear", mctx->inst->name);
+ DEBUG3("Calling %s.clear", mctx->mi->name);
if (env->key->vb_length == 0) {
REDEBUG("Zero length key string is invalid");
*/
static unlang_action_t CC_HINT(nonnull) mod_method_ttl(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_cache_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
cache_call_env_t *env = talloc_get_type_abort(mctx->env_data, cache_call_env_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
fr_time_delta_t ttl;
rlm_cache_handle_t *handle = NULL;
fr_pair_t *vp;
- DEBUG3("Calling %s.ttl", mctx->inst->name);
+ DEBUG3("Calling %s.ttl", mctx->mi->name);
if (env->key->vb_length == 0) {
REDEBUG("Zero length key string is invalid");
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_cache_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
+ rlm_cache_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
/*
* We need to explicitly free all children, so if the driver
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_cache_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_cache_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!fr_time_delta_ispos(inst->config.ttl)) {
cf_log_err(conf, "Must set 'ttl' to non-zero");
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_cache_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_cache_t );
+ rlm_cache_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_cache_t );
xlat_t *xlat;
inst->driver = (rlm_cache_driver_t const *)inst->driver_submodule->module->exported;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/password.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_chap_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_chap_t);
+ rlm_chap_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_chap_t);
uint8_t chap_password[1 + FR_CHAP_CHALLENGE_LENGTH];
fr_value_box_t *vb;
uint8_t const *challenge;
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
fr_pair_t *vp;
- rlm_chap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_chap_t);
+ rlm_chap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_chap_t);
chap_autz_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, chap_autz_call_env_t);
if (fr_pair_find_by_da(&request->control_pairs, NULL, attr_auth_type) != NULL) {
- RDEBUG3("Auth-Type is already set. Not setting 'Auth-Type := %s'", mctx->inst->name);
+ RDEBUG3("Auth-Type is already set. Not setting 'Auth-Type := %s'", mctx->mi->name);
RETURN_MODULE_NOOP;
}
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup CHAP authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_chap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_chap_t);
+ rlm_chap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_chap_t);
fr_pair_t *known_good;
uint8_t pass_str[1 + FR_CHAP_CHALLENGE_LENGTH];
chap_auth_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, chap_auth_call_env_t);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_chap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_chap_t);
+ rlm_chap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_chap_t);
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. CHAP authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
return 0;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_cipher_t);
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
char const *msg;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_cipher_t);
rlm_cipher_rsa_thread_inst_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_cipher_rsa_thread_inst_t);
uint8_t const *sig;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_cipher_t);
char const *md_name;
EVP_MD const *md;
size_t md_len;
xlat_ctx_t const *xctx,
request_t *request, UNUSED fr_value_box_list_t *in)
{
- rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_cipher_t);
ASN1_INTEGER const *serial;
fr_value_box_t *vb;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_cipher_t);
char const *attribute = fr_value_box_list_head(in)->vb_strvalue;
fr_value_box_t *vb;
*/
static int cipher_rsa_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_cipher_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_cipher_t);
rlm_cipher_rsa_thread_inst_t *ti = talloc_get_type_abort(mctx->thread, rlm_cipher_rsa_thread_inst_t);
/*
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_cipher_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_cipher_t);
+ rlm_cipher_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_cipher_t);
switch (inst->type) {
case RLM_CIPHER_TYPE_RSA:
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_cipher_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_cipher_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_cipher_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_cipher_t);
+ CONF_SECTION *conf = mctx->mi->conf;
switch (inst->type) {
case RLM_CIPHER_TYPE_RSA:
*/
static unlang_action_t mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_couchbase_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_couchbase_t); /* our module instance */
+ rlm_couchbase_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_couchbase_t); /* our module instance */
rlm_couchbase_handle_t *handle = NULL; /* connection pool handle */
char buffer[MAX_KEY_SIZE];
char const *dockey; /* our document key */
*/
static unlang_action_t mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_couchbase_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_couchbase_t); /* our module instance */
+ rlm_couchbase_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_couchbase_t); /* our module instance */
rlm_couchbase_handle_t *handle = NULL; /* connection pool handle */
rlm_rcode_t rcode = RLM_MODULE_OK; /* return code */
fr_pair_t *vp; /* radius value pair linked list */
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_couchbase_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_couchbase_t);
+ rlm_couchbase_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_couchbase_t);
if (inst->map) json_object_put(inst->map);
if (inst->pool) fr_pool_free(inst->pool);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_couchbase_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_couchbase_t); /* our module instance */
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_couchbase_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_couchbase_t); /* our module instance */
+ CONF_SECTION *conf = mctx->mi->conf;
{
char *server, *p;
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_csv_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_csv_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_csv_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_csv_t);
+ CONF_SECTION *conf = mctx->mi->conf;
int i;
char const *p;
char *q;
/*
* And register the `map csv <key> { ... }` function.
*/
- map_proc_register(inst, mctx->inst->name, mod_map_proc, csv_maps_verify, 0, 0);
+ map_proc_register(inst, mctx->mi->name, mod_map_proc, csv_maps_verify, 0, 0);
return 0;
}
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_csv_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_csv_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_csv_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_csv_t);
+ CONF_SECTION *conf = mctx->mi->conf;
CONF_SECTION *cs;
int lineno;
FILE *fp;
static unlang_action_t CC_HINT(nonnull) mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_csv_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_csv_t);
+ rlm_csv_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_csv_t);
rlm_rcode_t rcode;
ssize_t slen;
fr_value_box_t *key;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_date_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_date_t);
+ rlm_date_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_date_t);
struct tm tminfo;
fr_value_box_t *arg = fr_value_box_list_head(in);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_date_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_date_t );
+ rlm_date_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_date_t );
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, xlat_date_convert, FR_TYPE_VOID);
static unlang_action_t CC_HINT(nonnull) mod_delay(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_delay_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_delay_t);
+ rlm_delay_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_delay_t);
fr_time_delta_t delay;
fr_time_t resume_at, *yielded_at;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_delay_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_delay_t);
+ rlm_delay_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_delay_t);
fr_time_t resume_at, *yielded_at;
fr_value_box_t *delay = fr_value_box_list_head(in);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_delay_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_delay_t);
+ rlm_delay_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_delay_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, xlat_delay, FR_TYPE_TIME_DELTA);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_detail_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_detail_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_detail_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_detail_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->ef = module_rlm_exfile_init(inst, conf, 256, fr_time_delta_from_sec(30), inst->locking, NULL, NULL);
if (!inst->ef) {
int outfd, dupfd;
FILE *outfp = NULL;
- rlm_detail_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_detail_t);
+ rlm_detail_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_detail_t);
RDEBUG2("%s expands to %pV", env->filename_tmpl->name, &env->filename);
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_dhcpv4_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_dhcpv4_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_dhcpv4_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_dhcpv4_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Ensure that we have a destination address.
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_dhcpv4_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_dhcpv4_t);
+ rlm_dhcpv4_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_dhcpv4_t);
rlm_dhcpv4_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_dhcpv4_thread_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ CONF_SECTION *conf = mctx->mi->conf;
t->buffer = talloc_array(t, uint8_t, inst->max_packet_size);
if (!t->buffer) {
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_digest_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_digest_t);
+ rlm_digest_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_digest_t);
fr_pair_t *vp;
/*
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup Digest authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_digest_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_digest_t);
+ rlm_digest_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_digest_t);
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. Digest authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
return 0;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
eap_type_t last_type,
eap_type_data_t *nak)
{
- rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_eap_t);
unsigned int i, s_i = 0;
fr_pair_t *vp = NULL;
eap_type_t method = FR_EAP_METHOD_INVALID;
*/
static unlang_action_t eap_method_select(rlm_rcode_t *p_result, module_ctx_t const *mctx, eap_session_t *eap_session)
{
- rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_eap_t);
eap_type_data_t *type = &eap_session->this_round->response->type;
request_t *request = eap_session->request;
static unlang_action_t mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_eap_t);
eap_session_t *eap_session;
eap_packet_raw_t *eap_packet;
unlang_action_t ua;
*/
static unlang_action_t mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_eap_t);
int status;
#ifdef WITH_PROXY
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup EAP authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
* Was *NOT* an EAP-Failure, so we now need to turn it into one.
*/
REDEBUG("Request rejected after last call to module \"%s\", transforming response into EAP-Failure",
- mctx->inst->name);
+ mctx->mi->name);
eap_fail(eap_session); /* Compose an EAP failure */
eap_session_destroy(&eap_session); /* Free the EAP session, and dissociate it from the request */
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_t);
size_t i;
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. EAP authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_eap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_t);
+ rlm_eap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_t);
size_t i, j, loaded, count = 0;
/*
* allowed by the config.
*/
if (inst->default_method_is_set && !inst->methods[inst->default_method].submodule) {
- cf_log_err_by_child(mctx->inst->conf, "default_eap_type", "EAP-Type \"%s\" is not enabled",
+ cf_log_err_by_child(mctx->mi->conf, "default_eap_type", "EAP-Type \"%s\" is not enabled",
eap_type2name(inst->default_method));
return -1;
}
if (count == 0) {
- cf_log_err(mctx->inst->conf, "No EAP method(s) configured, module cannot do anything");
+ cf_log_err(mctx->mi->conf, "No EAP method(s) configured, module cannot do anything");
return -1;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_module_conf_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_module_conf_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->type = rlm_eap_aka.provides[0];
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_module_conf_t);
+ eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_module_conf_t);
inst->type = rlm_eap_aka_prime.provides[0];
*/
static unlang_action_t mod_session_init(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_fast_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_eap_fast_t);
+ rlm_eap_fast_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_eap_fast_t);
rlm_eap_fast_thread_t *thread = talloc_get_type_abort(mctx->thread, rlm_eap_fast_thread_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_tls_session_t *eap_tls_session;
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_eap_fast_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_fast_t);
+ rlm_eap_fast_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_fast_t);
rlm_eap_fast_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_fast_thread_t);
t->ssl_ctx = fr_tls_ctx_alloc(inst->tls_conf, false);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_fast_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_fast_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_eap_fast_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_fast_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!virtual_server_find(inst->virtual_server)) {
- cf_log_err_by_child(mctx->inst->conf, "virtual_server", "Unknown virtual server '%s'",
+ cf_log_err_by_child(mctx->mi->conf, "virtual_server", "Unknown virtual server '%s'",
inst->virtual_server);
return -1;
}
*/
static unlang_action_t mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_gtc_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_gtc_t);
+ rlm_eap_gtc_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_gtc_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_round_t *eap_round = eap_session->this_round;
char challenge_str[1024];
int length;
eap_round_t *eap_round = eap_session->this_round;
- rlm_eap_gtc_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_gtc_t);
+ rlm_eap_gtc_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_gtc_t);
if (xlat_eval(challenge_str, sizeof(challenge_str), request, inst->challenge, NULL, NULL) < 0) {
RETURN_MODULE_FAIL;
mschapv2_opaque_t *data = talloc_get_type_abort(eap_session->opaque, mschapv2_opaque_t);
eap_round_t *eap_round = eap_session->this_round;
fr_pair_list_t response;
- rlm_eap_mschapv2_t const *inst = mctx->inst->data;
+ rlm_eap_mschapv2_t const *inst = mctx->mi->data;
rlm_rcode_t rcode;
fr_pair_t *parent;
*/
static unlang_action_t CC_HINT(nonnull) mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_mschapv2_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_mschapv2_t);
+ rlm_eap_mschapv2_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_mschapv2_t);
request_t *parent = request->parent;
eap_session_t *eap_session = eap_session_get(parent);
mschapv2_opaque_t *data = talloc_get_type_abort(eap_session->opaque, mschapv2_opaque_t);
int i;
bool created_auth_challenge;
- if (!fr_cond_assert(mctx->inst->data)) RETURN_MODULE_FAIL;
+ if (!fr_cond_assert(mctx->mi->data)) RETURN_MODULE_FAIL;
/*
* We're looking for attributes that should come
* Compose the EAP-MSCHAPV2 packet out of the data structure,
* and free it.
*/
- eap_mschapv2_compose(mctx->inst->data, request, eap_session, auth_challenge);
+ eap_mschapv2_compose(mctx->mi->data, request, eap_session, auth_challenge);
if (created_auth_challenge) TALLOC_FREE(auth_challenge);
/*
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_mschapv2_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_mschapv2_t);
+ rlm_eap_mschapv2_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_mschapv2_t);
if (inst->identity && (strlen(inst->identity) > 255)) {
- cf_log_err(mctx->inst->conf, "identity is too long");
+ cf_log_err(mctx->mi->conf, "identity is too long");
return -1;
}
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->inst->data, rlm_eap_peap_t);
+ rlm_eap_peap_t *inst = talloc_get_type(mctx->mi->data, rlm_eap_peap_t);
rlm_rcode_t rcode;
*/
static unlang_action_t mod_session_init(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_peap_t);
+ rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_peap_t);
rlm_eap_peap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_peap_thread_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_tls_session_t *eap_tls_session;
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_peap_t);
+ rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_peap_t);
rlm_eap_peap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_peap_thread_t);
t->ssl_ctx = fr_tls_ctx_alloc(inst->tls_conf, false);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_peap_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_eap_peap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_peap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!virtual_server_find(inst->virtual_server)) {
cf_log_err_by_child(conf, "virtual_server", "Unknown virtual server '%s'", inst->virtual_server);
static unlang_action_t mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_pwd_t);
+ rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_pwd_t);
eap_session_t *eap_session = eap_session_get(request->parent);
pwd_session_t *session;
static unlang_action_t mod_session_init(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_pwd_t);
+ rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_pwd_t);
eap_session_t *eap_session = eap_session_get(request->parent);
pwd_session_t *session;
fr_pair_t *vp;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_pwd_t);
+ rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_pwd_t);
if (inst->bnctx) BN_CTX_free(inst->bnctx);
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_pwd_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_eap_pwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_pwd_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (inst->fragment_size < 100) {
cf_log_err(conf, "Fragment size is too small");
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_module_conf_t);
+ eap_aka_sim_module_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_module_conf_t);
inst->type = rlm_eap_sim.provides[0];
*/
static unlang_action_t mod_session_init(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_tls_t);
+ rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_tls_t);
rlm_eap_tls_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_tls_thread_t);
eap_session_t *eap_session = eap_session_get(request->parent);
eap_tls_session_t *eap_tls_session;
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_tls_t);
+ rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_tls_t);
rlm_eap_tls_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_tls_thread_t);
t->ssl_ctx = fr_tls_ctx_alloc(inst->tls_conf, false);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_tls_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_eap_tls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_tls_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->tls_conf = eap_tls_conf_parse(conf, "tls");
if (!inst->tls_conf) {
*/
static unlang_action_t mod_session_init(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_ttls_t);
+ rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_ttls_t);
rlm_eap_ttls_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_ttls_thread_t);
eap_session_t *eap_session = eap_session_get(request->parent);
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_ttls_t);
+ rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_ttls_t);
rlm_eap_ttls_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_eap_ttls_thread_t);
t->ssl_ctx = fr_tls_ctx_alloc(inst->tls_conf, false);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_eap_ttls_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_eap_ttls_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_eap_ttls_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!virtual_server_find(inst->virtual_server)) {
cf_log_err_by_child(conf, "virtual_server", "Unknown virtual server '%s'", inst->virtual_server);
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_escape_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_escape_t);
+ rlm_escape_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_escape_t);
fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p = arg->vb_strvalue;
size_t len;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <stdint.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_exec_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_exec_t);
+ rlm_exec_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_exec_t);
fr_pair_list_t *env_pairs = NULL;
fr_exec_state_t *exec;
static unlang_action_t mod_exec_oneshot_nowait_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
request_t *request)
{
- rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_exec_t);
+ rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_exec_t);
fr_value_box_list_t *args = talloc_get_type_abort(mctx->rctx, fr_value_box_list_t);
fr_pair_list_t *env_pairs = NULL;
static unlang_action_t mod_exec_oneshot_wait_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
int status;
- rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_exec_t);
+ rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_exec_t);
rlm_exec_ctx_t *m = talloc_get_type_abort(mctx->rctx, rlm_exec_ctx_t);
rlm_rcode_t rcode;
rlm_exec_ctx_t *m;
fr_pair_list_t *env_pairs = NULL;
TALLOC_CTX *ctx;
- rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_exec_t);
+ rlm_exec_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_exec_t);
exec_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, exec_call_env_t);
if (!env_data->program) {
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_exec_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_exec_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_exec_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_exec_t);
+ CONF_SECTION *conf = mctx->mi->conf;
xlat_t *xlat;
xlat = xlat_func_register_module(NULL, mctx, NULL, exec_xlat_oneshot, FR_TYPE_STRING);
rlm_files_env_t *env = talloc_get_type_abort(mctx->env_data, rlm_files_env_t);
fr_value_box_list_init(&env->values);
- env->name = mctx->inst->name;
+ env->name = mctx->mi->name;
/*
* Set mod_files_resume as the repeat function
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_icmp_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_icmp_t);
+ rlm_icmp_t *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_icmp_t);
rlm_icmp_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_icmp_thread_t);
rlm_icmp_echo_t *echo;
icmp_header_t icmp;
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
module_thread_inst_ctx_t *our_mctx;
- rlm_icmp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_icmp_t);
+ rlm_icmp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_icmp_t);
rlm_icmp_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_icmp_thread_t);
fr_ipaddr_t ipaddr, *src;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_icmp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_icmp_t);
+ rlm_icmp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_icmp_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, xlat_icmp, FR_TYPE_BOOL);
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_idn_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_idn_t);
+ rlm_idn_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_idn_t);
char *idna = NULL;
int res;
size_t len;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_idn_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_idn_t);
+ rlm_idn_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_idn_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, xlat_idna, FR_TYPE_STRING);
static unlang_action_t CC_HINT(nonnull) mod_authenticate_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx,
request_t *request)
{
- rlm_imap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_imap_t);
+ rlm_imap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_imap_t);
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;
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_imap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_imap_t);
+ rlm_imap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_imap_t);
rlm_imap_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_imap_thread_t);
fr_curl_handle_t *mhandle;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_isc_dhcp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_isc_dhcp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_isc_dhcp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_isc_dhcp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
rlm_isc_dhcp_info_t *info;
int ret;
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_isc_dhcp_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_isc_dhcp_t);
+ rlm_isc_dhcp_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_isc_dhcp_t);
int ret;
ret = apply_fixed_ip(inst, request);
static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_isc_dhcp_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_isc_dhcp_t);
+ rlm_isc_dhcp_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_isc_dhcp_t);
int ret;
ret = apply(inst, request, inst->head);
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_json_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_json_t);
+ rlm_json_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_json_t);
fr_json_format_t const *format = inst->format;
ssize_t slen;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_json_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_json_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_json_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_json_t);
+ CONF_SECTION *conf = mctx->mi->conf;
xlat_t *xlat;
fr_json_format_t *format = inst->format;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_krb5_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_krb5_t);
+ rlm_krb5_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_krb5_t);
#ifndef HEIMDAL_KRB5
talloc_free(inst->vic_options);
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_krb5_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_krb5_t);
+ rlm_krb5_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_krb5_t);
krb5_error_code ret;
#ifndef HEIMDAL_KRB5
krb5_keytab keytab;
/*
* Initialize the socket pool.
*/
- inst->pool = module_rlm_connection_pool_init(mctx->inst->conf, inst, krb5_mod_conn_create, NULL, NULL, NULL, NULL);
+ inst->pool = module_rlm_connection_pool_init(mctx->mi->conf, inst, krb5_mod_conn_create, NULL, NULL, NULL, NULL);
if (!inst->pool) return -1;
#else
inst->conn = krb5_mod_conn_create(inst, inst, fr_time_delta_wrap(0));
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_krb5_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_krb5_t);
+ rlm_krb5_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_krb5_t);
rlm_rcode_t rcode;
krb5_error_code ret;
rlm_krb5_handle_t *conn;
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_krb5_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_krb5_t);
+ rlm_krb5_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_krb5_t);
rlm_rcode_t rcode;
krb5_error_code ret;
request_t *request, fr_value_box_list_t *in)
{
fr_value_box_t *vb = NULL, *group_vb = fr_value_box_list_pop_head(in);
- rlm_ldap_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_ldap_t);
fr_ldap_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, fr_ldap_thread_t);
ldap_xlat_memberof_call_env_t *env_data = talloc_get_type_abort(xctx->env_data, ldap_xlat_memberof_call_env_t);
bool group_is_dn;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_ldap_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_ldap_t);
fr_ldap_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, fr_ldap_thread_t);
ldap_xlat_profile_call_env_t *env_data = talloc_get_type_abort(xctx->env_data, ldap_xlat_profile_call_env_t);
fr_value_box_t *uri_components, *uri;
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_ldap_t);
fr_ldap_thread_t *thread = talloc_get_type_abort(module_rlm_thread_by_data(inst)->data, fr_ldap_thread_t);
ldap_auth_ctx_t *auth_ctx;
ldap_auth_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, ldap_auth_call_env_t);
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_ldap_t);
fr_ldap_thread_t *thread = talloc_get_type_abort(module_rlm_thread_by_data(inst)->data, fr_ldap_thread_t);
ldap_autz_ctx_t *autz_ctx;
fr_ldap_map_exp_t *expanded;
}
expanded->attrs[expanded->count] = NULL;
- autz_ctx->dlinst = mctx->inst;
+ autz_ctx->dlinst = mctx->mi;
autz_ctx->inst = inst;
autz_ctx->call_env = call_env;
autz_ctx->status = LDAP_AUTZ_FIND;
static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_ldap_t);
ldap_usermod_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, ldap_usermod_call_env_t);
if (inst->accounting) return user_modify(p_result, inst, request, inst->accounting, call_env);
static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_ldap_t);
ldap_usermod_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, ldap_usermod_call_env_t);
if (inst->postauth) return user_modify(p_result, inst, request, inst->postauth, call_env);
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_ldap_t);
if (inst->user.obj_sort_ctrl) ldap_control_free(inst->user.obj_sort_ctrl);
CONF_SECTION *parent, ldap_acct_section_t **config,
rlm_components_t comp)
{
- rlm_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_ldap_t);
CONF_SECTION *cs;
char const *name = section_type_value[comp];
cs = cf_section_find(parent, name, NULL);
if (!cs) {
DEBUG2("rlm_ldap (%s) - Couldn't find configuration for %s, will return NOOP for calls "
- "from this section", mctx->inst->name, name);
+ "from this section", mctx->mi->name, name);
return 0;
}
*config = talloc_zero(inst, ldap_acct_section_t);
if (cf_section_parse(*config, *config, cs) < 0) {
- PERROR("rlm_ldap (%s) - Failed parsing configuration for section %s", mctx->inst->name, name);
+ PERROR("rlm_ldap (%s) - Failed parsing configuration for section %s", mctx->mi->name, name);
return -1;
}
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_ldap_t);
+ rlm_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_ldap_t);
fr_ldap_thread_t *t = talloc_get_type_abort(mctx->thread, fr_ldap_thread_t);
fr_ldap_thread_trunk_t *ttrunk;
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_ldap_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_ldap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
char buffer[256];
char const *group_attribute;
xlat_t *xlat;
- inst->handle_config.name = talloc_typed_asprintf(inst, "rlm_ldap (%s)", mctx->inst->name);
+ inst->handle_config.name = talloc_typed_asprintf(inst, "rlm_ldap (%s)", mctx->mi->name);
if (inst->group.attribute) {
group_attribute = inst->group.attribute;
} else if (cf_section_name2(conf)) {
- snprintf(buffer, sizeof(buffer), "%s-LDAP-Group", mctx->inst->name);
+ snprintf(buffer, sizeof(buffer), "%s-LDAP-Group", mctx->mi->name);
group_attribute = buffer;
} else {
group_attribute = "LDAP-Group";
xlat_func_args_set(xlat, ldap_xlat_arg);
xlat_func_call_env_set(xlat, &xlat_profile_method_env);
- map_proc_register(inst, mctx->inst->name, mod_map_proc, ldap_map_verify, 0, LDAP_URI_SAFE_FOR);
+ map_proc_register(inst, mctx->mi->name, mod_map_proc, ldap_map_verify, 0, LDAP_URI_SAFE_FOR);
return 0;
}
size_t i;
CONF_SECTION *options;
- rlm_ldap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_ldap_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_ldap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_ldap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
options = cf_section_find(conf, "options", NULL);
if (!options || !cf_pair_find(options, "chase_referrals")) {
*/
if (inst->handle_config.server) {
inst->handle_config.server[talloc_array_length(inst->handle_config.server) - 2] = '\0';
- DEBUG4("rlm_ldap (%s) - LDAP server string: %s", mctx->inst->name, inst->handle_config.server);
+ DEBUG4("rlm_ldap (%s) - LDAP server string: %s", mctx->mi->name, inst->handle_config.server);
}
/*
#include <freeradius-devel/util/debug.h>
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include "rlm_ldap.h"
xlat_ctx_t const *xctx, request_t *request,
fr_value_box_list_t *args)
{
- rlm_linelog_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_linelog_t);
+ rlm_linelog_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_linelog_t);
linelog_call_env_t const *call_env = talloc_get_type_abort(xctx->env_data, linelog_call_env_t);
struct iovec vector[2];
static unlang_action_t CC_HINT(nonnull) mod_do_linelog_resume(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_linelog_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_linelog_t);
+ rlm_linelog_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_linelog_t);
linelog_call_env_t const *call_env = talloc_get_type_abort(mctx->env_data, linelog_call_env_t);
rlm_linelog_rctx_t *rctx = talloc_get_type_abort(mctx->rctx, rlm_linelog_rctx_t);
struct iovec *vector;
*/
static unlang_action_t CC_HINT(nonnull) mod_do_linelog(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_linelog_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_linelog_t);
+ rlm_linelog_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_linelog_t);
linelog_call_env_t const *call_env = talloc_get_type_abort(mctx->env_data, linelog_call_env_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ CONF_SECTION *conf = mctx->mi->conf;
char buff[4096];
char *p = buff;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_linelog_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_linelog_t);
+ rlm_linelog_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_linelog_t);
fr_pool_free(inst->pool);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_linelog_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_linelog_t);
- CONF_SECTION *cs, *conf = mctx->inst->conf;
+ rlm_linelog_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_linelog_t);
+ CONF_SECTION *cs, *conf = mctx->mi->conf;
char prefix[100];
inst->log_dst = fr_table_value_by_str(linefr_log_dst_table, inst->log_dst_str, LINELOG_DST_INVALID);
return -1;
}
- snprintf(prefix, sizeof(prefix), "rlm_linelog (%s)", mctx->inst->name);
+ snprintf(prefix, sizeof(prefix), "rlm_linelog (%s)", mctx->mi->name);
/*
* Setup the logging destination
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_linelog_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_linelog_t);
+ rlm_linelog_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_linelog_t);
xlat_t *xlat;
static xlat_arg_parser_t const linelog_xlat_args[] = {
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_logtee_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_logtee_t);
+ rlm_logtee_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_logtee_t);
rlm_logtee_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_logtee_thread_t);
MEM(t->fring = fr_fring_alloc(t, inst->buffer_depth, false));
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_logtee_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_logtee_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_logtee_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_logtee_t);
+ CONF_SECTION *conf = mctx->mi->conf;
char prefix[100];
/*
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/util/debug.h>
static int _lua_pair_set(lua_State *L)
{
module_ctx_t const *mctx = fr_lua_util_get_mctx();
- rlm_lua_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_lua_t);
+ rlm_lua_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_lua_t);
request_t *request = fr_lua_util_get_request();
fr_dcursor_t cursor;
fr_dict_attr_t const *da;
*/
int fr_lua_init(lua_State **out, module_inst_ctx_t const *mctx)
{
- rlm_lua_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_lua_t);
+ rlm_lua_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_lua_t);
lua_State *L;
fr_lua_util_set_mctx(MODULE_CTX_FROM_INST(mctx));
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/util/debug.h>
#define DO_LUA(_s)\
static unlang_action_t mod_##_s(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request) \
{\
- rlm_lua_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_lua_t);\
+ rlm_lua_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_lua_t);\
if (!inst->func_##_s) RETURN_MODULE_NOOP;\
return fr_lua_run(p_result, mctx, request, inst->func_##_s);\
}
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_lua_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_lua_t);
+ rlm_lua_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_lua_t);
rlm_rcode_t ret = 0;
/*
if (inst->interpreter) {
if (inst->func_detach) {
fr_lua_run(&ret,
- MODULE_CTX(mctx->inst,
+ MODULE_CTX(mctx->mi,
&(rlm_lua_thread_t){
.interpreter = inst->interpreter
},
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_lua_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_lua_t);
+ rlm_lua_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_lua_t);
rlm_rcode_t rcode;
/*
if (inst->func_instantiate) {
fr_lua_run(&rcode,
- MODULE_CTX(mctx->inst,
+ MODULE_CTX(mctx->mi,
&(rlm_lua_thread_t){
.interpreter = inst->interpreter
},
*/
RCSID("$Id$")
-#define LOG_PREFIX fr_lua_mctx->inst->name
+#define LOG_PREFIX fr_lua_mctx->mi->name
#include <freeradius-devel/server/base.h>
{
return fr_lua_request;
}
-
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_mruby_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_mruby_t);
+ rlm_mruby_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mruby_t);
mrb_state *mrb;
CONF_SECTION *cs;
FILE *f;
/* Convert a FreeRADIUS config structure into a mruby hash */
inst->mrubyconf_hash = mrb_hash_new(mrb);
- cs = cf_section_find(mctx->inst->conf, "config", NULL);
+ cs = cf_section_find(mctx->mi->conf, "config", NULL);
if (cs) mruby_parse_config(mrb, cs, 0, inst->mrubyconf_hash);
/* Define the Request class */
{ \
return do_mruby(p_result, \
request, \
- (rlm_mruby_t const *)mctx->inst->data, \
+ (rlm_mruby_t const *)mctx->mi->data, \
#foo); \
}
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_mruby_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_mruby_t);
+ rlm_mruby_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mruby_t);
mrb_close(inst->mrb);
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/exec_legacy.h>
uint8_t buffer[32];
fr_pair_t *user_name;
fr_pair_t *chap_challenge, *response;
- rlm_mschap_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_mschap_t);
+ rlm_mschap_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_mschap_t);
fr_value_box_t *arg = fr_value_box_list_head(in);
fr_value_box_t *vb;
bool tainted = false;
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_mschap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_mschap_t);
+ rlm_mschap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_mschap_t);
mschap_autz_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, mschap_autz_call_env_t);
fr_pair_t *challenge = NULL;
fr_pair_t *parent;
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup MS-CHAP authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_mschap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_mschap_t);
+ rlm_mschap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_mschap_t);
mschap_auth_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, mschap_auth_call_env_t);
mschap_auth_ctx_t *auth_ctx;
* otherwise
*/
*auth_ctx = (mschap_auth_ctx_t) {
- .name = mctx->inst->name,
+ .name = mctx->mi->name,
.inst = inst,
.method = inst->method,
.env_data = env_data,
* input attribute, and we're calling out to an
* external password store.
*/
- if (nt_password_find(auth_ctx, &auth_ctx->nt_password, mctx->inst->data, request) < 0) RETURN_MODULE_FAIL;
+ if (nt_password_find(auth_ctx, &auth_ctx->nt_password, mctx->mi->data, request) < 0) RETURN_MODULE_FAIL;
/*
* Check to see if this is a change password request, and process
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_mschap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_mschap_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_mschap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mschap_t);
+ CONF_SECTION *conf = mctx->mi->conf;
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. MS-CHAP authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_mschap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_mschap_t);
+ rlm_mschap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mschap_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, mschap_xlat, FR_TYPE_VOID);
module_detach_ctx_t const *mctx)
{
#ifdef WITH_AUTH_WINBIND
- rlm_mschap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_mschap_t);
+ rlm_mschap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_mschap_t);
fr_pool_free(inst->wb_pool);
#endif
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_opendirectory_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_opendirectory_t);
+ rlm_opendirectory_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_opendirectory_t);
struct passwd *userdata = NULL;
int ismember = 0;
fr_client_t *client = NULL;
setup_auth_type:
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup OpenDirectory authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_opendirectory_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_opendirectory_t);
+ rlm_opendirectory_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_opendirectory_t);
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. OpenDirectory authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
return 0;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_pam_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_pam_t);
+ rlm_pam_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_pam_t);
if (!inst->pam_auth_name) inst->pam_auth_name = main_config->name;
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_pam_t const *data = talloc_get_type_abort_const(mctx->inst->data, rlm_pam_t);
+ rlm_pam_t const *data = talloc_get_type_abort_const(mctx->mi->data, rlm_pam_t);
int ret;
fr_pair_t *pair;
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_pap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_pap_t);
+ rlm_pap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_pap_t);
pap_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, pap_call_env_t);
if (fr_pair_find_by_da(&request->control_pairs, NULL, attr_auth_type) != NULL) {
- RDEBUG3("Auth-Type is already set. Not setting 'Auth-Type := %s'", mctx->inst->name);
+ RDEBUG3("Auth-Type is already set. Not setting 'Auth-Type := %s'", mctx->mi->name);
RETURN_MODULE_NOOP;
}
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup PAP authentication.",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_pap_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_pap_t);
+ rlm_pap_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_pap_t);
fr_pair_t *known_good;
rlm_rcode_t rcode = RLM_MODULE_INVALID;
pap_auth_func_t auth_func;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_pap_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_pap_t);
+ rlm_pap_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_pap_t);
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. PAP will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
return 0;
size_t len;
int i;
fr_dict_attr_t const *da;
- rlm_passwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_passwd_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_passwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_passwd_t);
+ CONF_SECTION *conf = mctx->mi->conf;
fr_assert(inst->filename && *inst->filename);
fr_assert(inst->format && *inst->format);
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_passwd_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_passwd_t);
+ rlm_passwd_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_passwd_t);
if (inst->ht) {
release_ht(inst->ht);
inst->ht = NULL;
static unlang_action_t CC_HINT(nonnull) mod_passwd_map(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_passwd_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_passwd_t);
+ rlm_passwd_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_passwd_t);
char buffer[1024];
fr_pair_t *key, *i;
PerlInterpreter *interp, char const *function_name)
{
- rlm_perl_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t);
+ rlm_perl_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_perl_t);
fr_pair_list_t vps;
int ret=0, count;
STRLEN n_a;
#define RLM_PERL_FUNC(_x) \
static unlang_action_t CC_HINT(nonnull) mod_##_x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request) \
{ \
- rlm_perl_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t); \
+ rlm_perl_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_perl_t); \
return do_perl(p_result, mctx, request, \
((rlm_perl_thread_t *)talloc_get_type_abort(mctx->thread, rlm_perl_thread_t))->perl, \
inst->func_##_x); \
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_perl_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t);
+ rlm_perl_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_perl_t);
rlm_perl_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_perl_thread_t);
PerlInterpreter *interp;
UV clone_flags = 0;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_perl_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_perl_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_perl_t);
+ CONF_SECTION *conf = mctx->mi->conf;
AV *end_AV;
char const **embed_c; /* Stupid Perl and lack of const consistency */
DIAG_OFF(nested-externs)
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_perl_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_perl_t);
+ rlm_perl_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_perl_t);
int ret = 0, count = 0;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
*/
if (!p_func) RETURN_MODULE_NOOP;
- RDEBUG3("Using thread state %p/%p", mctx->inst->data, t->state);
+ RDEBUG3("Using thread state %p/%p", mctx->mi->data, t->state);
PyEval_RestoreThread(t->state); /* Swap in our local thread state */
do_python_single(&rcode, mctx, request, p_func, funcname);
#define MOD_FUNC(x) \
static unlang_action_t CC_HINT(nonnull) mod_##x(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request) \
{ \
- rlm_python_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_python_t); \
+ rlm_python_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_python_t); \
return do_python(p_result, mctx, request, inst->x.function, #x);\
}
*/
static int python_module_import_config(module_inst_ctx_t const *mctx, CONF_SECTION *conf, PyObject *module)
{
- rlm_python_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_python_t);
+ rlm_python_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_python_t);
CONF_SECTION *cs;
/*
static int python_interpreter_init(module_inst_ctx_t const *mctx)
{
- rlm_python_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_python_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_python_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_python_t);
+ CONF_SECTION *conf = mctx->mi->conf;
PyObject *module;
/*
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_python_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_python_t);
+ rlm_python_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_python_t);
if (python_interpreter_init(mctx) < 0) return -1;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_python_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_python_t);
+ rlm_python_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_python_t);
/*
* If we don't have a interpreter
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
PyThreadState *state;
- rlm_python_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_python_t);
+ rlm_python_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_python_t);
rlm_python_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_python_thread_t);
state = PyThreadState_New(inst->interpreter->interp);
static void mod_radius_signal(module_ctx_t const *mctx, request_t *request, fr_signal_t action)
{
- rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_radius_t);
+ rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_radius_t);
rlm_radius_io_t const *io = (rlm_radius_io_t const *)inst->io_submodule->module; /* Public symbol exported by the module */
/*
*/
static unlang_action_t CC_HINT(nonnull) mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_radius_t);
+ rlm_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_radius_t);
rlm_rcode_t rcode;
unlang_action_t ua;
fr_client_t *client;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
size_t i, num_types;
- rlm_radius_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_radius_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_radius_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_radius_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->io = (rlm_radius_io_t const *)inst->io_submodule->module; /* Public symbol exported by the module */
- inst->name = mctx->inst->name;
+ inst->name = mctx->mi->name;
/*
* These limits are specific to RADIUS, and cannot be over-ridden
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_radius_udp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_radius_udp_t);
+ rlm_radius_udp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_radius_udp_t);
udp_thread_t *thread = talloc_get_type_abort(mctx->thread, udp_thread_t);
static fr_trunk_io_funcs_t io_funcs = {
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_radius_t *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_radius_t);
- rlm_radius_udp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_radius_udp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_radius_t *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_radius_t);
+ rlm_radius_udp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_radius_udp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!parent) {
ERROR("IO module cannot be instantiated directly");
*/
static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_radutmp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_radutmp_t);
+ rlm_radutmp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_radutmp_t);
rlm_radutmp_env_t *env = talloc_get_type_abort(mctx->env_data, rlm_radutmp_env_t);
rlm_rcode_t rcode = RLM_MODULE_OK;
struct radutmp ut, u;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
+ rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_redis_t);
fr_socket_t node_addr;
fr_pool_t *pool;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
+ rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_redis_t);
fr_redis_cluster_key_slot_t const *key_slot;
fr_redis_cluster_node_t const *node;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_redis_t *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_redis_t);
+ rlm_redis_t *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_redis_t);
redis_lua_func_inst_t const *xlat_inst = talloc_get_type_abort_const(xctx->inst, redis_lua_func_inst_t);
redis_lua_func_t *func = xlat_inst->func;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_redis_t);
+ rlm_redis_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_redis_t);
xlat_action_t action = XLAT_ACTION_DONE;
fr_redis_conn_t *conn;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_redis_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_redis_t);
+ rlm_redis_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_redis_t);
fr_socket_t *nodes;
int ret, i;
- inst->cluster = fr_redis_cluster_alloc(inst, mctx->inst->conf, &inst->conf, true, NULL, NULL, NULL);
+ inst->cluster = fr_redis_cluster_alloc(inst, mctx->mi->conf, &inst->conf, true, NULL, NULL, NULL);
if (!inst->cluster) return -1;
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_redis_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_redis_t);
+ rlm_redis_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_redis_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, redis_xlat, FR_TYPE_VOID);
static unlang_action_t CC_HINT(nonnull) mod_alloc(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_redis_ippool_t);
+ rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_redis_ippool_t);
redis_ippool_alloc_call_env_t *env = talloc_get_type_abort(mctx->env_data, redis_ippool_alloc_call_env_t);
uint32_t lease_time;
static unlang_action_t CC_HINT(nonnull) mod_update(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_redis_ippool_t);
+ rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_redis_ippool_t);
redis_ippool_update_call_env_t *env = talloc_get_type_abort(mctx->env_data, redis_ippool_update_call_env_t);
CHECK_POOL_NAME
static unlang_action_t CC_HINT(nonnull) mod_release(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_redis_ippool_t);
+ rlm_redis_ippool_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_redis_ippool_t);
redis_ippool_release_call_env_t *env = talloc_get_type_abort(mctx->env_data, redis_ippool_release_call_env_t);
CHECK_POOL_NAME
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
static bool done_hash = false;
- CONF_SECTION *subcs = cf_section_find(mctx->inst->conf, "redis", NULL);
+ CONF_SECTION *subcs = cf_section_find(mctx->mi->conf, "redis", NULL);
- rlm_redis_ippool_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_redis_ippool_t);
+ rlm_redis_ippool_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_redis_ippool_t);
fr_assert(subcs);
static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_rediswho_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_rediswho_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_rediswho_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rediswho_t);
+ CONF_SECTION *conf = mctx->mi->conf;
rlm_rcode_t rcode;
fr_pair_t *vp;
fr_dict_enum_value_t *dv;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_rediswho_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_rediswho_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_rediswho_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_rediswho_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->cluster = fr_redis_cluster_alloc(inst, conf, &inst->conf, true, NULL, NULL, NULL);
if (!inst->cluster) return -1;
rlm_rest_xlat_rctx_t *our_rctx = talloc_get_type_abort(xctx->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_signal(MODULE_CTX(xctx->mctx->inst,
+ rest_io_module_signal(MODULE_CTX(xctx->mctx->mi,
t,
xctx->mctx->env_data,
randle),
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <ctype.h>
#include <string.h>
static int rest_request_config_body(module_ctx_t const *mctx, rlm_rest_section_t const *section,
request_t *request, fr_curl_io_request_t *randle, rest_read_t func)
{
- rlm_rest_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_rest_t);
rlm_rest_curl_context_t *uctx = talloc_get_type_abort(randle->uctx, rlm_rest_curl_context_t);
ssize_t len;
http_body_type_t type,
char const *uri, char const *body_data)
{
- rlm_rest_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_rest_t);
rlm_rest_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, rlm_rest_call_env_t);
rlm_rest_curl_context_t *ctx = talloc_get_type_abort(randle->uctx, rlm_rest_curl_context_t);
CURL *candle = randle->candle;
xlat_ctx_t const *xctx, request_t *request,
fr_value_box_list_t *in)
{
- rlm_rest_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_rest_thread_t);
fr_curl_io_request_t *randle = NULL;
*
* @todo We could extract the User-Name and password from the URL string.
*/
- ret = rest_request_config(MODULE_CTX(xctx->mctx->inst, t, xctx->env_data, NULL),
+ ret = rest_request_config(MODULE_CTX(xctx->mctx->mi, t, xctx->env_data, NULL),
section, request, randle, section->request.method,
section->request.body,
uri_vb->vb_strvalue, in_vb ? in_vb->vb_strvalue : NULL);
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->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rest_t);
rlm_rest_section_t const *section = &inst->authenticate;
fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, 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->authorize;
static unlang_action_t mod_authenticate_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->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rest_t);
rlm_rest_section_t const *section = &inst->authenticate;
fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
rlm_rest_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, rlm_rest_call_env_t);
rlm_rest_section_t const *section = &inst->authenticate;
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->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rest_t);
rlm_rest_section_t const *section = &inst->authenticate;
fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
*/
static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, 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->accounting;
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->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_rest_t);
rlm_rest_section_t const *section = &inst->authenticate;
fr_curl_io_request_t *handle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
*/
static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t const *inst = talloc_get_type_abort_const(mctx->mi->data, 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->post_auth;
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_rest_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_rest_t);
rlm_rest_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_rest_thread_t);
fr_curl_handle_t *mhandle;
*/
static int instantiate(module_inst_ctx_t const *mctx)
{
- rlm_rest_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_rest_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_rest_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->xlat.request.method_str = "GET";
inst->xlat.request.body = REST_HTTP_BODY_NONE;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_rest_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_rest_t);
+ rlm_rest_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_rest_t);
xlat_t *xlat;
xlat = xlat_func_register_module(inst, mctx, NULL, rest_xlat, FR_TYPE_STRING);
/******************************************/
static int mod_detach(module_detach_ctx_t *mctx)
{
- rlm_securid_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_securid_t);
+ rlm_securid_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_securid_t);
/* delete session tree */
if (inst->session_tree) {
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_securid_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_securid_t);
+ rlm_securid_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_securid_t);
/*
* Lookup sessions in the tree. We don't free them in
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
int rcode;
- rlm_securid_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_securid_t);
+ rlm_securid_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_securid_t);
char buffer[FR_MAX_STRING_LEN]="";
fr_pair_t *username, *password;
fr_pair_t *vp;
*/
RCSID("$Id$")
-#define LOG_PREFIX_ARGS mctx->inst->name
+#define LOG_PREFIX_ARGS mctx->mi->name
#include <osmocom/core/linuxlist.h>
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sigtran_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_sigtran_t);
+ rlm_sigtran_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_sigtran_t);
rlm_sigtran_thread_t const *t = talloc_get_type_abort_const(mctx->thread, rlm_sigtran_thread_t);
return sigtran_client_map_send_auth_info(p_result, inst, request, inst->conn, t->fd);
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_sigtran_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sigtran_t);
- CONF_SECTION const *conf = mctx->inst->conf;
+ rlm_sigtran_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sigtran_t);
+ CONF_SECTION const *conf = mctx->mi->conf;
/*
* Translate traffic mode string to integer
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_sigtran_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sigtran_t);
+ rlm_sigtran_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sigtran_t);
/*
* If we're just checking the config we didn't start the
*/
static unlang_action_t smtp_io_module_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->inst->data, rlm_smtp_t);
+ rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_smtp_t);
fr_curl_io_request_t *randle = talloc_get_type_abort(mctx->rctx, fr_curl_io_request_t);
fr_curl_tls_t const *tls = &inst->tls;
long curl_out;
*/
static unlang_action_t CC_HINT(nonnull) mod_mail(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_smtp_t);
+ rlm_smtp_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_smtp_t);
rlm_smtp_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_smtp_thread_t);
rlm_smtp_env_t *call_env = talloc_get_type_abort(mctx->env_data, rlm_smtp_env_t);
fr_curl_io_request_t *randle = NULL;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_smtp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_smtp_t);
+ rlm_smtp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_smtp_t);
inst->conn_config.reuse.num_children = 1;
inst->conn_config.reuse.child_pool_size = sizeof(fr_mail_ctx_t);
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_smtp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_smtp_t);
+ rlm_smtp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_smtp_t);
rlm_smtp_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_smtp_thread_t);
fr_curl_handle_t *mhandle;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_sometimes_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sometimes_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sometimes_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sometimes_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* Convert the rcode string to an int, and get rid of it
static unlang_action_t sometimes_return(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request,
fr_packet_t *packet, fr_packet_t *reply)
{
- rlm_sometimes_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_sometimes_t);
+ rlm_sometimes_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_sometimes_t);
uint32_t hash;
fr_pair_t *vp;
float value;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_sql_cassandra_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_cassandra_t);
+ rlm_sql_cassandra_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_cassandra_t);
if (inst->ssl) cass_ssl_free(inst->ssl);
if (inst->session) cass_session_free(inst->session); /* also synchronously closes the session */
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_sql_t const *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_sql_t);
+ rlm_sql_t const *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_sql_t);
rlm_sql_config_t const *config = &parent->config;
- rlm_sql_cassandra_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_cassandra_t);
+ rlm_sql_cassandra_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_cassandra_t);
bool do_tls = false;
bool do_latency_aware_routing = false;
CassCluster *cluster;
* This has to be done before we call cf_section_parse
* as it sets default values, and creates the section.
*/
- if (cf_section_find(mctx->inst->conf, "tls", NULL)) do_tls = true;
- if (cf_section_find(mctx->inst->conf, "latency_aware_routing", NULL)) do_latency_aware_routing = true;
+ if (cf_section_find(mctx->mi->conf, "tls", NULL)) do_tls = true;
+ if (cf_section_find(mctx->mi->conf, "latency_aware_routing", NULL)) do_latency_aware_routing = true;
DEBUG4("Configuring CassCluster structure");
cluster = inst->cluster = cass_cluster_new();
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sql_mysql_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_mysql_t);
+ rlm_sql_mysql_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_mysql_t);
int warnings;
warnings = fr_table_value_by_str(server_warnings_table, inst->warnings_str, -1);
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_sql_oracle_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_oracle_t);
+ rlm_sql_oracle_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_oracle_t);
if (inst->pool) OCISessionPoolDestroy((dvoid *)inst->pool, (dvoid *)inst->error, OCI_DEFAULT );
if (inst->error) OCIHandleFree((dvoid *)inst->error, OCI_HTYPE_ERROR);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sql_t const *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_sql_t);
+ rlm_sql_t const *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_sql_t);
rlm_sql_config_t const *config = &parent->config;
- rlm_sql_oracle_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_oracle_t);
+ rlm_sql_oracle_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_oracle_t);
char errbuff[512];
sb4 errcode = 0;
OraText *sql_password = NULL;
OraText *sql_login = NULL;
- if (!cf_section_find(mctx->inst->conf, "spool", NULL)) {
+ if (!cf_section_find(mctx->mi->conf, "spool", NULL)) {
ERROR("Couldn't load mctx->configuration of session pool(\"spool\" section in driver mctx->config)");
return RLM_SQL_ERROR;
}
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sql_t const *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_sql_t);
+ rlm_sql_t const *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_sql_t);
rlm_sql_config_t const *config = &parent->config;
- rlm_sql_postgresql_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_postgresql_t);
+ rlm_sql_postgresql_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_postgresql_t);
char application_name[NAMEDATALEN];
char *db_string;
CONF_SECTION *cs;
char const *name;
- cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ cs = cf_item_to_section(cf_parent(mctx->mi->conf));
name = cf_section_name2(cs);
if (!name) name = cf_section_name1(cs);
{
CONF_SECTION *cs;
- cs = cf_section_find(mctx->inst->conf, "states", NULL);
+ cs = cf_section_find(mctx->mi->conf, "states", NULL);
if (cs && (sql_state_entries_from_cs(inst->states, cs) < 0)) return -1;
}
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sql_t const *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_sql_t);
+ rlm_sql_t const *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_sql_t);
rlm_sql_config_t const *config = &parent->config;
- rlm_sql_sqlite_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_sqlite_t);
+ rlm_sql_sqlite_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_sqlite_t);
bool exists;
struct stat buf;
int fd;
return -1;
}
- if (cf_pair_find(mctx->inst->conf, "bootstrap")) {
+ if (cf_pair_find(mctx->mi->conf, "bootstrap")) {
inst->bootstrap = true;
}
if (p) {
size_t len = (p - inst->filename) + 1;
- buff = talloc_array(mctx->inst->conf, char, len);
+ buff = talloc_array(mctx->mi->conf, char, len);
strlcpy(buff, inst->filename, len);
} else {
- MEM(buff = talloc_typed_strdup(mctx->inst->conf, inst->filename));
+ MEM(buff = talloc_typed_strdup(mctx->mi->conf, inst->filename));
}
ret = fr_mkdir(NULL, buff, -1, 0700, NULL, NULL);
/*
* Execute multiple bootstrap SQL files in order
*/
- for (cp = cf_pair_find(mctx->inst->conf, "bootstrap");
+ for (cp = cf_pair_find(mctx->mi->conf, "bootstrap");
cp;
- cp = cf_pair_find_next(mctx->inst->conf, cp, "bootstrap")) {
+ cp = cf_pair_find_next(mctx->mi->conf, cp, "bootstrap")) {
p = cf_pair_value(cp);
if (!p) continue;
- ret = sql_loadfile(mctx->inst->conf, db, p);
+ ret = sql_loadfile(mctx->mi->conf, db, p);
if (ret < 0) goto unlink;
}
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/exfile.h>
sql_xlat_call_env_t *call_env = talloc_get_type_abort(xctx->env_data, sql_xlat_call_env_t);
rlm_sql_handle_t *handle = NULL;
rlm_sql_row_t row;
- rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_sql_t);
+ rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_sql_t);
sql_rcode_t rcode;
xlat_action_t ret = XLAT_ACTION_DONE;
char const *p;
request_t *request, fr_value_box_list_t *in)
{
sql_group_xlat_ctx_t *xlat_ctx = talloc_get_type_abort(xctx->rctx, sql_group_xlat_ctx_t);
- rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_sql_t);
+ rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_sql_t);
fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p = arg->vb_strvalue;
fr_value_box_t *query, *vb;
{
sql_group_xlat_call_env_t *call_env = talloc_get_type_abort(xctx->env_data, sql_group_xlat_call_env_t);
sql_group_xlat_ctx_t *xlat_ctx;
- rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_sql_t);
+ rlm_sql_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_sql_t);
if (!call_env->membership_query) {
RWARN("Cannot check group membership - group_membership_query not set");
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_sql_t);
+ rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_sql_t);
sql_autz_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, sql_autz_call_env_t);
sql_autz_ctx_t *autz_ctx;
*/
static unlang_action_t CC_HINT(nonnull) mod_sql_redundant(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_sql_t);
+ rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_sql_t);
sql_redundant_call_env_t *call_env = talloc_get_type_abort(mctx->env_data, sql_redundant_call_env_t);
sql_redundant_ctx_t *redundant_ctx;
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_sql_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_t);
+ rlm_sql_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_t);
if (inst->pool) fr_pool_free(inst->pool);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sql_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sql_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_t);
+ CONF_SECTION *conf = mctx->mi->conf;
xlat_t *xlat;
xlat_arg_parser_t *sql_xlat_arg;
rlm_sql_escape_uctx_t *uctx;
- inst->name = mctx->inst->name; /* Need this for functions in sql.c */
+ inst->name = mctx->mi->name; /* Need this for functions in sql.c */
inst->driver = (rlm_sql_driver_t const *)inst->driver_submodule->module->exported; /* Public symbol exported by the submodule */
/*
if (inst->config.group_attribute) {
group_attribute = inst->config.group_attribute;
} else if (cf_section_name2(conf)) {
- snprintf(buffer, sizeof(buffer), "%s-SQL-Group", mctx->inst->name);
+ snprintf(buffer, sizeof(buffer), "%s-SQL-Group", mctx->mi->name);
group_attribute = buffer;
} else {
group_attribute = "SQL-Group";
*/
xlat = xlat_func_register_module(inst, mctx, NULL, sql_xlat, FR_TYPE_VOID); /* Returns an integer sometimes */
if (!xlat) {
- cf_log_perr(conf, "Failed registering %s expansion", mctx->inst->name);
+ cf_log_perr(conf, "Failed registering %s expansion", mctx->mi->name);
return -1;
}
xlat_func_call_env_set(xlat, &xlat_method_env);
/*
* Register the SQL map processor function
*/
- if (inst->driver->sql_fields) map_proc_register(inst, mctx->inst->name, mod_map_proc, sql_map_verify, 0, (fr_value_box_safe_for_t)inst->driver);
+ if (inst->driver->sql_fields) map_proc_register(inst, mctx->mi->name, mod_map_proc, sql_map_verify, 0, (fr_value_box_safe_for_t)inst->driver);
return 0;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_sql_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sql_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sql_t);
+ CONF_SECTION *conf = mctx->mi->conf;
/*
* We need authorize_group_check_query or authorize_group_reply_query
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlcounter_t);
+ rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlcounter_t);
sqlcounter_call_env_t *env = talloc_get_type_abort(mctx->env_data, sqlcounter_call_env_t);
fr_pair_t *limit, *vp;
sqlcounter_rctx_t *rctx;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlcounter_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlcounter_t);
+ CONF_SECTION *conf = mctx->mi->conf;
fr_assert(inst->query && *inst->query);
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlcounter_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sqlcounter_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlcounter_t);
+ CONF_SECTION *conf = mctx->mi->conf;
fr_dict_attr_flags_t flags = (fr_dict_attr_flags_t) { .internal = 1, .length = 8 };
module_instance_t const *sql_inst;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlippool_t);
- inst->name = talloc_asprintf(inst, "%s - %s", mctx->inst->name, inst->sql_name);
+ rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlippool_t);
+ inst->name = talloc_asprintf(inst, "%s - %s", mctx->mi->name, inst->sql_name);
return 0;
}
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
module_instance_t *sql;
- rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlippool_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlippool_t);
+ CONF_SECTION *conf = mctx->mi->conf;
sql = module_rlm_by_name(NULL, inst->sql_name);
if (!sql) {
*/
static unlang_action_t CC_HINT(nonnull) mod_alloc(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlippool_t);
+ rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlippool_t);
ippool_alloc_call_env_t *env = talloc_get_type_abort(mctx->env_data, ippool_alloc_call_env_t);
rlm_sql_t const *sql = inst->sql;
rlm_sql_handle_t *handle;
*/
static unlang_action_t CC_HINT(nonnull) mod_common(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_sqlippool_t);
+ rlm_sqlippool_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_sqlippool_t);
ippool_common_call_env_t *env = talloc_get_type_abort(mctx->env_data, ippool_common_call_env_t);
rlm_sql_t const *sql = inst->sql;
rlm_sql_handle_t *handle;
*/
static unlang_action_t CC_HINT(nonnull) mod_stats(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_stats_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_stats_t);
+ rlm_stats_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_stats_t);
rlm_stats_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_stats_thread_t);
int i;
uint32_t stats_type;
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_stats_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_stats_t);
+ rlm_stats_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_stats_t);
rlm_stats_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_stats_thread_t);
(void) talloc_set_type(t, rlm_stats_thread_t);
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_stats_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_stats_t);
+ rlm_stats_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_stats_t);
pthread_mutex_init(&inst->mutex, NULL);
fr_dlist_init(&inst->list, rlm_stats_thread_t, entry);
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_stats_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_stats_t);
+ rlm_stats_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_stats_t);
pthread_mutex_destroy(&inst->mutex);
static void mod_tacacs_signal(module_ctx_t const *mctx, request_t *request, fr_signal_t action)
{
- rlm_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_tacacs_t);
+ rlm_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_tacacs_t);
rlm_tacacs_io_t const *io = (rlm_tacacs_io_t const *)inst->io_submodule->module; /* Public symbol exported by the module */
/*
*/
static unlang_action_t CC_HINT(nonnull) mod_process(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_tacacs_t);
+ rlm_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_tacacs_t);
rlm_rcode_t rcode;
unlang_action_t ua;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
size_t i, num_types;
- rlm_tacacs_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_tacacs_t);
+ rlm_tacacs_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_tacacs_t);
inst->io = (rlm_tacacs_io_t const *)inst->io_submodule->module; /* Public symbol exported by the module */
- inst->name = mctx->inst->name;
+ inst->name = mctx->mi->name;
/*
* These limits are specific to TACACS, and cannot be over-ridden, due to 8-bit ID fields!
*/
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_tacacs_tcp_t);
+ rlm_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_tacacs_tcp_t);
udp_thread_t *thread = talloc_get_type_abort(mctx->thread, udp_thread_t);
static fr_trunk_io_funcs_t io_funcs = {
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_tacacs_t *parent = talloc_get_type_abort(mctx->inst->parent->data, rlm_tacacs_t);
- rlm_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_tacacs_tcp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_tacacs_t *parent = talloc_get_type_abort(mctx->mi->parent->data, rlm_tacacs_t);
+ rlm_tacacs_tcp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_tacacs_tcp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
if (!parent) {
ERROR("IO module cannot be instantiated directly");
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_test_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_test_t);
+ rlm_test_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_test_t);
rlm_test_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_test_thread_t);
t->inst = inst;
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_test_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_test_t);
+ rlm_test_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_test_t);
xlat_t *xlat;
/*
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_totp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_totp_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_totp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_totp_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->name = cf_section_name2(conf);
if (!inst->name) inst->name = cf_section_name1(conf);
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_totp_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_totp_t);
+ rlm_totp_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_totp_t);
FR_INTEGER_BOUND_CHECK("time_step", inst->totp.time_step, >=, 5);
FR_INTEGER_BOUND_CHECK("time_step", inst->totp.time_step, <=, 120);
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
rlm_totp_call_env_t *env_data = talloc_get_type_abort(mctx->env_data, rlm_totp_call_env_t);
- rlm_totp_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_totp_t);
+ rlm_totp_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_totp_t);
fr_value_box_t *user_password = &env_data->user_password;
fr_value_box_t *secret = &env_data->secret;
fr_value_box_t *key = &env_data->key;
*/
RCSID("$Id$")
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/module_rlm.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_unbound_t const *inst = talloc_get_type_abort_const(xctx->mctx->inst->data, rlm_unbound_t);
+ rlm_unbound_t const *inst = talloc_get_type_abort_const(xctx->mctx->mi->data, rlm_unbound_t);
rlm_unbound_thread_t *t = talloc_get_type_abort(xctx->mctx->thread, rlm_unbound_thread_t);
fr_value_box_t *host_vb = fr_value_box_list_head(in);
fr_value_box_t *query_vb = fr_value_box_list_next(in, host_vb);
static int mod_thread_instantiate(module_thread_inst_ctx_t const *mctx)
{
- rlm_unbound_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_unbound_t);
+ rlm_unbound_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_unbound_t);
rlm_unbound_thread_t *t = talloc_get_type_abort(mctx->thread, rlm_unbound_thread_t);
int res;
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_unbound_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_unbound_t);
+ rlm_unbound_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_unbound_t);
xlat_t *xlat;
- inst->name = mctx->inst->name;
+ inst->name = mctx->mi->name;
if (inst->timeout > 10000) {
- cf_log_err(mctx->inst->conf, "timeout must be 0 to 10000");
+ cf_log_err(mctx->mi->conf, "timeout must be 0 to 10000");
return -1;
}
RCSID("$Id$")
USES_APPLE_DEPRECATED_API
-#define LOG_PREFIX mctx->inst->name
+#define LOG_PREFIX mctx->mi->name
#include <freeradius-devel/radius/radius.h>
#include <freeradius-devel/server/base.h>
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_unix_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_unix_t);
+ rlm_unix_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_unix_t);
fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p = arg->vb_strvalue;
fr_value_box_t *vb;
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_unix_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_unix_t);
+ rlm_unix_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_unix_t);
xlat_t *xlat;
xlat_arg_parser_t *xlat_arg;
*/
static unlang_action_t CC_HINT(nonnull) mod_accounting(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_unix_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_unix_t);
+ rlm_unix_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_unix_t);
fr_pair_t *vp;
FILE *fp;
struct utmp ut;
*/
static unlang_action_t CC_HINT(nonnull) mod_post_auth(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_wimax_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_wimax_t);
+ rlm_wimax_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_wimax_t);
fr_pair_t *msk, *emsk, *vp;
fr_pair_t *mn_nai, *ip, *fa_rk;
EVP_MD_CTX *hmac_ctx;
xlat_ctx_t const *xctx,
request_t *request, fr_value_box_list_t *in)
{
- rlm_winbind_t const *inst = talloc_get_type_abort(xctx->mctx->inst->data, rlm_winbind_t);
+ rlm_winbind_t const *inst = talloc_get_type_abort(xctx->mctx->mi->data, rlm_winbind_t);
winbind_group_xlat_call_env_t *env = talloc_get_type_abort(xctx->env_data, winbind_group_xlat_call_env_t);
fr_value_box_t *arg = fr_value_box_list_head(in);
char const *p = arg->vb_strvalue;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_winbind_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_winbind_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_winbind_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_winbind_t);
+ CONF_SECTION *conf = mctx->mi->conf;
inst->wb_pool = module_rlm_connection_pool_init(conf, inst, mod_conn_create, NULL, NULL, NULL, NULL);
if (!inst->wb_pool) {
return -1;
}
- inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->inst->name, -1);
+ inst->auth_type = fr_dict_enum_by_name(attr_auth_type, mctx->mi->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. Winbind authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
return 0;
*/
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_winbind_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_winbind_t);
+ rlm_winbind_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_winbind_t);
fr_pool_free(inst->wb_pool);
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_winbind_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_winbind_t);
+ rlm_winbind_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_winbind_t);
winbind_autz_call_env_t *env = talloc_get_type_abort(mctx->env_data, winbind_autz_call_env_t);
fr_pair_t *vp;
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup Winbind authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_winbind_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_winbind_t);
+ rlm_winbind_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_winbind_t);
winbind_auth_call_env_t *env = talloc_get_type_abort(mctx->env_data, winbind_auth_call_env_t);
/*
*/
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_winbind_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_winbind_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_winbind_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_winbind_t);
+ CONF_SECTION *conf = mctx->mi->conf;
xlat_t *xlat;
/*
*/
unlang_action_t rlm_yubikey_decrypt(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request, char const *passcode)
{
- rlm_yubikey_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_yubikey_t);
+ rlm_yubikey_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_yubikey_t);
uint32_t counter, timestamp;
yubikey_token_st token;
#ifndef HAVE_YUBIKEY
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- rlm_yubikey_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_yubikey_t);
+ rlm_yubikey_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_yubikey_t);
if (inst->decrypt) {
- cf_log_err(mctx->inst->conf, "Requires libyubikey for OTP decryption");
+ cf_log_err(mctx->mi->conf, "Requires libyubikey for OTP decryption");
return -1;
}
return 0;
*/
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- rlm_yubikey_t *inst = talloc_get_type_abort(mctx->inst->data, rlm_yubikey_t);
- CONF_SECTION *conf = mctx->inst->conf;
+ rlm_yubikey_t *inst = talloc_get_type_abort(mctx->mi->data, rlm_yubikey_t);
+ CONF_SECTION *conf = mctx->mi->conf;
- inst->name = mctx->inst->name;
+ inst->name = mctx->mi->name;
inst->auth_type = fr_dict_enum_by_name(attr_auth_type, inst->name, -1);
if (!inst->auth_type) {
WARN("Failed to find 'authenticate %s {...}' section. Yubikey authentication will likely not work",
- mctx->inst->name);
+ mctx->mi->name);
}
if (inst->validate) {
#ifdef HAVE_YKCLIENT
static int mod_detach(module_detach_ctx_t const *mctx)
{
- rlm_yubikey_ykclient_detach(talloc_get_type_abort(mctx->inst->data, rlm_yubikey_t));
+ rlm_yubikey_ykclient_detach(talloc_get_type_abort(mctx->mi->data, rlm_yubikey_t));
return 0;
}
#endif
*/
static unlang_action_t CC_HINT(nonnull) mod_authorize(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_yubikey_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_yubikey_t);
+ rlm_yubikey_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_yubikey_t);
char const *passcode;
size_t len;
fr_pair_t *vp, *password;
if (!inst->auth_type) {
WARN("No 'authenticate %s {...}' section or 'Auth-Type = %s' set. Cannot setup Yubikey authentication",
- mctx->inst->name, mctx->inst->name);
+ mctx->mi->name, mctx->mi->name);
RETURN_MODULE_NOOP;
}
*/
static unlang_action_t CC_HINT(nonnull) mod_authenticate(rlm_rcode_t *p_result, module_ctx_t const *mctx, request_t *request)
{
- rlm_yubikey_t const *inst = talloc_get_type_abort_const(mctx->inst->data, rlm_yubikey_t);
+ rlm_yubikey_t const *inst = talloc_get_type_abort_const(mctx->mi->data, rlm_yubikey_t);
rlm_rcode_t rcode = RLM_MODULE_NOOP;
char const *passcode = NULL;
fr_pair_t const *vp;
unlang_action_t rlm_yubikey_validate(rlm_rcode_t *p_result, module_ctx_t const *mctx,
request_t *request, char const *passcode)
{
- rlm_yubikey_t const *inst = talloc_get_type_abort(mctx->inst->data, rlm_yubikey_t);
+ rlm_yubikey_t const *inst = talloc_get_type_abort(mctx->mi->data, rlm_yubikey_t);
rlm_rcode_t rcode = RLM_MODULE_OK;
ykclient_rc status;
ykclient_handle_t *yandle;
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_arp_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_arp_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "arp";
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_bfd_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_bfd_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "bfd";
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_dhcpv4_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_dhcpv4_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "dhcpv4";
{
CONF_SECTION *cs;
fr_process_state_t const *state;
- process_dhcpv6_t const *inst = mctx->inst->data;
+ process_dhcpv6_t const *inst = mctx->mi->data;
process_dhcpv6_client_fields_t *rctx = NULL;
PROCESS_TRACE;
{
CONF_SECTION *cs;
fr_process_state_t const *state;
- process_dhcpv6_t const *inst = mctx->inst->data;
+ process_dhcpv6_t const *inst = mctx->mi->data;
process_dhcpv6_client_fields_t *rctx;
PROCESS_TRACE;
*/
RESUME(send_to_client)
{
- process_dhcpv6_t *inst = talloc_get_type_abort(mctx->inst->data, process_dhcpv6_t);
+ process_dhcpv6_t *inst = talloc_get_type_abort(mctx->mi->data, process_dhcpv6_t);
process_dhcpv6_client_fields_t *fields = talloc_get_type_abort(mctx->rctx, process_dhcpv6_client_fields_t);
fr_process_state_t const *state;
{
CONF_SECTION *cs;
fr_process_state_t const *state;
- process_dhcpv6_t const *inst = mctx->inst->data;
+ process_dhcpv6_t const *inst = mctx->mi->data;
process_dhcpv6_relay_fields_t *rctx = NULL;
rctx = dhcpv6_relay_fields_store(request);
*/
RESUME(send_to_relay)
{
- process_dhcpv6_t *inst = talloc_get_type_abort(mctx->inst->data, process_dhcpv6_t);
+ process_dhcpv6_t *inst = talloc_get_type_abort(mctx->mi->data, process_dhcpv6_t);
process_dhcpv6_relay_fields_t *fields = talloc_get_type_abort(mctx->rctx, process_dhcpv6_relay_fields_t);
fr_process_state_t const *state;
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_dhcpv6_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_dhcpv6_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "dhcpv6";
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- process_dhcpv6_t *inst = talloc_get_type_abort(mctx->inst->data, process_dhcpv6_t);
+ process_dhcpv6_t *inst = talloc_get_type_abort(mctx->mi->data, process_dhcpv6_t);
- inst->server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
return 0;
}
*/
RESUME(recv_request)
{
- process_dns_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_dns_t);
+ process_dns_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_dns_t);
fr_process_state_t const *state;
fr_pair_t *rcode = NULL;
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_dns_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_dns_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "dns";
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
inst->type = FR_EAP_METHOD_AKA;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
inst->type = FR_EAP_METHOD_AKA_PRIME;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->inst->data, eap_aka_sim_process_conf_t);
+ eap_aka_sim_process_conf_t *inst = talloc_get_type_abort(mctx->mi->data, eap_aka_sim_process_conf_t);
inst->type = FR_EAP_METHOD_SIM;
{
fr_process_state_t const *state;
- (void) talloc_get_type_abort_const(mctx->inst->data, process_ldap_sync_t);
+ (void) talloc_get_type_abort_const(mctx->mi->data, process_ldap_sync_t);
PROCESS_TRACE;
RECV(access_request)
{
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
/*
* Only reject if the state has already been thawed.
CONF_SECTION *cs;
fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
RESUME(access_accept)
{
fr_pair_t *vp;
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
RESUME(access_reject)
{
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
RESUME(access_challenge)
{
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
CONF_SECTION *cs;
fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
- process_radius_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ process_radius_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
{
fr_process_state_t const *state;
- (void) talloc_get_type_abort_const(mctx->inst->data, process_radius_t);
+ (void) talloc_get_type_abort_const(mctx->mi->data, process_radius_t);
PROCESS_TRACE;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- process_radius_t *inst = talloc_get_type_abort(mctx->inst->data, process_radius_t);
+ process_radius_t *inst = talloc_get_type_abort(mctx->mi->data, process_radius_t);
inst->auth.state_tree = fr_state_tree_init(inst, attr_state, main_config->spawn_workers, inst->auth.max_session,
inst->auth.session_timeout, inst->auth.state_server_id,
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- process_radius_t *inst = talloc_get_type_abort(mctx->inst->data, process_radius_t);
+ process_radius_t *inst = talloc_get_type_abort(mctx->mi->data, process_radius_t);
- inst->server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
if (virtual_server_section_attribute_define(inst->server_cs, "authenticate", attr_auth_type) < 0) return -1;
return 0;
CONF_SECTION *cs;
fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
PROCESS_TRACE;
RESUME(auth_pass)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
PROCESS_TRACE;
RESUME(auth_fail)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
PROCESS_TRACE;
RESUME(auth_restart)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
PROCESS_TRACE;
RESUME(auth_get)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
process_tacacs_session_t *session;
fr_pair_t *vp, *copy;
RECV(auth_cont)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
process_tacacs_session_t *session;
if ((state_create(request->request_ctx, &request->request_pairs, request, false) < 0) ||
*/
RECV(auth_cont_abort)
{
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
if ((state_create(request->request_ctx, &request->request_pairs, request, false) < 0) ||
(fr_state_to_request(inst->auth.state_tree, request) < 0)) {
CONF_SECTION *cs;
fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
- process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
PROCESS_TRACE;
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_tacacs_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_tacacs_t);
fr_assert(FR_TACACS_PACKET_CODE_VALID(request->packet->code));
request->component = "tacacs";
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- process_tacacs_t *inst = talloc_get_type_abort(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t *inst = talloc_get_type_abort(mctx->mi->data, process_tacacs_t);
inst->auth.state_tree = fr_state_tree_init(inst, attr_tacacs_state, main_config->spawn_workers, inst->auth.max_session,
inst->auth.session_timeout, inst->auth.state_server_id,
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- process_tacacs_t *inst = talloc_get_type_abort(mctx->inst->data, process_tacacs_t);
+ process_tacacs_t *inst = talloc_get_type_abort(mctx->mi->data, process_tacacs_t);
- inst->server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
if (virtual_server_section_attribute_define(inst->server_cs, "authenticate", attr_auth_type) < 0) return -1;
FR_INTEGER_BOUND_CHECK("session.max_rounds", inst->auth.max_rounds, >=, 1);
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_test_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_test_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "test";
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_tls_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_tls_t);
request->component = "tls";
request->module = NULL;
CONF_SECTION *cs;
fr_dict_enum_value_t const *dv;
fr_process_state_t const *state;
- process_ttls_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_ttls_t);
+ process_ttls_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_ttls_t);
PROCESS_TRACE;
RESUME(access_accept)
{
fr_pair_t *vp;
- process_ttls_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_ttls_t);
+ process_ttls_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_ttls_t);
PROCESS_TRACE;
RESUME(access_reject)
{
- process_ttls_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_ttls_t);
+ process_ttls_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_ttls_t);
PROCESS_TRACE;
{
CONF_SECTION *cs;
fr_process_state_t const *state;
- process_ttls_t const *inst = talloc_get_type_abort_const(mctx->inst->data, process_ttls_t);
+ process_ttls_t const *inst = talloc_get_type_abort_const(mctx->mi->data, process_ttls_t);
PROCESS_TRACE;
{
fr_process_state_t const *state;
- (void) talloc_get_type_abort_const(mctx->inst->data, process_ttls_t);
+ (void) talloc_get_type_abort_const(mctx->mi->data, process_ttls_t);
PROCESS_TRACE;
static int mod_instantiate(module_inst_ctx_t const *mctx)
{
- process_ttls_t *inst = talloc_get_type_abort(mctx->inst->data, process_ttls_t);
+ process_ttls_t *inst = talloc_get_type_abort(mctx->mi->data, process_ttls_t);
inst->auth.state_tree = fr_state_tree_init(inst, attr_state, main_config->spawn_workers, inst->auth.session.max,
inst->auth.session.timeout, inst->auth.session.state_server_id,
static int mod_bootstrap(module_inst_ctx_t const *mctx)
{
- process_ttls_t *inst = talloc_get_type_abort(mctx->inst->data, process_ttls_t);
+ process_ttls_t *inst = talloc_get_type_abort(mctx->mi->data, process_ttls_t);
- inst->server_cs = cf_item_to_section(cf_parent(mctx->inst->conf));
+ inst->server_cs = cf_item_to_section(cf_parent(mctx->mi->conf));
if (virtual_server_section_attribute_define(inst->server_cs, "authenticate", attr_auth_type) < 0) return -1;
return 0;
PROCESS_TRACE;
- (void)talloc_get_type_abort_const(mctx->inst->data, process_vmps_t);
+ (void)talloc_get_type_abort_const(mctx->mi->data, process_vmps_t);
fr_assert(PROCESS_PACKET_CODE_VALID(request->packet->code));
request->component = "vmps";
projects / thirdparty / freeradius-server.git / commitdiff
