rlm_sql.c

Go to the documentation of this file.

/*
 *   This program is is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or (at
 *   your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/**
 * $Id: acefc287ac964fcefcd620f508b96fc7ea5a2e4e $
 * @file rlm_sql.c
 * @brief Implements SQL 'users' file, and SQL accounting.
 *
 * @copyright 2012-2014 Arran Cudbard-Bell (a.cudbardb@freeradius.org)
 * @copyright 2000,2006 The FreeRADIUS server project
 * @copyright 2000 Mike Machado (mike@innercite.com)
 * @copyright 2000 Alan DeKok (aland@freeradius.org)
 */
 
RCSID("$Id: acefc287ac964fcefcd620f508b96fc7ea5a2e4e $")
 
#define LOG_PREFIX mctx->inst->name
 
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/server/exfile.h>
#include <freeradius-devel/server/map_proc.h>
#include <freeradius-devel/server/module_rlm.h>
#include <freeradius-devel/server/pairmove.h>
#include <freeradius-devel/util/debug.h>
#include <freeradius-devel/util/table.h>
#include <freeradius-devel/unlang/function.h>
#include <freeradius-devel/unlang/xlat_func.h>
 
#include <sys/stat.h>
 
#include "rlm_sql.h"
 
extern module_rlm_t rlm_sql;
 
static const conf_parser_t module_config[] = {
        { FR_CONF_OFFSET_TYPE_FLAGS("driver", FR_TYPE_VOID, 0, rlm_sql_t, driver_submodule), .dflt = "null",
                         .func = module_rlm_submodule_parse },
        { FR_CONF_OFFSET("server", rlm_sql_config_t, sql_server), .dflt = "" }, /* Must be zero length so drivers can determine if it was set */
        { FR_CONF_OFFSET("port", rlm_sql_config_t, sql_port), .dflt = "0" },
        { FR_CONF_OFFSET("login", rlm_sql_config_t, sql_login), .dflt = "" },
        { FR_CONF_OFFSET_FLAGS("password", CONF_FLAG_SECRET, rlm_sql_config_t, sql_password), .dflt = "" },
        { FR_CONF_OFFSET("radius_db", rlm_sql_config_t, sql_db), .dflt = "radius" },
        { FR_CONF_OFFSET("read_groups", rlm_sql_config_t, read_groups), .dflt = "yes" },
        { FR_CONF_OFFSET("group_attribute", rlm_sql_config_t, group_attribute) },
        { FR_CONF_OFFSET("cache_groups", rlm_sql_config_t, cache_groups) },
        { FR_CONF_OFFSET("read_profiles", rlm_sql_config_t, read_profiles), .dflt = "yes" },
        { FR_CONF_OFFSET("open_query", rlm_sql_config_t, connect_query) },
 
        { FR_CONF_OFFSET("safe_characters", rlm_sql_config_t, allowed_chars), .dflt = "@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /" },
 
        /*
         *      This only works for a few drivers.
         */
        { FR_CONF_OFFSET("query_timeout", rlm_sql_config_t, query_timeout) },
 
        CONF_PARSER_TERMINATOR
};
 
static fr_dict_t const *dict_freeradius;
 
extern fr_dict_autoload_t rlm_sql_dict[];
fr_dict_autoload_t rlm_sql_dict[] = {
        { .out = &dict_freeradius, .proto = "freeradius" },
        { NULL }
};
 
static fr_dict_attr_t const *attr_fall_through;
static fr_dict_attr_t const *attr_sql_user_name;
static fr_dict_attr_t const *attr_user_profile;
static fr_dict_attr_t const *attr_expr_bool_enum;
 
extern fr_dict_attr_autoload_t rlm_sql_dict_attr[];
fr_dict_attr_autoload_t rlm_sql_dict_attr[] = {
        { .out = &attr_fall_through, .name = "Fall-Through", .type = FR_TYPE_BOOL, .dict = &dict_freeradius },
        { .out = &attr_sql_user_name, .name = "SQL-User-Name", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
        { .out = &attr_user_profile, .name = "User-Profile", .type = FR_TYPE_STRING, .dict = &dict_freeradius },
        { .out = &attr_expr_bool_enum, .name = "Expr-Bool-Enum", .type = FR_TYPE_BOOL, .dict = &dict_freeradius },
        { NULL }
};
 
typedef struct {
        fr_value_box_t  user;                   //!< Expansion of the sql_user_name
        tmpl_t          *check_query;           //!< Tmpl to expand to form authorize_check_query
        tmpl_t          *reply_query;           //!< Tmpl to expand to form authorize_reply_query
        tmpl_t          *membership_query;      //!< Tmpl to expand to form group_membership_query
        tmpl_t          *group_check_query;     //!< Tmpl to expand to form authorize_group_check_query
        tmpl_t          *group_reply_query;     //!< Tmpl to expand to form authorize_group_reply_query
} sql_autz_call_env_t;
 
static const call_env_method_t authorize_method_env = {
        FR_CALL_ENV_METHOD_OUT(sql_autz_call_env_t),
        .env = (call_env_parser_t[]) {
                { FR_CALL_ENV_OFFSET("sql_user_name", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_autz_call_env_t, user) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("authorize_check_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_autz_call_env_t, check_query) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("authorize_reply_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_autz_call_env_t, reply_query) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("group_membership_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_autz_call_env_t, membership_query) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("authorize_group_check_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_autz_call_env_t, group_check_query) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("authorize_group_reply_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_autz_call_env_t, group_reply_query) },
                CALL_ENV_TERMINATOR
        }
};
 
static int logfile_call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *out, tmpl_rules_t const *t_rules, CONF_ITEM *cc,
                                  char const *section_name1, char const *section_name2, void const *data, call_env_parser_t const *rule);
 
static int query_call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *out, tmpl_rules_t const *t_rules, CONF_ITEM *cc,
                                char const *section_name1, char const *section_name2, void const *data, call_env_parser_t const *rule);
 
typedef struct {
        fr_value_box_t  filename;
} sql_xlat_call_env_t;
 
static const call_env_method_t xlat_method_env = {
        FR_CALL_ENV_METHOD_OUT(sql_xlat_call_env_t),
        .env = (call_env_parser_t[]) {
                { FR_CALL_ENV_OFFSET("logfile", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_xlat_call_env_t, filename),
                  .pair.escape = {
                        .func = rad_filename_box_make_safe,
                        .safe_for = (fr_value_box_safe_for_t)rad_filename_box_make_safe,
                        .mode = TMPL_ESCAPE_PRE_CONCAT
                  },
                  .pair.literals_safe_for = (fr_value_box_safe_for_t)rad_filename_box_make_safe,
                },
                CALL_ENV_TERMINATOR
        }
};
 
typedef struct rlm_sql_grouplist_s rlm_sql_grouplist_t;
 
/** Status of the authorization process
 */
typedef enum {
        SQL_AUTZ_CHECK          = 0x11,         //!< Running user `check` query
        SQL_AUTZ_REPLY          = 0x12,         //!< Running user `reply` query
        SQL_AUTZ_GROUP_MEMB     = 0x20,         //!< Running group membership query
        SQL_AUTZ_GROUP_CHECK    = 0x21,         //!< Running group `check` query
        SQL_AUTZ_GROUP_REPLY    = 0x22,         //!< Running group `reply` query
        SQL_AUTZ_PROFILE_START  = 0x40,         //!< Starting processing user profiles
        SQL_AUTZ_PROFILE_CHECK  = 0x41,         //!< Running profile `check` query
        SQL_AUTZ_PROFILE_REPLY  = 0x42,         //!< Running profile `reply` query
} sql_autz_status_t;
 
#define SQL_AUTZ_STAGE_GROUP 0x20
#define SQL_AUTZ_STAGE_PROFILE 0x40
 
/** Context for SQL authorization
 */
typedef struct {
        rlm_sql_t const         *inst;          //!< Module instance.
        request_t               *request;       //!< Request being processed.
        rlm_rcode_t             rcode;          //!< Module return code.
        rlm_sql_handle_t        *handle;        //!< Database connection handle in use for current authorization.
        sql_autz_call_env_t     *call_env;      //!< Call environment data.
        map_list_t              check_tmp;      //!< List to store check items before processing.
        map_list_t              reply_tmp;      //!< List to store reply items before processing.
        sql_autz_status_t       status;         //!< Current status of the authorization.
        fr_value_box_list_t     query;          //!< Where expanded query tmpls will be written.
        bool                    user_found;     //!< Has the user been found anywhere?
        rlm_sql_grouplist_t     *groups;        //!< List of groups returned by the group membership query.
        rlm_sql_grouplist_t     *group;         //!< Current group being processed.
        fr_pair_t               *sql_group;     //!< Pair to update with group being processed.
        fr_pair_t               *profile;       //!< Current profile being processed.
} sql_autz_ctx_t;
 
typedef struct {
        fr_value_box_t          user;           //!< Expansion of sql_user_name.
        fr_value_box_t          filename;       //!< File name to write SQL logs to.
        tmpl_t                  **query;        //!< Array of tmpls for list of queries to run.
} sql_redundant_call_env_t;
 
static const call_env_method_t accounting_method_env = {
        FR_CALL_ENV_METHOD_OUT(sql_redundant_call_env_t),
        .env = (call_env_parser_t[]) {
                { FR_CALL_ENV_OFFSET("sql_user_name", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_redundant_call_env_t, user) },
                { FR_CALL_ENV_SUBSECTION_FUNC(CF_IDENT_ANY, CF_IDENT_ANY, CALL_ENV_FLAG_SUBSECTION, logfile_call_env_parse) },
                { FR_CALL_ENV_SUBSECTION_FUNC("accounting", CF_IDENT_ANY, CALL_ENV_FLAG_SUBSECTION, query_call_env_parse) },
                CALL_ENV_TERMINATOR
        }
};
 
static const call_env_method_t send_method_env = {
        FR_CALL_ENV_METHOD_OUT(sql_redundant_call_env_t),
        .env = (call_env_parser_t[]) {
                { FR_CALL_ENV_OFFSET("sql_user_name", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_redundant_call_env_t, user) },
                { FR_CALL_ENV_SUBSECTION_FUNC(CF_IDENT_ANY, CF_IDENT_ANY, CALL_ENV_FLAG_SUBSECTION, logfile_call_env_parse) },
                { FR_CALL_ENV_SUBSECTION_FUNC("send", CF_IDENT_ANY, CALL_ENV_FLAG_SUBSECTION, query_call_env_parse) },
                CALL_ENV_TERMINATOR
        }
};
 
/** Context for tracking redundant SQL query sets
 */
typedef struct {
        rlm_sql_t const                 *inst;          //!< Module instance.
        request_t                       *request;       //!< Request being processed.
        rlm_sql_handle_t                *handle;        //!< Database connection handle.
        sql_redundant_call_env_t        *call_env;      //!< Call environment data.
        size_t                          query_no;       //!< Current query number.
        fr_value_box_list_t             query;          //!< Where expanded query tmpl will be written.
} sql_redundant_ctx_t;
 
typedef struct {
        fr_value_box_t  user;
        tmpl_t          *membership_query;
} sql_group_xlat_call_env_t;
 
static const call_env_method_t group_xlat_method_env = {
        FR_CALL_ENV_METHOD_OUT(sql_group_xlat_call_env_t),
        .env = (call_env_parser_t[]) {
                { FR_CALL_ENV_OFFSET("sql_user_name", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_group_xlat_call_env_t, user) },
                { FR_CALL_ENV_PARSE_ONLY_OFFSET("group_membership_query", FR_TYPE_STRING, CALL_ENV_FLAG_PARSE_ONLY, sql_group_xlat_call_env_t, membership_query) },
                CALL_ENV_TERMINATOR
        }
};
 
static int _sql_escape_uxtx_free(void *uctx)
{
        return talloc_free(uctx);
}
 
/*
 *      Create a thread local uctx which is used in SQL value box escaping
 *      so that an already reserved connection can be used.
 */
static void *sql_escape_uctx_alloc(request_t *request, void const *uctx)
{
        static _Thread_local rlm_sql_escape_uctx_t      *t_ctx;
 
        if (unlikely(t_ctx == NULL)) {
                rlm_sql_escape_uctx_t *ctx;
 
                MEM(ctx = talloc_zero(NULL, rlm_sql_escape_uctx_t));
                fr_atexit_thread_local(t_ctx, _sql_escape_uxtx_free, ctx);
        }
        t_ctx->sql = uctx;
        t_ctx->handle = request_data_reference(request, (void *)sql_escape_uctx_alloc, 0);
 
        return t_ctx;
}
 
/*
 *      Fall-Through checking function from rlm_files.c
 */
static sql_fall_through_t fall_through(map_list_t *maps)
{
        bool rcode;
        map_t *map, *next;
 
        for (map = map_list_head(maps);
             map != NULL;
             map = next) {
                next = map_list_next(maps, map);
 
                fr_assert(tmpl_is_attr(map->lhs));
 
                if (tmpl_attr_tail_da(map->lhs) == attr_fall_through) {
                        (void) map_list_remove(maps, map);
 
                        if (tmpl_is_data(map->rhs)) {
                                fr_assert(tmpl_value_type(map->rhs) == FR_TYPE_BOOL);
 
                                rcode = tmpl_value(map->rhs)->vb_bool;
                        } else {
                                rcode = false;
                        }
 
                        talloc_free(map);
                        return rcode;
                }
        }
 
        return  FALL_THROUGH_DEFAULT;
}
 
/*
 *      Yucky prototype.
 */
static size_t sql_escape_func(request_t *, char *out, size_t outlen, char const *in, void *arg);
 
/** Escape a tainted VB used as an xlat argument
 *
 */
static int CC_HINT(nonnull(2,3)) sql_xlat_escape(request_t *request, fr_value_box_t *vb, void *uctx)
{
        fr_sbuff_t                      sbuff;
        fr_sbuff_uctx_talloc_t          sbuff_ctx;
 
        size_t                          len;
        rlm_sql_handle_t                *handle;
        rlm_sql_escape_uctx_t           *ctx = uctx;
        rlm_sql_t const                 *inst = talloc_get_type_abort_const(ctx->sql, rlm_sql_t);
        fr_value_box_entry_t            entry;
 
        /*
         *      If it's already safe, don't do anything.
         */
        if (fr_value_box_is_safe_for(vb, inst->driver)) return 0;
 
        handle = ctx->handle ? ctx->handle : fr_pool_connection_get(inst->pool, request);
        if (!handle) {
        error:
                fr_value_box_clear_value(vb);
                return -1;
        }
 
        /*
         *      Escaping functions work on strings - ensure the box is a string
         */
        if ((vb->type != FR_TYPE_STRING) && (fr_value_box_cast_in_place(vb, vb, FR_TYPE_STRING, NULL) < 0)) goto error;
 
        /*
         *      Maximum escaped length is 3 * original - if every character needs escaping
         */
        if (!fr_sbuff_init_talloc(vb, &sbuff, &sbuff_ctx, vb->vb_length * 3, vb->vb_length * 3)) {
                fr_strerror_printf_push("Failed to allocate buffer for escaped sql argument");
                return -1;
        }
 
        len = inst->sql_escape_func(request, fr_sbuff_buff(&sbuff), vb->vb_length * 3 + 1, vb->vb_strvalue, handle);
 
        /*
         *      fr_value_box_strdup_shallow resets the dlist entries - take a copy
         */
        entry = vb->entry;
        fr_sbuff_trim_talloc(&sbuff, len);
        fr_value_box_clear_value(vb);
        fr_value_box_strdup_shallow(vb, NULL, fr_sbuff_buff(&sbuff), vb->tainted);
 
        /*
         *      Different databases have slightly different ideas as
         *      to what is safe.  So we track the database type in the
         *      safe value.  This means that we don't
         *      cross-contaminate "safe" values across databases.
         */
        fr_value_box_mark_safe_for(vb, inst->driver);
        vb->entry = entry;
 
        if (!ctx->handle) fr_pool_connection_release(inst->pool, request, handle);
        return 0;
}
 
static int sql_box_escape(fr_value_box_t *vb, void *uctx)
{
        return sql_xlat_escape(NULL, vb, uctx);
}
 
/** Execute an arbitrary SQL query
 *
 * For SELECTs, the values of the first column will be returned.
 * For INSERTS, UPDATEs and DELETEs, the number of rows affected will
 * be returned instead.
 *
@verbatim
%sql(<sql statement>)
@endverbatim
 *
 * @ingroup xlat_functions
 */
static xlat_action_t sql_xlat(TALLOC_CTX *ctx, fr_dcursor_t *out,
                              xlat_ctx_t const *xctx,
                              request_t *request, fr_value_box_list_t *in)
{
        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);
        sql_rcode_t             rcode;
        xlat_action_t           ret = XLAT_ACTION_DONE;
        char const              *p;
        fr_value_box_t          *arg = fr_value_box_list_head(in);
        fr_value_box_t          *vb = NULL;
        bool                    fetched = false;
 
        handle = fr_pool_connection_get(inst->pool, request);   /* connection pool should produce error */
        if (!handle) return XLAT_ACTION_FAIL;
 
        if (call_env->filename.type == FR_TYPE_STRING && call_env->filename.vb_length > 0) {
                rlm_sql_query_log(inst, call_env->filename.vb_strvalue, arg->vb_strvalue);
        }
 
        p = arg->vb_strvalue;
 
        /*
         *      Trim whitespace for the prefix check
         */
        fr_skip_whitespace(p);
 
        /*
         *      If the query starts with any of the following prefixes,
         *      then return the number of rows affected
         */
        if ((strncasecmp(p, "insert", 6) == 0) ||
            (strncasecmp(p, "update", 6) == 0) ||
            (strncasecmp(p, "delete", 6) == 0)) {
                int numaffected;
 
                rcode = rlm_sql_query(inst, request, &handle, arg->vb_strvalue);
                if (rcode != RLM_SQL_OK) {
                query_error:
                        RERROR("SQL query failed: %s", fr_table_str_by_value(sql_rcode_description_table, rcode, "<INVALID>"));
 
                        ret = XLAT_ACTION_FAIL;
                        goto finish;
                }
 
                numaffected = (inst->driver->sql_affected_rows)(handle, &inst->config);
                if (numaffected < 1) {
                        RDEBUG2("SQL query affected no rows");
                        (inst->driver->sql_finish_query)(handle, &inst->config);
 
                        goto finish;
                }
 
                MEM(vb = fr_value_box_alloc_null(ctx));
                fr_value_box_uint32(vb, NULL, (uint32_t)numaffected, false);
                fr_dcursor_append(out, vb);
 
                (inst->driver->sql_finish_query)(handle, &inst->config);
 
                goto finish;
        } /* else it's a SELECT statement */
 
        rcode = rlm_sql_select_query(inst, request, &handle, arg->vb_strvalue);
        if (rcode != RLM_SQL_OK) goto query_error;
 
        do {
                rcode = rlm_sql_fetch_row(&row, inst, request, &handle);
                switch (rcode) {
                case RLM_SQL_OK:
                        if (row[0]) break;
 
                        RDEBUG2("NULL value in first column of result");
                        ret = XLAT_ACTION_FAIL;
 
                        goto finish_query;
 
                case RLM_SQL_NO_MORE_ROWS:
                        if (!fetched) {
                                RDEBUG2("SQL query returned no results");
                                ret = XLAT_ACTION_FAIL;
                        }
 
                        goto finish_query;
 
                default:
                        (inst->driver->sql_finish_select_query)(handle, &inst->config);
                        goto query_error;
                }
 
                fetched = true;
 
                MEM(vb = fr_value_box_alloc_null(ctx));
                fr_value_box_strdup(vb, vb, NULL, row[0], false);
                fr_dcursor_append(out, vb);
 
        } while (1);
 
finish_query:
        (inst->driver->sql_finish_select_query)(handle, &inst->config);
 
finish:
        fr_pool_connection_release(inst->pool, request, handle);
 
        return ret;
}
 
/** Converts a string value into a #fr_pair_t
 *
 * @param[in,out] ctx to allocate #fr_pair_t (s).
 * @param[out] out where to write the resulting #fr_pair_t.
 * @param[in] request The current request.
 * @param[in] map to process.
 * @param[in] uctx The value to parse.
 * @return
 *      - 0 on success.
 *      - -1 on failure.
 */
static int _sql_map_proc_get_value(TALLOC_CTX *ctx, fr_pair_list_t *out,
                                   request_t *request, map_t const *map, void *uctx)
{
        fr_pair_t       *vp;
        char const      *value = uctx;
 
        vp = fr_pair_afrom_da_nested(ctx, out, tmpl_attr_tail_da(map->lhs));
        if (!vp) return -1;
 
        /*
         *      Buffer not always talloced, sometimes it's
         *      just a pointer to a field in a result struct.
         */
        if (fr_pair_value_from_str(vp, value, strlen(value), NULL, true) < 0) {
                RPEDEBUG("Failed parsing value \"%pV\" for attribute %s",
                         fr_box_strvalue_buffer(value), vp->da->name);
                return -1;
        }
 
        return 0;
}
 
/*
 *      Verify the result of the map.
 */
static int sql_map_verify(CONF_SECTION *cs, UNUSED void *mod_inst, UNUSED void *proc_inst,
                          tmpl_t const *src, UNUSED map_list_t const *maps)
{
        if (!src) {
                cf_log_err(cs, "Missing SQL query");
 
                return -1;
        }
 
        return 0;
}
 
/** Executes a SELECT query and maps the result to server attributes
 *
 * @param p_result      Result of map expansion:
 *                      - #RLM_MODULE_NOOP no rows were returned or columns matched.
 *                      - #RLM_MODULE_UPDATED if one or more #fr_pair_t were added to the #request_t.
 *                      - #RLM_MODULE_FAIL if a fault occurred.
 * @param mod_inst #rlm_sql_t instance.
 * @param proc_inst Instance data for this specific mod_proc call (unused).
 * @param request The current request.
 * @param query string to execute.
 * @param maps Head of the map list.
 * @return UNLANG_ACTION_CALCULATE_RESULT
 */
static unlang_action_t mod_map_proc(rlm_rcode_t *p_result, void *mod_inst, UNUSED void *proc_inst, request_t *request,
                                    fr_value_box_list_t *query, map_list_t const *maps)
{
        rlm_sql_t               *inst = talloc_get_type_abort(mod_inst, rlm_sql_t);
        rlm_sql_handle_t        *handle = NULL;
 
        int                     i, j;
 
        rlm_rcode_t             rcode = RLM_MODULE_UPDATED;
        sql_rcode_t             ret;
 
        map_t const             *map;
 
        rlm_sql_row_t           row;
 
        int                     rows = 0;
        int                     field_cnt;
        char const              **fields = NULL, *map_rhs;
        char                    map_rhs_buff[128];
 
        char const              *query_str = NULL;
        fr_value_box_t          *query_head = fr_value_box_list_head(query);
 
#define MAX_SQL_FIELD_INDEX (64)
 
        int                     field_index[MAX_SQL_FIELD_INDEX];
        bool                    found_field = false;    /* Did we find any matching fields in the result set ? */
 
        fr_assert(inst->driver->sql_fields);            /* Should have been caught during validation... */
 
        if (!query_head) {
                REDEBUG("Query cannot be (null)");
                RETURN_MODULE_FAIL;
        }
 
        if (fr_value_box_list_concat_in_place(request,
                                              query_head, query, FR_TYPE_STRING,
                                              FR_VALUE_BOX_LIST_FREE, true,
                                              SIZE_MAX) < 0) {
                RPEDEBUG("Failed concatenating input string");
                RETURN_MODULE_FAIL;
        }
        query_str = query_head->vb_strvalue;
 
        for (i = 0; i < MAX_SQL_FIELD_INDEX; i++) field_index[i] = -1;
 
        handle = fr_pool_connection_get(inst->pool, request);           /* connection pool should produce error */
        if (!handle) {
                RETURN_MODULE_FAIL;
        }
 
        ret = rlm_sql_select_query(inst, request, &handle, query_str);
        if (ret != RLM_SQL_OK) {
                RERROR("SQL query failed: %s", fr_table_str_by_value(sql_rcode_description_table, ret, "<INVALID>"));
                rcode = RLM_MODULE_FAIL;
                goto finish;
        }
 
        /*
         *      Not every driver provides an sql_num_rows function
         */
        if (inst->driver->sql_num_rows) {
                ret = inst->driver->sql_num_rows(handle, &inst->config);
                if (ret == 0) {
                        RDEBUG2("Server returned an empty result");
                        rcode = RLM_MODULE_NOOP;
                        (inst->driver->sql_finish_select_query)(handle, &inst->config);
                        goto finish;
                }
 
                if (ret < 0) {
                        RERROR("Failed retrieving row count");
                error:
                        rcode = RLM_MODULE_FAIL;
                        (inst->driver->sql_finish_select_query)(handle, &inst->config);
                        goto finish;
                }
        }
 
        /*
         *      Map proc only registered if driver provides an sql_fields function
         */
        ret = (inst->driver->sql_fields)(&fields, handle, &inst->config);
        if (ret != RLM_SQL_OK) {
                RERROR("Failed retrieving field names: %s", fr_table_str_by_value(sql_rcode_description_table, ret, "<INVALID>"));
                goto error;
        }
        fr_assert(fields);
        field_cnt = talloc_array_length(fields);
 
        if (RDEBUG_ENABLED3) for (j = 0; j < field_cnt; j++) RDEBUG3("Got field: %s", fields[j]);
 
        /*
         *      Iterate over the maps, it's O(N2)ish but probably
         *      faster than building a radix tree each time the
         *      map set is evaluated (map->rhs can be dynamic).
         */
        for (map = map_list_head(maps), i = 0;
             map && (i < MAX_SQL_FIELD_INDEX);
             map = map_list_next(maps, map), i++) {
                /*
                 *      Expand the RHS to get the name of the SQL field
                 */
                if (tmpl_expand(&map_rhs, map_rhs_buff, sizeof(map_rhs_buff),
                                request, map->rhs, NULL, NULL) < 0) {
                        RPERROR("Failed getting field name");
                        goto error;
                }
 
                for (j = 0; j < field_cnt; j++) {
                        if (strcmp(fields[j], map_rhs) != 0) continue;
                        field_index[i] = j;
                        found_field = true;
                }
        }
 
        /*
         *      Couldn't resolve any map RHS values to fields
         *      in the result set.
         */
        if (!found_field) {
                RDEBUG2("No fields matching map found in query result");
                rcode = RLM_MODULE_NOOP;
                (inst->driver->sql_finish_select_query)(handle, &inst->config);
                goto finish;
        }
 
        /*
         *      We've resolved all the maps to result indexes, now convert
         *      the values at those indexes into fr_pair_ts.
         *
         *      Note: Not all SQL client libraries provide a row count,
         *      so we have to do the count here.
         */
        while (((ret = rlm_sql_fetch_row(&row, inst, request, &handle)) == RLM_SQL_OK)) {
                rows++;
                for (map = map_list_head(maps), j = 0;
                     map && (j < MAX_SQL_FIELD_INDEX);
                     map = map_list_next(maps, map), j++) {
                        if (field_index[j] < 0) continue;       /* We didn't find the map RHS in the field set */
                        if (map_to_request(request, map, _sql_map_proc_get_value, row[field_index[j]]) < 0) goto error;
                }
        }
 
        if (ret == RLM_SQL_ERROR) goto error;
 
        if (rows == 0) {
                RDEBUG2("SQL query returned no results");
                rcode = RLM_MODULE_NOOP;
        }
 
        (inst->driver->sql_finish_select_query)(handle, &inst->config);
 
finish:
        talloc_free(fields);
        fr_pool_connection_release(inst->pool, request, handle);
 
        RETURN_MODULE_RCODE(rcode);
}
 
 
/** xlat escape function for drivers which do not provide their own
 *
 */
static size_t sql_escape_func(UNUSED request_t *request, char *out, size_t outlen, char const *in, void *arg)
{
        rlm_sql_handle_t        *handle = arg;
        rlm_sql_t const         *inst = talloc_get_type_abort_const(handle->inst, rlm_sql_t);
        size_t                  len = 0;
 
        while (in[0]) {
                size_t utf8_len;
 
                /*
                 *      Allow all multi-byte UTF8 characters.
                 */
                utf8_len = fr_utf8_char((uint8_t const *) in, -1);
                if (utf8_len > 1) {
                        if (outlen <= utf8_len) break;
 
                        memcpy(out, in, utf8_len);
                        in += utf8_len;
                        out += utf8_len;
 
                        outlen -= utf8_len;
                        len += utf8_len;
                        continue;
                }
 
                /*
                 *      Because we register our own escape function
                 *      we're now responsible for escaping all special
                 *      chars in an xlat expansion or attribute value.
                 */
                switch (in[0]) {
                case '\n':
                        if (outlen <= 2) break;
                        out[0] = '\\';
                        out[1] = 'n';
 
                        in++;
                        out += 2;
                        outlen -= 2;
                        len += 2;
                        break;
 
                case '\r':
                        if (outlen <= 2) break;
                        out[0] = '\\';
                        out[1] = 'r';
 
                        in++;
                        out += 2;
                        outlen -= 2;
                        len += 2;
                        break;
 
                case '\t':
                        if (outlen <= 2) break;
                        out[0] = '\\';
                        out[1] = 't';
 
                        in++;
                        out += 2;
                        outlen -= 2;
                        len += 2;
                        break;
                }
 
                /*
                 *      Non-printable characters get replaced with their
                 *      mime-encoded equivalents.
                 */
                if ((in[0] < 32) ||
                    strchr(inst->config.allowed_chars, *in) == NULL) {
                        /*
                         *      Only 3 or less bytes available.
                         */
                        if (outlen <= 3) {
                                break;
                        }
 
                        snprintf(out, outlen, "=%02X", (unsigned char) in[0]);
                        in++;
                        out += 3;
                        outlen -= 3;
                        len += 3;
                        continue;
                }
 
                /*
                 *      Only one byte left.
                 */
                if (outlen <= 1) {
                        break;
                }
 
                /*
                 *      Allowed character.
                 */
                *out = *in;
                out++;
                in++;
                outlen--;
                len++;
        }
        *out = '\0';
        return len;
}
 
/*
 *      Set the SQL user name.
 *
 *      We don't call the escape function here. The resulting string
 *      will be escaped later in the queries xlat so we don't need to
 *      escape it twice. (it will make things wrong if we have an
 *      escape candidate character in the username)
 */
static void sql_set_user(rlm_sql_t const *inst, request_t *request, fr_value_box_t *user)
{
        fr_pair_t *vp = NULL;
 
        fr_assert(request->packet != NULL);
 
        MEM(pair_update_request(&vp, inst->sql_user) >= 0);
        if(!user || (user->type != FR_TYPE_STRING)) {
                pair_delete_request(vp);
                return;
        }
 
        /*
         *      Replace any existing SQL-User-Name with new value
         */
        fr_pair_value_bstrdup_buffer(vp, user->vb_strvalue, user->tainted);
        RDEBUG2("SQL-User-Name set to '%pV'", &vp->data);
}
 
/*
 *      Do a set/unset user, so it's a bit clearer what's going on.
 */
#define sql_unset_user(_i, _r) fr_pair_delete_by_da(&_r->request_pairs, _i->sql_user)
 
 
struct rlm_sql_grouplist_s {
        char                    *name;
        rlm_sql_grouplist_t     *next;
};
 
static int sql_get_grouplist(rlm_sql_t const *inst, rlm_sql_handle_t **handle, request_t *request,
                             char const *query, rlm_sql_grouplist_t **phead)
{
        int                     num_groups = 0;
        rlm_sql_row_t           row;
        rlm_sql_grouplist_t     *entry;
        int                     ret;
 
        /* NOTE: sql_set_user should have been run before calling this function */
 
        entry = *phead = NULL;
 
        if (!query || !*query) return 0;
 
        ret = rlm_sql_select_query(inst, request, handle, query);
        if (ret != RLM_SQL_OK) return -1;
 
        while (rlm_sql_fetch_row(&row, inst, request, handle) == RLM_SQL_OK) {
                if (!row[0]){
                        RDEBUG2("row[0] returned NULL");
                        (inst->driver->sql_finish_select_query)(*handle, &inst->config);
                        talloc_free(entry);
                        return -1;
                }
 
                if (!*phead || !entry) {        /* clang scan couldn't tell that when *phead != NULL then entry != NULL */
                        *phead = talloc_zero(*handle, rlm_sql_grouplist_t);
                        entry = *phead;
                } else {
                        entry->next = talloc_zero(*phead, rlm_sql_grouplist_t);
                        entry = entry->next;
                }
                entry->next = NULL;
                entry->name = talloc_typed_strdup(entry, row[0]);
 
                num_groups++;
        }
 
        (inst->driver->sql_finish_select_query)(*handle, &inst->config);
 
        return num_groups;
}
 
/** Check if a given group is in the SQL group for this user.
 *
 */
static bool CC_HINT(nonnull) sql_check_group(rlm_sql_t const *inst, request_t *request, char const *query, char const *name)
{
        bool rcode = false;
        rlm_sql_handle_t        *handle;
        rlm_sql_grouplist_t     *entry, *head = NULL;
 
        /*
         *      Get a socket for this lookup
         */
        handle = fr_pool_connection_get(inst->pool, request);
        if (!handle) {
                REDEBUG("Failed getting connection handle");
                return false;
        }
 
        /*
         *      Get the list of groups this user is a member of
         */
        if (sql_get_grouplist(inst, &handle, request, query, &head) < 0) {
                talloc_free(head);
                REDEBUG("Error getting group membership");
                fr_pool_connection_release(inst->pool, request, handle);
                return false;
        }
 
        for (entry = head; entry != NULL; entry = entry->next) {
                if (strcmp(entry->name, name) == 0) {
                        rcode = true;
                        break;
                }
        }
 
        /* Free the grouplist */
        talloc_free(head);
        fr_pool_connection_release(inst->pool, request, handle);
 
        return rcode;
}
 
typedef struct {
        fr_value_box_list_t     query;
} sql_group_xlat_ctx_t;
 
static xlat_action_t sql_group_xlat_resume(TALLOC_CTX *ctx, fr_dcursor_t *out, xlat_ctx_t const *xctx,
                                           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);
        fr_value_box_t          *arg = fr_value_box_list_head(in);
        char const              *p = arg->vb_strvalue;
        fr_value_box_t          *query, *vb;
 
        query = fr_value_box_list_head(&xlat_ctx->query);
        if (!query) return XLAT_ACTION_FAIL;
 
        fr_skip_whitespace(p);
 
        MEM(vb = fr_value_box_alloc(ctx, FR_TYPE_BOOL, attr_expr_bool_enum));
        vb->vb_bool = sql_check_group(inst, request, query->vb_strvalue, p);
        fr_dcursor_append(out, vb);
 
        return XLAT_ACTION_DONE;
}
 
 
/** Check if the user is a member of a particular group
 *
@verbatim
%sql.group(<name>)
@endverbatim
 *
 * @ingroup xlat_functions
 */
static xlat_action_t sql_group_xlat(UNUSED TALLOC_CTX *ctx, UNUSED fr_dcursor_t *out, xlat_ctx_t const *xctx,
                                    request_t *request, UNUSED fr_value_box_list_t *in)
{
        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);
 
        if (!call_env->membership_query) {
                RWARN("Cannot check group membership - group_membership_query not set");
                return XLAT_ACTION_FAIL;
        }
 
        /*
         *      Set the user attr here
         */
        sql_set_user(inst, request, &call_env->user);
 
        MEM(xlat_ctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), sql_group_xlat_ctx_t));
        fr_value_box_list_init(&xlat_ctx->query);
 
        if (unlang_xlat_yield(request, sql_group_xlat_resume, NULL, 0, xlat_ctx) != XLAT_ACTION_YIELD) return XLAT_ACTION_FAIL;
        if (unlang_tmpl_push(xlat_ctx, &xlat_ctx->query, request, call_env->membership_query, NULL) < 0) return XLAT_ACTION_FAIL;
        return XLAT_ACTION_PUSH_UNLANG;
}
 
/**  Process a "check" map
 *
 * Any entries using an assignment operator will be moved to the reply map
 * for later merging into the request.
 *
 * @param request       Current request.
 * @param check_map     to process.
 * @param reply_map     where any assignment entries will be moved.
 * @return
 *      - 0 if all the check entries pass.
 *      - -1 if the checks fail.
 */
static int check_map_process(request_t *request, map_list_t *check_map, map_list_t *reply_map)
{
        map_t *map, *next;
 
        for (map = map_list_head(check_map);
             map != NULL;
             map = next) {
                next = map_list_next(check_map, map);
 
                if (fr_assignment_op[map->op]) {
                        (void) map_list_remove(check_map, map);
                        map_list_insert_tail(reply_map, map);
                        continue;
                }
 
                if (!fr_comparison_op[map->op]) {
                        REDEBUG("Invalid operator '%s'", fr_tokens[map->op]);
                        goto fail;
                }
 
                if (fr_type_is_structural(tmpl_attr_tail_da(map->lhs)->type) &&
                    (map->op != T_OP_CMP_TRUE) && (map->op != T_OP_CMP_FALSE)) {
                        REDEBUG("Invalid comparison for structural type");
                        goto fail;
                }
 
                RDEBUG2("    &%s %s %s", map->lhs->name, fr_tokens[map->op], map->rhs->name);
                if (radius_legacy_map_cmp(request, map) != 1) {
                fail:
                        map_list_talloc_free(check_map);
                        map_list_talloc_free(reply_map);
                        RDEBUG2("failed match: skipping this entry");
                        return -1;
                }
        }
        return 0;
}
 
static int sql_autz_ctx_free(sql_autz_ctx_t *to_free)
{
        (void) request_data_get(to_free->request, (void *)sql_escape_uctx_alloc, 0);
        if (to_free->handle) fr_pool_connection_release(to_free->inst->pool, to_free->request, to_free->handle);
        map_list_talloc_free(&to_free->check_tmp);
        map_list_talloc_free(&to_free->reply_tmp);
        sql_unset_user(to_free->inst, to_free->request);
 
        return 0;
}
 
/** Resume function called after authorization group / profile expansion of check / reply query tmpl
 *
 * Groups and profiles are treated almost identically except:
 *   - groups are read from an SQL query
 *   - profiles are read from &control.User-Profile
 *   - if `cache_groups` is set, groups populate &control.SQL-Group
 *
 * Profiles are handled after groups, and will not happend if the last group resulted in `Fall-Through = no`
 *
 * Before each query is run, &request.SQL-Group is populated with the value of the group being evaluated.
 *
 * @param p_result      Result of current authorization.
 * @param priority      Unused.
 * @param request       Current request.
 * @param uctx          Current authorization context.
 * @return one of the RLM_MODULE_* values.
 */
static unlang_action_t mod_autz_group_resume(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
{
        sql_autz_ctx_t          *autz_ctx = talloc_get_type_abort(uctx, sql_autz_ctx_t);
        sql_autz_call_env_t     *call_env = autz_ctx->call_env;
        rlm_sql_t const         *inst = autz_ctx->inst;
        fr_value_box_t          *query = fr_value_box_list_pop_head(&autz_ctx->query);
        int                     rows;
        sql_fall_through_t      do_fall_through = FALL_THROUGH_DEFAULT;
        fr_pair_t               *vp;
 
        switch(autz_ctx->status) {
        case SQL_AUTZ_GROUP_MEMB:
                rows = sql_get_grouplist(inst, &autz_ctx->handle, request, query->vb_strvalue, &autz_ctx->groups);
                talloc_free(query);
 
                if (rows < 0) {
                        talloc_free(autz_ctx->groups);
                        REDEBUG("Error retrieving group list");
                        RETURN_MODULE_FAIL;
                }
 
                if (rows == 0) {
                        RDEBUG2("User not found in any groups");
                        break;
                }
                fr_assert(autz_ctx->groups);
 
                RDEBUG2("User found in the group table");
                autz_ctx->user_found = true;
                autz_ctx->group = autz_ctx->groups;
                MEM(pair_update_request(&autz_ctx->sql_group, inst->group_da) >= 0);
 
        next_group:
                fr_pair_value_strdup(autz_ctx->sql_group, autz_ctx->group->name, true);
                autz_ctx->status = SQL_AUTZ_GROUP_CHECK;
                FALL_THROUGH;
 
        case SQL_AUTZ_PROFILE_START:
        next_profile:
                if (autz_ctx->status & SQL_AUTZ_STAGE_PROFILE) {
                        fr_pair_value_strdup(autz_ctx->sql_group, autz_ctx->profile->vp_strvalue, true);
                        autz_ctx->status = SQL_AUTZ_PROFILE_CHECK;
                }
                RDEBUG3("Processing %s %pV",
                        autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "group" : "profile", &autz_ctx->sql_group->data);
                if (inst->config.cache_groups && autz_ctx->status & SQL_AUTZ_STAGE_GROUP) {
                        MEM(pair_append_control(&vp, inst->group_da) >= 0);
                        fr_pair_value_strdup(vp, autz_ctx->group->name, true);
                }
 
                if (call_env->group_check_query) {
                        if (unlang_function_repeat_set(request, mod_autz_group_resume) < 0) RETURN_MODULE_FAIL;
                        if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request,
                                             call_env->group_check_query, NULL) < 0) RETURN_MODULE_FAIL;
                        return UNLANG_ACTION_PUSHED_CHILD;
                }
 
                goto group_reply_push;
 
        case SQL_AUTZ_GROUP_CHECK:
        case SQL_AUTZ_PROFILE_CHECK:
                rows = sql_get_map_list(autz_ctx, inst, request, &autz_ctx->handle, &autz_ctx->check_tmp,
                                        query->vb_strvalue, request_attr_request);
                talloc_free(query);
 
                if (rows < 0) {
                        REDEBUG("Error retrieving check pairs for %s %pV",
                                autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "group" : "profile",
                                &autz_ctx->sql_group->data);
                        RETURN_MODULE_FAIL;
                }
 
                /*
                 *      If we got check rows we need to process them before we decide to
                 *      process the reply rows
                 */
                if (rows > 0) {
                        if (check_map_process(request, &autz_ctx->check_tmp, &autz_ctx->reply_tmp) < 0) {
                                map_list_talloc_free(&autz_ctx->check_tmp);
                                goto next_group_find;
                        }
                        RDEBUG2("%s \"%pV\": Conditional check items matched",
                                autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "Group" : "Profile", &autz_ctx->sql_group->data);
                } else {
                        RDEBUG2("%s \"%pV\": Conditional check items matched (empty)",
                                autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "Group" : "Profile", &autz_ctx->sql_group->data);
                }
 
                if (autz_ctx->rcode == RLM_MODULE_NOOP) autz_ctx->rcode = RLM_MODULE_OK;
 
                map_list_talloc_free(&autz_ctx->check_tmp);
 
                if (call_env->group_reply_query) {
                group_reply_push:
                        if (unlang_function_repeat_set(request, mod_autz_group_resume) < 0) RETURN_MODULE_FAIL;
                        if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request,
                                             call_env->group_reply_query, NULL) < 0) RETURN_MODULE_FAIL;
                        autz_ctx->status = autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? SQL_AUTZ_GROUP_REPLY : SQL_AUTZ_PROFILE_REPLY;
                        return UNLANG_ACTION_PUSHED_CHILD;
                }
 
                if (map_list_num_elements(&autz_ctx->reply_tmp)) goto group_attr_cache;
 
                goto next_group_find;
 
        case SQL_AUTZ_GROUP_REPLY:
        case SQL_AUTZ_PROFILE_REPLY:
                rows = sql_get_map_list(autz_ctx, inst, request, &autz_ctx->handle, &autz_ctx->reply_tmp,
                                        query->vb_strvalue, request_attr_reply);
                talloc_free(query);
 
                if (rows < 0) {
                        REDEBUG("Error retrieving reply pairs for %s %pV",
                                autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "group" : "profile", &autz_ctx->sql_group->data);
                        RETURN_MODULE_FAIL;
                }
 
                if (rows == 0) {
                        do_fall_through = FALL_THROUGH_DEFAULT;
                        goto group_attr_cache;
                }
 
                fr_assert(!map_list_empty(&autz_ctx->reply_tmp)); /* coverity, among others */
                do_fall_through = fall_through(&autz_ctx->reply_tmp);
 
        group_attr_cache:
                if (inst->config.cache_groups && autz_ctx->status & SQL_AUTZ_STAGE_GROUP) {
                        MEM(pair_append_control(&vp, inst->group_da) >= 0);
                        fr_pair_value_strdup(vp, autz_ctx->group->name, true);
                }
 
                if (map_list_num_elements(&autz_ctx->reply_tmp) == 0) goto next_group_find;
                RDEBUG2("%s \"%pV\": Merging control and reply items",
                        autz_ctx->status & SQL_AUTZ_STAGE_GROUP ? "Group" : "Profile", &autz_ctx->sql_group->data);
                autz_ctx->rcode = RLM_MODULE_UPDATED;
 
                RINDENT();
                if (radius_legacy_map_list_apply(request, &autz_ctx->reply_tmp, NULL) < 0) {
                        RPEDEBUG("Failed applying reply item");
                        REXDENT();
                        RETURN_MODULE_FAIL;
                }
                REXDENT();
                map_list_talloc_free(&autz_ctx->reply_tmp);
 
        next_group_find:
                if (do_fall_through != FALL_THROUGH_YES) break;
                if (autz_ctx->status & SQL_AUTZ_STAGE_PROFILE) {
                        autz_ctx->profile = fr_pair_find_by_da(&request->control_pairs, autz_ctx->profile, attr_user_profile);
                        if (autz_ctx->profile) goto next_profile;
                        break;
                }
                autz_ctx->group = autz_ctx->group->next;
                if (autz_ctx->group) goto next_group;
 
                break;
 
        default:
                fr_assert(0);
        }
 
        /*
         *      If group processing has completed, check to see if profile processing should be done
         */
        if ((autz_ctx->status & SQL_AUTZ_STAGE_GROUP) &&
            ((do_fall_through == FALL_THROUGH_YES) ||
             (inst->config.read_profiles && (do_fall_through == FALL_THROUGH_DEFAULT)))) {
                RDEBUG3("... falling-through to profile processing");
 
                autz_ctx->profile = fr_pair_find_by_da(&request->control_pairs, NULL, attr_user_profile);
                if (autz_ctx->profile) {
                        MEM(pair_update_request(&autz_ctx->sql_group, inst->group_da) >= 0);
                        autz_ctx->status = SQL_AUTZ_PROFILE_START;
                        goto next_profile;
                }
        }
 
        if (!autz_ctx->user_found) RETURN_MODULE_NOTFOUND;
 
        RETURN_MODULE_RCODE(autz_ctx->rcode);
}
 
/** Resume function called after authorization check / reply tmpl expansion
 *
 * @param p_result      Result of current authorization.
 * @param priority      Unused.
 * @param request       Current request.
 * @param uctx          Current authorization context.
 * @return one of the RLM_MODULE_* values.
 */
static unlang_action_t mod_authorize_resume(rlm_rcode_t *p_result, int *priority, request_t *request, void *uctx)
{
        sql_autz_ctx_t          *autz_ctx = talloc_get_type_abort(uctx, sql_autz_ctx_t);
        sql_autz_call_env_t     *call_env = autz_ctx->call_env;
        rlm_sql_t const         *inst = autz_ctx->inst;
        fr_value_box_t          *query = fr_value_box_list_pop_head(&autz_ctx->query);
        int                     rows;
        sql_fall_through_t      do_fall_through = FALL_THROUGH_DEFAULT;
 
        switch(autz_ctx->status) {
        case SQL_AUTZ_CHECK:
                rows = sql_get_map_list(autz_ctx, inst, request, &autz_ctx->handle, &autz_ctx->check_tmp,
                                        query->vb_strvalue, request_attr_request);
                talloc_free(query);
 
                if (rows < 0) {
                        REDEBUG("Failed getting check attributes");
                        RETURN_MODULE_FAIL;
                }
 
                if (rows == 0) goto skip_reply; /* Don't need to handle map entries we don't have */
 
                /*
                 *      Only do this if *some* check pairs were returned
                 */
                RDEBUG2("User found in radcheck table");
                autz_ctx->user_found = true;
 
                if (check_map_process(request, &autz_ctx->check_tmp, &autz_ctx->reply_tmp) < 0) goto skip_reply;
                RDEBUG2("Conditional check items matched");
 
                autz_ctx->rcode = RLM_MODULE_OK;
                map_list_talloc_free(&autz_ctx->check_tmp);
 
                if (!call_env->reply_query) goto skip_reply;
 
                if (unlang_function_repeat_set(request, mod_authorize_resume) < 0) RETURN_MODULE_FAIL;
                if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request, call_env->reply_query, NULL) < 0) RETURN_MODULE_FAIL;
                autz_ctx->status = SQL_AUTZ_REPLY;
                return UNLANG_ACTION_PUSHED_CHILD;
 
        case SQL_AUTZ_REPLY:
                rows = sql_get_map_list(autz_ctx, inst, request, &autz_ctx->handle, &autz_ctx->reply_tmp,
                                        query->vb_strvalue, request_attr_reply);
                talloc_free(query);
 
                if (rows < 0) {
                        REDEBUG("SQL query error getting reply attributes");
                        RETURN_MODULE_FAIL;
                }
 
                if (rows == 0) goto skip_reply;
 
                do_fall_through = fall_through(&autz_ctx->reply_tmp);
 
                RDEBUG2("User found in radreply table");
                autz_ctx->user_found = true;
 
        skip_reply:
                if (map_list_num_elements(&autz_ctx->reply_tmp)) {
                        RDEBUG2("Merging control and reply items");
                        RINDENT();
                        if (radius_legacy_map_list_apply(request, &autz_ctx->reply_tmp, NULL) < 0) {
                                RPEDEBUG("Failed applying item");
                                REXDENT();
                                RETURN_MODULE_FAIL;
                        }
                        REXDENT();
 
                        autz_ctx->rcode = RLM_MODULE_UPDATED;
                        map_list_talloc_free(&autz_ctx->reply_tmp);
                }
 
                if ((do_fall_through == FALL_THROUGH_YES) ||
                    (inst->config.read_groups && (do_fall_through == FALL_THROUGH_DEFAULT))) {
                        RDEBUG3("... falling-through to group processing");
 
                        if (!call_env->membership_query) {
                                RWARN("Cannot check groups when group_membership_query is not set");
                                break;
                        }
 
                        if (!call_env->group_check_query && !call_env->group_reply_query) {
                                RWARN("Cannot process groups when neither authorize_group_check_query nor authorize_group_check_query are set");
                                break;
                        }
 
                        if (unlang_function_repeat_set(request, mod_autz_group_resume) < 0) RETURN_MODULE_FAIL;
                        if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request,
                                             call_env->membership_query, NULL) < 0) RETURN_MODULE_FAIL;
                        autz_ctx->status = SQL_AUTZ_GROUP_MEMB;
                        return UNLANG_ACTION_PUSHED_CHILD;
                }
 
                if ((do_fall_through == FALL_THROUGH_YES) ||
                    (inst->config.read_profiles && (do_fall_through == FALL_THROUGH_DEFAULT))) {
                        RDEBUG3("... falling-through to profile processing");
 
                        if (!call_env->group_check_query && !call_env->group_reply_query) {
                                RWARN("Cannot process profiles when neither authorize_group_check_query nor authorize_group_check_query are set");
                                break;
                        }
 
                        autz_ctx->profile = fr_pair_find_by_da(&request->control_pairs, NULL, attr_user_profile);
                        if (!autz_ctx->profile) break;
 
                        MEM(pair_update_request(&autz_ctx->sql_group, inst->group_da) >= 0);
                        autz_ctx->status = SQL_AUTZ_PROFILE_START;
                        return mod_autz_group_resume(p_result, priority, request, autz_ctx);
                }
                break;
 
        default:
                fr_assert(0);
        }
 
        if (!autz_ctx->user_found) RETURN_MODULE_NOTFOUND;
        RETURN_MODULE_RCODE(autz_ctx->rcode);
}
 
/** Start of module authorize method
 *
 * Pushes the tmpl relating to the first required query for evaluation
 */
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);
        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;
 
        fr_assert(request->packet != NULL);
        fr_assert(request->reply != NULL);
 
        if (!call_env->check_query && !call_env->reply_query && !(inst->config.read_groups && call_env->membership_query)) {
                RWDEBUG("No authorization checks configured, returning noop");
                RETURN_MODULE_NOOP;
        }
 
        /*
         *      Set and check the user attr here
         */
        sql_set_user(inst, request, &call_env->user);
 
        MEM(autz_ctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), sql_autz_ctx_t));
        *autz_ctx = (sql_autz_ctx_t) {
                .inst = inst,
                .call_env = call_env,
                .request = request,
                .rcode = RLM_MODULE_NOOP
        };
        map_list_init(&autz_ctx->check_tmp);
        map_list_init(&autz_ctx->reply_tmp);
        talloc_set_destructor(autz_ctx, sql_autz_ctx_free);
 
        /*
         *      Reserve a socket
         *
         *      This is freed by the talloc destructor for autz_ctx
         */
        autz_ctx->handle = fr_pool_connection_get(inst->pool, request);
        if (!autz_ctx->handle) RETURN_MODULE_FAIL;
 
        request_data_add(request, (void *)sql_escape_uctx_alloc, 0, autz_ctx->handle, false, false, false);
 
        if (unlang_function_push(request, NULL, mod_authorize_resume, NULL, 0,
                                 UNLANG_SUB_FRAME, autz_ctx) < 0) {
        error:
                talloc_free(autz_ctx);
                RETURN_MODULE_FAIL;
        }
 
        fr_value_box_list_init(&autz_ctx->query);
 
        /*
         *      Query the check table to find any conditions associated with this user/realm/whatever...
         */
        if (call_env->check_query) {
                if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request, call_env->check_query, NULL) < 0) goto error;
                autz_ctx->status = SQL_AUTZ_CHECK;
                return UNLANG_ACTION_PUSHED_CHILD;
        }
 
        if (call_env->reply_query) {
                if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request, call_env->reply_query, NULL) < 0) goto error;
                autz_ctx->status = SQL_AUTZ_REPLY;
                return UNLANG_ACTION_PUSHED_CHILD;
        }
 
        /*
         *      Neither check nor reply queries were set, so we must be doing group stuff
         */
        if (unlang_tmpl_push(autz_ctx, &autz_ctx->query, request, call_env->membership_query, NULL) < 0) goto error;
        autz_ctx->status = SQL_AUTZ_GROUP_MEMB;
        return UNLANG_ACTION_PUSHED_CHILD;
}
 
/** Tidy up when freeing an SQL redundant context
 *
 * Release the connection handle and unset the SQL-User attribute.
 */
static int sql_redundant_ctx_free(sql_redundant_ctx_t *to_free)
{
        (void) request_data_get(to_free->request, (void *)sql_escape_uctx_alloc, 0);
        if (to_free->handle) fr_pool_connection_release(to_free->inst->pool, to_free->request, to_free->handle);
        sql_unset_user(to_free->inst, to_free->request);
 
        return 0;
}
 
/** Resume function called after expansion of next query in a redundant list of queries
 *
 * @param p_result      Result of current module call.
 * @param priority      Unused.
 * @param request       Current request.
 * @param uctx          Current redundant sql context.
 * @return one of the RLM_MODULE_* values.
 */
static unlang_action_t mod_sql_redundant_resume(rlm_rcode_t *p_result, UNUSED int *priority, request_t *request, void *uctx)
{
        sql_redundant_ctx_t             *redundant_ctx = talloc_get_type_abort(uctx, sql_redundant_ctx_t);
        sql_redundant_call_env_t        *call_env = redundant_ctx->call_env;
        rlm_sql_t const                 *inst = redundant_ctx->inst;
        fr_value_box_t                  *query;
        int                             sql_ret;
        int                             numaffected = 0;
        tmpl_t                          *next_query;
 
        query = fr_value_box_list_pop_head(&redundant_ctx->query);
        if (!query) RETURN_MODULE_FAIL;
 
        if ((call_env->filename.type == FR_TYPE_STRING) && (call_env->filename.vb_length > 0)) {
                rlm_sql_query_log(inst, call_env->filename.vb_strvalue, query->vb_strvalue);
        }
 
        sql_ret = rlm_sql_query(inst, request, &redundant_ctx->handle, query->vb_strvalue);
        talloc_free(query);
 
        RDEBUG2("SQL query returned: %s", fr_table_str_by_value(sql_rcode_description_table, sql_ret, "<INVALID>"));
 
        switch (sql_ret) {
        /*
         *      Query was a success! Now we just need to check if it did anything.
         */
        case RLM_SQL_OK:
                break;
 
        /*
         *      A general, unrecoverable server fault.
         */
        case RLM_SQL_ERROR:
        /*
         *      If we get RLM_SQL_RECONNECT it means all connections in the pool
         *      were exhausted, and we couldn't create a new connection,
         *      so we do not need to call fr_pool_connection_release.
         */
        case RLM_SQL_RECONNECT:
                RETURN_MODULE_FAIL;
 
        /*
         *      Query was invalid, this is a terminal error.
         */
        case RLM_SQL_QUERY_INVALID:
                RETURN_MODULE_INVALID;
 
        /*
         *      Driver found an error (like a unique key constraint violation)
         *      that hinted it might be a good idea to try an alternative query.
         */
        case RLM_SQL_ALT_QUERY:
                goto next;
        }
        fr_assert(redundant_ctx->handle);
 
        /*
         *      We need to have updated something for the query to have been
         *      counted as successful.
         */
        numaffected = (inst->driver->sql_affected_rows)(redundant_ctx->handle, &inst->config);
        (inst->driver->sql_finish_query)(redundant_ctx->handle, &inst->config);
        RDEBUG2("%i record(s) updated", numaffected);
 
        if (numaffected > 0) RETURN_MODULE_OK;  /* A query succeeded, were done! */
next:
        /*
         *      Look to see if there are any more queries to expand
         */
        redundant_ctx->query_no++;
        if (redundant_ctx->query_no >= talloc_array_length(call_env->query)) RETURN_MODULE_NOOP;
        next_query = *(tmpl_t **)((uint8_t *)call_env->query + sizeof(void *) * redundant_ctx->query_no);
        if (unlang_function_repeat_set(request, mod_sql_redundant_resume) < 0) RETURN_MODULE_FAIL;
        if (unlang_tmpl_push(redundant_ctx, &redundant_ctx->query, request, next_query, NULL) < 0) RETURN_MODULE_FAIL;
 
        RDEBUG2("Trying next query...");
 
        return UNLANG_ACTION_PUSHED_CHILD;
}
 
/**  Generic module call for failing between a bunch of queries.
 *
 * Used for `accounting` and `send` module calls
 *
 */
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);
        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;
 
        /*
         *      No query to expand - do nothing.
         */
        if (!call_env->query) {
                RWARN("No query configured");
                RETURN_MODULE_NOOP;
        }
 
        MEM(redundant_ctx = talloc_zero(unlang_interpret_frame_talloc_ctx(request), sql_redundant_ctx_t));
        *redundant_ctx = (sql_redundant_ctx_t) {
                .inst = inst,
                .request = request,
                .call_env = call_env,
                .query_no = 0
        };
        talloc_set_destructor(redundant_ctx, sql_redundant_ctx_free);
 
        redundant_ctx->handle = fr_pool_connection_get(inst->pool, request);
        if (!redundant_ctx->handle) RETURN_MODULE_FAIL;
 
        request_data_add(request, (void *)sql_escape_uctx_alloc, 0, redundant_ctx->handle, false, false, false);
 
        sql_set_user(inst, request, &call_env->user);
 
        if (unlang_function_push(request, NULL, mod_sql_redundant_resume, NULL, 0,
                                 UNLANG_SUB_FRAME, redundant_ctx) < 0) RETURN_MODULE_FAIL;
 
        fr_value_box_list_init(&redundant_ctx->query);
        if (unlang_tmpl_push(redundant_ctx, &redundant_ctx->query, request, *call_env->query, NULL) < 0) RETURN_MODULE_FAIL;
 
        return UNLANG_ACTION_PUSHED_CHILD;
}
 
static int logfile_call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *out, tmpl_rules_t const *t_rules,
                                  CONF_ITEM *ci, char const *section_name1, char const *section_name2,
                                  UNUSED void const *data, UNUSED call_env_parser_t const *rule)
{
        CONF_SECTION const      *subcs = NULL, *subsubcs = NULL;
        CONF_PAIR const         *to_parse = NULL;
        tmpl_t                  *parsed_tmpl;
        call_env_parsed_t       *parsed_env;
        tmpl_rules_t            our_rules;
        char                    *section2, *p;
 
        /*
         *      The call env subsection which calls this has CF_IDENT_ANY as its name
         *      which results in finding the first child section of the module config.
         *      We actually want the whole module config - so go to the parent.
         */
        ci = cf_parent(ci);
 
        /*
         *      Find the instance of "logfile" to parse
         *
         *      If the module call is from `accounting Start` then first is
         *              <module> { accounting { start { logfile } } }
         *      then
         *              <module> { accounting { logfile } }
         *      falling back to
         *              <module> { logfile }
         */
        subcs = cf_section_find(cf_item_to_section(ci), section_name1, CF_IDENT_ANY);
        if (subcs) {
                if (section_name2) {
                        section2 = talloc_strdup(NULL, section_name2);
                        p = section2;
                        while (*p != '\0') {
                                *(p) = tolower((uint8_t)*p);
                                p++;
                        }
                        subsubcs = cf_section_find(subcs, section2, CF_IDENT_ANY);
                        talloc_free(section2);
                        if (subsubcs) to_parse = cf_pair_find(subsubcs, "logfile");
                }
                if (!to_parse) to_parse = cf_pair_find(subcs, "logfile");
        }
 
        if (!to_parse) to_parse = cf_pair_find(cf_item_to_section(ci), "logfile");
 
        if (!to_parse) return 0;
 
        /*
         *      Use filename safety escape functions
         */
        our_rules = *t_rules;
        our_rules.escape.func = rad_filename_box_make_safe;
        our_rules.escape.safe_for = (fr_value_box_safe_for_t)rad_filename_box_make_safe;
        our_rules.escape.mode = TMPL_ESCAPE_PRE_CONCAT;
        our_rules.literals_safe_for = our_rules.escape.safe_for;
 
        MEM(parsed_env = call_env_parsed_add(ctx, out,
                                             &(call_env_parser_t){ FR_CALL_ENV_OFFSET("logfile", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT, sql_redundant_call_env_t, filename)}));
 
        if (tmpl_afrom_substr(parsed_env, &parsed_tmpl,
                              &FR_SBUFF_IN(cf_pair_value(to_parse), talloc_array_length(cf_pair_value(to_parse)) - 1),
                              cf_pair_value_quote(to_parse), NULL, &our_rules) < 0) {
        error:
                call_env_parsed_free(out, parsed_env);
                return -1;
        }
        if (tmpl_needs_resolving(parsed_tmpl) &&
            (tmpl_resolve(parsed_tmpl, &(tmpl_res_rules_t){ .dict_def = our_rules.attr.dict_def }) < 0)) goto error;
 
        call_env_parsed_set_tmpl(parsed_env, parsed_tmpl);
 
        return 0;
}
 
static int query_call_env_parse(TALLOC_CTX *ctx, call_env_parsed_head_t *out, tmpl_rules_t const *t_rules,
                                CONF_ITEM *ci, UNUSED char const *section_name1, char const *section_name2,
                                void const *data, UNUSED call_env_parser_t const *rule)
{
        rlm_sql_t const         *inst = talloc_get_type_abort_const(data, rlm_sql_t);
        CONF_SECTION const      *subcs = NULL;
        CONF_PAIR const         *to_parse = NULL;
        tmpl_t                  *parsed_tmpl;
        call_env_parsed_t       *parsed_env;
        tmpl_rules_t            our_rules;
        char                    *section2, *p;
        ssize_t                 count, slen, multi_index = 0;
 
        if (!section_name2) return -1;
 
        /*
         *      Find the instance(s) of "query" to parse
         *
         *      If the module call is from `accounting Start` then it should be
         *              <module> { accounting { start { query } } }
         */
        section2 = talloc_strdup(NULL, section_name2);
        p = section2;
        while (*p != '\0') {
                *(p) = tolower((uint8_t)*p);
                p++;
        }
        subcs = cf_section_find(cf_item_to_section(ci), section2, CF_IDENT_ANY);
        talloc_free(section2);
        if (!subcs) return 0;
 
        /*
         *      Use module specific escape functions
         */
        our_rules = *t_rules;
        our_rules.escape.func = inst->box_escape_func;
        our_rules.escape.safe_for = (fr_value_box_safe_for_t)inst->driver;
        our_rules.escape.mode = TMPL_ESCAPE_PRE_CONCAT;
        our_rules.literals_safe_for = our_rules.escape.safe_for;
 
        count = cf_pair_count(subcs, "query");
 
        while ((to_parse = cf_pair_find_next(subcs, to_parse, "query"))) {
                MEM(parsed_env = call_env_parsed_add(ctx, out,
                                                     &(call_env_parser_t){ FR_CALL_ENV_PARSE_ONLY_OFFSET("query", FR_TYPE_STRING, CALL_ENV_FLAG_CONCAT | CALL_ENV_FLAG_MULTI, sql_redundant_call_env_t, query)}));
 
                slen = tmpl_afrom_substr(parsed_env, &parsed_tmpl,
                                      &FR_SBUFF_IN(cf_pair_value(to_parse), talloc_array_length(cf_pair_value(to_parse)) - 1),
                                      cf_pair_value_quote(to_parse), NULL, &our_rules);
                if (slen <= 0) {
                        cf_canonicalize_error(to_parse, slen, "Failed parsing query", cf_pair_value(to_parse));
                error:
                        call_env_parsed_free(out, parsed_env);
                        return -1;
                }
                if (tmpl_needs_resolving(parsed_tmpl) &&
                    (tmpl_resolve(parsed_tmpl, &(tmpl_res_rules_t){ .dict_def = our_rules.attr.dict_def }) < 0)) {
                        cf_log_perr(to_parse, "Failed resolving query");
                        goto error;
                }
 
                call_env_parsed_set_multi_index(parsed_env, count, multi_index++);
                call_env_parsed_set_data(parsed_env, parsed_tmpl);
        }
 
        return 0;
}
 
static int mod_detach(module_detach_ctx_t const *mctx)
{
        rlm_sql_t       *inst = talloc_get_type_abort(mctx->inst->data, rlm_sql_t);
 
        if (inst->pool) fr_pool_free(inst->pool);
 
        /*
         *      We need to explicitly free all children, so if the driver
         *      parented any memory off the instance, their destructors
         *      run before we unload the bytecode for them.
         *
         *      If we don't do this, we get a SEGV deep inside the talloc code
         *      when it tries to call a destructor that no longer exists.
         */
        talloc_free_children(inst);
 
        return 0;
}
 
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;
        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->driver = (rlm_sql_driver_t const *)inst->driver_submodule->module; /* Public symbol exported by the submodule */
 
        /*
         *      Register the group comparison attribute
         */
        if (cf_pair_find(conf, "group_membership_query")) {
                char const *group_attribute;
                fr_dict_attr_flags_t flags = {};
                char buffer[256];
 
                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);
                        group_attribute = buffer;
                } else {
                        group_attribute = "SQL-Group";
                }
 
                if (fr_dict_attr_add(fr_dict_unconst(dict_freeradius), fr_dict_root(dict_freeradius), group_attribute, -1,
                                     FR_TYPE_STRING, &flags) < 0) {
                        cf_log_perr(conf, "Failed defining group attribute");
                        return -1;
                }
 
                inst->group_da = fr_dict_attr_search_by_qualified_oid(NULL, dict_freeradius, group_attribute,
                                                                     false, false);
                if (!inst->group_da) {
                        cf_log_perr(conf, "Failed resolving group attribute");
                        return -1;
                }
 
                /*
                 *      Define the new %sql.group(name) xlat.  The
                 *      register function automatically adds the
                 *      module instance name as a prefix.
                 */
                xlat = xlat_func_register_module(inst, mctx, "group", sql_group_xlat, FR_TYPE_BOOL);
                if (!xlat) {
                        cf_log_perr(conf, "Failed registering %s expansion", group_attribute);
                        return -1;
                }
                xlat_func_call_env_set(xlat, &group_xlat_method_env);
 
                /*
                 *      The xlat escape function needs access to inst - so
                 *      argument parser details need to be defined here
                 */
                sql_xlat_arg = talloc_zero_array(inst, xlat_arg_parser_t, 2);
                sql_xlat_arg[0].type = FR_TYPE_STRING;
                sql_xlat_arg[0].required = true;
                sql_xlat_arg[0].concat = true;
                sql_xlat_arg[0].func = NULL; /* No real escaping done - we do strcmp() on it */
                sql_xlat_arg[0].uctx = NULL;
                sql_xlat_arg[1] = (xlat_arg_parser_t)XLAT_ARG_PARSER_TERMINATOR;
 
                xlat_func_mono_set(xlat, sql_xlat_arg);
        }
 
        /*
         *      Register the SQL xlat function
         */
        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);
                return -1;
        }
        xlat_func_call_env_set(xlat, &xlat_method_env);
 
        /*
         *      The xlat escape function needs access to inst - so
         *      argument parser details need to be defined here
         */
        sql_xlat_arg = talloc_zero_array(inst, xlat_arg_parser_t, 2);
        uctx = talloc_zero(sql_xlat_arg, rlm_sql_escape_uctx_t);
        *uctx = (rlm_sql_escape_uctx_t){ .sql = inst, .handle = NULL };
        sql_xlat_arg[0].type = FR_TYPE_STRING;
        sql_xlat_arg[0].required = true;
        sql_xlat_arg[0].concat = true;
        sql_xlat_arg[0].func = sql_xlat_escape;
        sql_xlat_arg[0].safe_for = (fr_value_box_safe_for_t)inst->driver;
        sql_xlat_arg[0].uctx = uctx;
        sql_xlat_arg[1] = (xlat_arg_parser_t)XLAT_ARG_PARSER_TERMINATOR;
 
        xlat_func_mono_set(xlat, sql_xlat_arg);
 
        /*
         *      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);
 
        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;
 
        /*
         *      We need authorize_group_check_query or authorize_group_reply_query
         *      if group_membership_query is set.
         *
         *      Or we need group_membership_query if authorize_group_check_query or
         *      authorize_group_reply_query is set.
         */
        if (!cf_pair_find(conf, "group_membership_query")) {
                if (cf_pair_find(conf, "authorize_group_check_query")) {
                        WARN("Ignoring authorize_group_check_query as group_membership_query is not configured");
                }
 
                if (cf_pair_find(conf, "authorize_group_reply_query")) {
                        WARN("Ignoring authorize_group_reply_query as group_membership_query is not configured");
                }
 
                if (!inst->config.read_groups) {
                        WARN("Ignoring read_groups as group_membership_query is not configured");
                        inst->config.read_groups = false;
                }
        } /* allow the group check / reply queries to be NULL */
 
        /*
         *      Cache the SQL-User-Name fr_dict_attr_t, so we can be slightly
         *      more efficient about creating SQL-User-Name attributes.
         */
        inst->sql_user = attr_sql_user_name;
 
        /*
         *      Export these methods, too.  This avoids RTDL_GLOBAL.
         */
        inst->query                     = rlm_sql_query;
        inst->select                    = rlm_sql_select_query;
        inst->fetch_row                 = rlm_sql_fetch_row;
 
        /*
         *      Either use the module specific escape function
         *      or our default one.
         */
        inst->sql_escape_func = inst->driver->sql_escape_func ?
                                inst->driver->sql_escape_func :
                                sql_escape_func;
        inst->box_escape_func = sql_box_escape;
 
        inst->ef = module_rlm_exfile_init(inst, conf, 256, fr_time_delta_from_sec(30), true, NULL, NULL);
        if (!inst->ef) {
                cf_log_err(conf, "Failed creating log file context");
                return -1;
        }
 
        /*
         *      Initialise the connection pool for this instance
         */
        INFO("Attempting to connect to database \"%s\"", inst->config.sql_db);
 
        inst->pool = module_rlm_connection_pool_init(conf, inst, sql_mod_conn_create, NULL, NULL, NULL, NULL);
        if (!inst->pool) return -1;
 
        return 0;
}
 
/* globally exported name */
module_rlm_t rlm_sql = {
        .common = {
                .magic          = MODULE_MAGIC_INIT,
                .name           = "sql",
                .flags          = MODULE_TYPE_THREAD_SAFE,
                .inst_size      = sizeof(rlm_sql_t),
                .config         = module_config,
                .bootstrap      = mod_bootstrap,
                .instantiate    = mod_instantiate,
                .detach         = mod_detach
        },
        .method_names = (module_method_name_t[]){
                /*
                 *      Hack to support old configurations
                 */
                { .name1 = "authorize",         .name2 = CF_IDENT_ANY,          .method = mod_authorize,
                  .method_env = &authorize_method_env   },
 
                { .name1 = "recv",              .name2 = CF_IDENT_ANY,          .method = mod_authorize,
                  .method_env = &authorize_method_env   },
                { .name1 = "accounting",        .name2 = CF_IDENT_ANY,          .method = mod_sql_redundant,
                  .method_env = &accounting_method_env  },
                { .name1 = "send",              .name2 = CF_IDENT_ANY,          .method = mod_sql_redundant,
                  .method_env = &send_method_env        },
                MODULE_NAME_TERMINATOR
        }
};