return 0;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config, fr_time_delta_t timeout)
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, fr_time_delta_t timeout)
{
rlm_sql_cassandra_conn_t *conn;
rlm_sql_cassandra_t *inst = config->driver;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
rlm_sql_cassandra_t *conf = config->driver;
return RLM_SQL_OK;
}
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
return conn->result ? cass_result_column_count(conn->result) : 0;
}
-static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
return conn->result ? cass_result_row_count(conn->result) : 0;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
}
static size_t sql_error(UNUSED TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_cassandra_conn_t *conn = handle->conn;
* There's a good article on it here:
* http://planetcassandra.org/blog/how-to-do-an-upsert-in-cassandra/
*/
-static int sql_affected_rows(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return 1;
}
return RLM_SQL_OK;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
SQLRETURN row;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
SQLRETURN row;
rlm_sql_db2_conn_t *conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
return sql_query(handle, config, query);
}
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
SQLSMALLINT c;
rlm_sql_db2_conn_t *conn;
return c;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_db2_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
int c, i;
SQLINTEGER len, slen;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_db2_conn_t *conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
char state[6];
char errbuff[1024];
return 1;
}
-static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return RLM_SQL_OK;
}
-static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
return sql_finish_query(handle, config);
}
-static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
SQLINTEGER c;
rlm_sql_db2_conn_t *conn = handle->conn;
/* Forward declarations */
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
static int _sql_socket_destructor(rlm_sql_firebird_conn_t *conn)
{
/** Establish connection to the db
*
*/
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
rlm_sql_firebird_conn_t *conn;
/** Issue a non-SELECT query (ie: update/delete/insert) to the database.
*
*/
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
rlm_sql_firebird_conn_t *conn = handle->conn;
/** Issue a select query to the database.
*
*/
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
return sql_query(handle, config, query);
}
/** Returns number of columns from query.
*
*/
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return ((rlm_sql_firebird_conn_t *) handle->conn)->sqlda_out->sqld;
}
/** Returns number of rows in query.
*
*/
-static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
return sql_affected_rows(handle, config);
}
/** Returns name of fields.
*
*/
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_firebird_conn_t *conn = handle->conn;
/** Returns an individual row.
*
*/
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_firebird_conn_t *conn = handle->conn;
int res;
/** End the select query, such as freeing memory or result.
*
*/
-static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_firebird_conn_t *conn = (rlm_sql_firebird_conn_t *) handle->conn;
/** End the query
*
*/
-static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
/** Frees memory allocated for a result set.
*
*/
-static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(UNUSED TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_firebird_conn_t *conn = handle->conn;
/** Return the number of rows affected by the query (update, or insert)
*
*/
-static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return fb_affected_rows(handle->conn);
}
* the database.
*
*************************************************************************/
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
CS_INT num = 0;
* Purpose: Return name of regular result columns.
*
*************************************************************************/
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
CS_DATAFMT datafmt;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(UNUSED TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
return 1;
}
-static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
* consecutive rows will be discarded.
*
*/
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
int num;
return num;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
CS_INT ret, count;
}
}
-static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
/*
}
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_freetds_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
return sql_num_rows(handle, config);
}
return RLM_SQL_OK;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config, fr_time_delta_t timeout)
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, fr_time_delta_t timeout)
{
rlm_sql_freetds_conn_t *conn;
unsigned int timeout_ms = fr_time_delta_to_msec(timeout);
return 0;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config, fr_time_delta_t timeout)
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, fr_time_delta_t timeout)
{
rlm_sql_mysql_conn_t *conn;
rlm_sql_mysql_t *inst = config->driver;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
sql_rcode_t rcode;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_store_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_store_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
sql_rcode_t rcode;
return RLM_SQL_OK;
}
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
int num = 0;
rlm_sql_mysql_conn_t *conn = handle->conn;
return num;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
sql_rcode_t rcode;
return rcode;
}
-static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
sql_rcode_t rcode;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
* - -1 on failure.
*/
static size_t sql_warnings(TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen,
- rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
rlm_sql_mysql_t *inst = config->driver;
* whether more results exist and process them in turn if so.
*
*/
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
#if (MYSQL_VERSION_ID >= 40100)
rlm_sql_mysql_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_mysql_conn_t *conn = handle->conn;
#include "rlm_sql.h"
-/* Prototypes */
-static sql_rcode_t sql_free_result(rlm_sql_handle_t*, rlm_sql_config_t*);
-
static const void *fake = "fake";
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config,
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
memcpy(&handle->conn, &fake, sizeof(handle->conn));
}
static sql_rcode_t sql_query(UNUSED rlm_sql_handle_t * handle,
- UNUSED rlm_sql_config_t *config, UNUSED char const *query)
+ UNUSED rlm_sql_config_t const *config, UNUSED char const *query)
{
return 0;
}
-static int sql_num_fields(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
static sql_rcode_t sql_select_query(UNUSED rlm_sql_handle_t *handle,
- UNUSED rlm_sql_config_t *config, UNUSED char const *query)
+ UNUSED rlm_sql_config_t const *config, UNUSED char const *query)
{
return 0;
}
-static int sql_num_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, UNUSED rlm_sql_handle_t *handle,
- UNUSED rlm_sql_config_t *config)
+ UNUSED rlm_sql_config_t const *config)
{
*out = NULL;
return RLM_SQL_NO_MORE_ROWS;
}
-static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
*
*/
static size_t sql_error(UNUSED TALLOC_CTX *ctx, UNUSED sql_log_entry_t out[], UNUSED size_t outlen,
- UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
-static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
-static sql_rcode_t sql_finish_select_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 0;
}
-static int sql_affected_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
return 1;
}
* - 0 on success.
* - -1 if there was no error.
*/
-static int sql_snprint_error(char *out, size_t outlen, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_snprint_error(char *out, size_t outlen, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
sb4 errcode = 0;
rlm_sql_oracle_conn_t *conn = handle->conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
char errbuff[512];
int ret;
return 0;
}
-static int sql_check_reconnect(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_check_reconnect(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
char errbuff[512];
return 0;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
char errbuff[512];
return RLM_SQL_OK;
}
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
int count;
rlm_sql_oracle_conn_t *conn = handle->conn;
return count;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_oracle_conn_t *conn = handle->conn;
int fields, i, status;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
int status;
rlm_sql_oracle_conn_t *conn = handle->conn;
return RLM_SQL_ERROR;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
int status;
char **row;
return RLM_SQL_ERROR;
}
-static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_oracle_conn_t *conn = handle->conn;
ub4 rows = 0;
return rows;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
int status;
rlm_sql_oracle_conn_t *conn = handle->conn;
return RLM_SQL_ERROR;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_oracle_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_oracle_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_oracle_conn_t *conn = handle->conn;
return 0;
}
-static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
return sql_num_rows(handle, config);
}
return 0;
}
-static int CC_HINT(nonnull) sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static int CC_HINT(nonnull) sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
rlm_sql_postgres_t *inst = config->driver;
return 0;
}
-static CC_HINT(nonnull) sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static CC_HINT(nonnull) sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
char const *query)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
return sql_classify_error(inst, status, conn->result);;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t const *config, char const *query)
{
return sql_query(handle, config, query);
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
int records, i, len;
return RLM_SQL_NO_MORE_ROWS;
}
-static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
char const *p, *q;
return i;
}
-static int sql_affected_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_postgres_conn_t *conn = handle->conn;
sqlite3_result_int64(ctx, max);
}
-static int CC_HINT(nonnull) sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static int CC_HINT(nonnull) sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
UNUSED fr_time_delta_t timeout)
{
rlm_sql_sqlite_conn_t *conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
char const *z_tail;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config, char const *query)
{
sql_rcode_t rcode;
return sql_check_error(conn->db, status);
}
-static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
int status;
rlm_sql_sqlite_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(UNUSED TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
char const *error;
return 1;
}
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
return sql_free_result(handle, config);
}
static int sql_affected_rows(rlm_sql_handle_t *handle,
- UNUSED rlm_sql_config_t *config)
+ UNUSED rlm_sql_config_t const *config)
{
rlm_sql_sqlite_conn_t *conn = handle->conn;
#include <sqlext.h>
/* Forward declarations */
-static int sql_check_error(long err_handle, rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
-static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+static int sql_check_error(long err_handle, rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
static int _sql_socket_destructor(rlm_sql_unixodbc_conn_t *conn)
{
return 0;
}
-static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
fr_time_delta_t timeout)
{
rlm_sql_unixodbc_conn_t *conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
long err_handle;
return 0;
}
-static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query)
+static sql_rcode_t sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
SQLINTEGER i;
return RLM_SQL_OK;
}
-static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
long err_handle;
return num_fields;
}
-static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_fetch_row(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
long err_handle;
return RLM_SQL_OK;
}
-static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
return 0;
}
-static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
* @return number of errors written to the #sql_log_entry_t array.
*/
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
- rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+ rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
SQLCHAR state[256];
* - #RLM_SQL_RECONNECT if reconnect is needed.
* - #RLM_SQL_ERROR on error.
*/
-static sql_rcode_t sql_check_error(long error_handle, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
+static sql_rcode_t sql_check_error(long error_handle, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
{
SQLCHAR state[256];
SQLCHAR error[256];
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
{
rlm_sql_unixodbc_conn_t *conn = handle->conn;
long error_handle;
goto finish;
}
- numaffected = (inst->driver->sql_affected_rows)(handle, inst->config);
+ 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);
+ (inst->driver->sql_finish_query)(handle, &inst->config);
goto finish;
}
fr_value_box_uint32(vb, NULL, (uint32_t)numaffected, false);
fr_dcursor_append(out, vb);
- (inst->driver->sql_finish_query)(handle, inst->config);
+ (inst->driver->sql_finish_query)(handle, &inst->config);
goto finish;
} /* else it's a SELECT statement */
goto finish_query;
default:
- (inst->driver->sql_finish_select_query)(handle, inst->config);
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
goto query_error;
}
} while (1);
finish_query:
- (inst->driver->sql_finish_select_query)(handle, inst->config);
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
finish:
fr_pool_connection_release(inst->pool, request, handle);
* Not every driver provides an sql_num_rows function
*/
if (inst->driver->sql_num_rows) {
- ret = inst->driver->sql_num_rows(handle, inst->config);
+ 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);
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
goto finish;
}
RERROR("Failed retrieving row count");
error:
rcode = RLM_MODULE_FAIL;
- (inst->driver->sql_finish_select_query)(handle, inst->config);
+ (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);
+ 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;
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);
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
goto finish;
}
rcode = RLM_MODULE_NOOP;
}
- (inst->driver->sql_finish_select_query)(handle, inst->config);
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
finish:
talloc_free(fields);
* mime-encoded equivalents.
*/
if ((in[0] < 32) ||
- strchr(inst->config->allowed_chars, *in) == NULL) {
+ strchr(inst->config.allowed_chars, *in) == NULL) {
/*
* Only 3 or less bytes available.
*/
if (username != NULL) {
sqluser = username;
- } else if (inst->config->query_user[0] != '\0') {
- sqluser = inst->config->query_user;
+ } else if (inst->config.query_user[0] != '\0') {
+ sqluser = inst->config.query_user;
} else {
return 0;
}
entry = *phead = NULL;
- if (!inst->config->groupmemb_query || !*inst->config->groupmemb_query) return 0;
- if (xlat_aeval(request, &expanded, request, inst->config->groupmemb_query,
+ if (!inst->config.groupmemb_query || !*inst->config.groupmemb_query) return 0;
+ if (xlat_aeval(request, &expanded, request, inst->config.groupmemb_query,
inst->sql_escape_func, *handle) < 0) return -1;
ret = rlm_sql_select_query(inst, request, handle, expanded);
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);
+ (inst->driver->sql_finish_select_query)(*handle, &inst->config);
talloc_free(entry);
return -1;
}
num_groups++;
}
- (inst->driver->sql_finish_select_query)(*handle, inst->config);
+ (inst->driver->sql_finish_select_query)(*handle, &inst->config);
return num_groups;
}
/*
* No group queries, don't do group comparisons.
*/
- if (!inst->config->groupmemb_query) {
+ if (!inst->config.groupmemb_query) {
RWARN("Cannot do group comparison when group_membership_query is not set");
return 1;
}
fr_pair_list_init(&check_tmp);
fr_pair_list_init(&reply_tmp);
- if (!inst->config->groupmemb_query) {
+ if (!inst->config.groupmemb_query) {
RWARN("Cannot do check groups when group_membership_query is not set");
do_nothing:
fr_assert(entry != NULL);
fr_pair_value_strdup(sql_group, entry->name, true);
- if (inst->config->authorize_group_check_query) {
+ if (inst->config.authorize_group_check_query) {
fr_pair_t *vp;
/*
* Expand the group query
*/
- if (xlat_aeval(request, &expanded, request, inst->config->authorize_group_check_query,
+ if (xlat_aeval(request, &expanded, request, inst->config.authorize_group_check_query,
inst->sql_escape_func, *handle) < 0) {
REDEBUG("Error generating query");
rcode = RLM_MODULE_FAIL;
fr_pair_list_free(&check_tmp);
}
- if (inst->config->authorize_group_reply_query) {
+ if (inst->config.authorize_group_reply_query) {
/*
* Now get the reply pairs since the paircmp matched
*/
- if (xlat_aeval(request, &expanded, request, inst->config->authorize_group_reply_query,
+ if (xlat_aeval(request, &expanded, request, inst->config.authorize_group_reply_query,
inst->sql_escape_func, *handle) < 0) {
REDEBUG("Error generating query");
rcode = RLM_MODULE_FAIL;
xlat_t *xlat;
xlat_arg_parser_t *sql_xlat_arg;
- /*
- * Hack...
- */
- inst->config = &inst->myconfig;
inst->cs = conf;
inst->name = cf_section_name2(conf);
/*
* Accomodate full and partial driver names
*/
- name = strrchr(inst->config->sql_driver_name, '_');
+ name = strrchr(inst->config.sql_driver_name, '_');
if (!name) {
- name = inst->config->sql_driver_name;
+ name = inst->config.sql_driver_name;
} else {
name++;
}
/*
* Call the driver's instantiate function (if set)
*/
- if (inst->driver->instantiate && (inst->driver->instantiate(inst->config,
+ if (inst->driver->instantiate && (inst->driver->instantiate(&inst->config,
inst->driver_inst->data,
driver_cs)) < 0) {
error:
* @fixme Inst should be passed to all driver callbacks
* instead of being stored here.
*/
- inst->config->driver = inst->driver_inst->data;
+ inst->config.driver = inst->driver_inst->data;
/*
* Register the group comparison attribute
*/
- if (inst->config->groupmemb_query) {
+ if (inst->config.groupmemb_query) {
char buffer[256];
char const *group_attribute;
- if (inst->config->group_attribute) {
- group_attribute = inst->config->group_attribute;
+ if (inst->config.group_attribute) {
+ group_attribute = inst->config.group_attribute;
} else if (cf_section_name2(conf)) {
snprintf(buffer, sizeof(buffer), "%s-SQL-Group", inst->name);
group_attribute = buffer;
/*
* Sanity check for crazy people.
*/
- if (strncmp(inst->config->sql_driver_name, "rlm_sql_", 8) != 0) {
- ERROR("\"%s\" is NOT an SQL driver!", inst->config->sql_driver_name);
+ if (strncmp(inst->config.sql_driver_name, "rlm_sql_", 8) != 0) {
+ ERROR("\"%s\" is NOT an SQL driver!", inst->config.sql_driver_name);
return -1;
}
* Or we need group_membership_query if authorize_group_check_query or
* authorize_group_reply_query is set.
*/
- if (!inst->config->groupmemb_query) {
- if (inst->config->authorize_group_check_query) {
+ if (!inst->config.groupmemb_query) {
+ if (inst->config.authorize_group_check_query) {
WARN("Ignoring authorize_group_reply_query as group_membership_query is not configured");
}
- if (inst->config->authorize_group_reply_query) {
+ if (inst->config.authorize_group_reply_query) {
WARN("Ignoring authorize_group_check_query as group_membership_query is not configured");
}
- if (!inst->config->read_groups) {
+ if (!inst->config.read_groups) {
WARN("Ignoring read_groups as group_membership_query is not configured");
- inst->config->read_groups = false;
+ inst->config.read_groups = false;
}
} /* allow the group check / reply queries to be NULL */
* configuration. So if that doesn't exist, we ignore
* the whole subsection.
*/
- inst->config->accounting.cs = cf_section_find(conf, "accounting", NULL);
- inst->config->accounting.reference_cp = (cf_pair_find(inst->config->accounting.cs, "reference") != NULL);
+ inst->config.accounting.cs = cf_section_find(conf, "accounting", NULL);
+ inst->config.accounting.reference_cp = (cf_pair_find(inst->config.accounting.cs, "reference") != NULL);
- inst->config->postauth.cs = cf_section_find(conf, "post-auth", NULL);
- inst->config->postauth.reference_cp = (cf_pair_find(inst->config->postauth.cs, "reference") != NULL);
+ inst->config.postauth.cs = cf_section_find(conf, "post-auth", NULL);
+ inst->config.postauth.reference_cp = (cf_pair_find(inst->config.postauth.cs, "reference") != NULL);
/*
* Cache the SQL-User-Name fr_dict_attr_t, so we can be slightly
/*
* Initialise the connection pool for this instance
*/
- INFO("Attempting to connect to database \"%s\"", inst->config->sql_db);
+ INFO("Attempting to connect to database \"%s\"", inst->config.sql_db);
inst->pool = module_connection_pool_init(inst->cs, inst, sql_mod_conn_create, NULL, NULL, NULL, NULL);
if (!inst->pool) return -1;
fr_assert(request->packet != NULL);
fr_assert(request->reply != NULL);
- if (!inst->config->authorize_check_query && !inst->config->authorize_reply_query &&
- !inst->config->read_groups && !inst->config->read_profiles) {
+ if (!inst->config.authorize_check_query && !inst->config.authorize_reply_query &&
+ !inst->config.read_groups && !inst->config.read_profiles) {
RWDEBUG("No authorization checks configured, returning noop");
RETURN_MODULE_NOOP;
/*
* Query the check table to find any conditions associated with this user/realm/whatever...
*/
- if (inst->config->authorize_check_query) {
+ if (inst->config.authorize_check_query) {
fr_pair_t *vp;
- if (xlat_aeval(request, &expanded, request, inst->config->authorize_check_query,
+ if (xlat_aeval(request, &expanded, request, inst->config.authorize_check_query,
inst->sql_escape_func, handle) < 0) {
REDEBUG("Failed generating query");
rcode = RLM_MODULE_FAIL;
fr_pair_list_free(&check_tmp);
}
- if (inst->config->authorize_reply_query) {
+ if (inst->config.authorize_reply_query) {
/*
* Now get the reply pairs since the paircmp matched
*/
- if (xlat_aeval(request, &expanded, request, inst->config->authorize_reply_query,
+ if (xlat_aeval(request, &expanded, request, inst->config.authorize_reply_query,
inst->sql_escape_func, handle) < 0) {
REDEBUG("Error generating query");
rcode = RLM_MODULE_FAIL;
* Neither group checks or profiles will work without
* a group membership query.
*/
- if (!inst->config->groupmemb_query) goto release;
+ if (!inst->config.groupmemb_query) goto release;
skip_reply:
if ((do_fall_through == FALL_THROUGH_YES) ||
- (inst->config->read_groups && (do_fall_through == FALL_THROUGH_DEFAULT))) {
+ (inst->config.read_groups && (do_fall_through == FALL_THROUGH_DEFAULT))) {
rlm_rcode_t ret;
RDEBUG3("... falling-through to group processing");
* Repeat the above process with the default profile or User-Profile
*/
if ((do_fall_through == FALL_THROUGH_YES) ||
- (inst->config->read_profiles && (do_fall_through == FALL_THROUGH_DEFAULT))) {
+ (inst->config.read_profiles && (do_fall_through == FALL_THROUGH_DEFAULT))) {
rlm_rcode_t ret;
char const *profile;
profile = user_profile ?
user_profile->vp_strvalue :
- inst->config->default_profile;
+ inst->config.default_profile;
if (!profile || !*profile) goto release;
* doesn't update any rows, the next matching config item is used.
*
*/
-static unlang_action_t acct_redundant(rlm_rcode_t *p_result, rlm_sql_t const *inst, request_t *request, sql_acct_section_t *section)
+static unlang_action_t acct_redundant(rlm_rcode_t *p_result, rlm_sql_t const *inst, request_t *request, sql_acct_section_t const *section)
{
rlm_rcode_t rcode = RLM_MODULE_OK;
* We need to have updated something for the query to have been
* counted as successful.
*/
- numaffected = (inst->driver->sql_affected_rows)(handle, inst->config);
- (inst->driver->sql_finish_query)(handle, inst->config);
+ numaffected = (inst->driver->sql_affected_rows)(handle, &inst->config);
+ (inst->driver->sql_finish_query)(handle, &inst->config);
RDEBUG2("%i record(s) updated", numaffected);
if (numaffected > 0) break; /* A query succeeded, were done! */
{
rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_sql_t);
- if (inst->config->accounting.reference_cp) {
- return acct_redundant(p_result, inst, request, &inst->config->accounting);
+ if (inst->config.accounting.reference_cp) {
+ return acct_redundant(p_result, inst, request, &inst->config.accounting);
}
RETURN_MODULE_NOOP;
{
rlm_sql_t const *inst = talloc_get_type_abort_const(mctx->instance, rlm_sql_t);
- if (inst->config->postauth.reference_cp) {
- return acct_redundant(p_result, inst, request, &inst->config->postauth);
+ if (inst->config.postauth.reference_cp) {
+ return acct_redundant(p_result, inst, request, &inst->config.postauth);
}
RETURN_MODULE_NOOP;
* >0 - Number of log entries
*/
typedef size_t (*sql_error_t)(TALLOC_CTX *ctx, sql_log_entry_t out[], size_t outlen, rlm_sql_handle_t *handle,
- rlm_sql_config_t *config);
+ rlm_sql_config_t const *config);
typedef struct {
DL_MODULE_COMMON; //!< Common fields to all loadable modules.
int flags;
sql_rcode_t (*instantiate)(rlm_sql_config_t const *config, void *instance, CONF_SECTION *cs);
- sql_rcode_t (*sql_socket_init)(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
+ sql_rcode_t (*sql_socket_init)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
fr_time_delta_t timeout);
- sql_rcode_t (*sql_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query);
- sql_rcode_t (*sql_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char const *query);
- sql_rcode_t (*sql_store_result)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ sql_rcode_t (*sql_query)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query);
+ sql_rcode_t (*sql_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config, char const *query);
+ sql_rcode_t (*sql_store_result)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
- int (*sql_num_fields)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
- int (*sql_num_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
- int (*sql_affected_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_num_fields)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+ int (*sql_num_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+ int (*sql_affected_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
- sql_rcode_t (*sql_fetch_row)(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t *config);
- sql_rcode_t (*sql_fields)(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t *config);
- sql_rcode_t (*sql_free_result)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ sql_rcode_t (*sql_fetch_row)(rlm_sql_row_t *out, rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+ sql_rcode_t (*sql_fields)(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+ sql_rcode_t (*sql_free_result)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
sql_error_t sql_error; //!< Get any errors from the previous query.
- sql_rcode_t (*sql_finish_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
- sql_rcode_t (*sql_finish_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ sql_rcode_t (*sql_finish_query)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+ sql_rcode_t (*sql_finish_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
xlat_escape_legacy_t sql_escape_func;
} rlm_sql_driver_t;
struct sql_inst {
- rlm_sql_config_t myconfig; /* HACK */
+ rlm_sql_config_t config; /* HACK */
fr_pool_t *pool;
- rlm_sql_config_t *config;
CONF_SECTION *cs;
fr_dict_attr_t const *sql_user; //!< Cached pointer to SQL-User-Name
void *sql_mod_conn_create(TALLOC_CTX *ctx, void *instance, fr_time_delta_t timeout);
int sql_getvpdata(TALLOC_CTX *ctx, rlm_sql_t const *inst, request_t *request, rlm_sql_handle_t **handle, fr_pair_list_t *out, char const *query);
-void rlm_sql_query_log(rlm_sql_t const *inst, request_t *request, sql_acct_section_t *section, char const *query) CC_HINT(nonnull (1, 2, 4));
+void rlm_sql_query_log(rlm_sql_t const *inst, request_t *request, sql_acct_section_t const *section, char const *query) CC_HINT(nonnull (1, 2, 4));
sql_rcode_t rlm_sql_select_query(rlm_sql_t const *inst, request_t *request, rlm_sql_handle_t **handle, char const *query) CC_HINT(nonnull (1, 3, 4));
sql_rcode_t rlm_sql_query(rlm_sql_t const *inst, request_t *request, rlm_sql_handle_t **handle, char const *query) CC_HINT(nonnull (1, 3, 4));
int rlm_sql_fetch_row(rlm_sql_row_t *out, rlm_sql_t const *inst, request_t *request, rlm_sql_handle_t **handle);
*/
handle->inst = inst;
- rcode = (inst->driver->sql_socket_init)(handle, inst->config, timeout);
+ rcode = (inst->driver->sql_socket_init)(handle, &inst->config, timeout);
if (rcode != 0) {
fail:
/*
return NULL;
}
- if (inst->config->connect_query) {
- if (rlm_sql_select_query(inst, NULL, &handle, inst->config->connect_query) != RLM_SQL_OK) goto fail;
- (inst->driver->sql_finish_select_query)(handle, inst->config);
+ if (inst->config.connect_query) {
+ if (rlm_sql_select_query(inst, NULL, &handle, inst->config.connect_query) != RLM_SQL_OK) goto fail;
+ (inst->driver->sql_finish_select_query)(handle, &inst->config);
}
return handle;
* may require the original connection to free up queries or
* result sets associated with that connection.
*/
- ret = (inst->driver->sql_fetch_row)(out, *handle, inst->config);
+ ret = (inst->driver->sql_fetch_row)(out, *handle, &inst->config);
switch (ret) {
case RLM_SQL_OK:
fr_assert(*out != NULL);
sql_log_entry_t log[20];
size_t num, i;
- num = (inst->driver->sql_error)(handle->log_ctx, log, (NUM_ELEMENTS(log)), handle, inst->config);
+ num = (inst->driver->sql_error)(handle->log_ctx, log, (NUM_ELEMENTS(log)), handle, &inst->config);
if (num == 0) {
ROPTIONAL(RERROR, ERROR, "Unknown error");
return;
}
- driver = inst->config->sql_driver_name;
+ driver = inst->config.sql_driver_name;
for (i = 0; i < num; i++) {
if (force_debug) goto debug;
/** Call the driver's sql_query method, reconnecting if necessary.
*
- * @note Caller must call ``(inst->driver->sql_finish_query)(handle, inst->config);``
+ * @note Caller must call ``(inst->driver->sql_finish_query)(handle, &inst->config);``
* after they're done with the result.
*
* @param handle to query the database with. *handle should not be NULL, as this indicates
for (i = 0; i < (count + 1); i++) {
ROPTIONAL(RDEBUG2, DEBUG2, "Executing query: %s", query);
- ret = (inst->driver->sql_query)(*handle, inst->config, query);
+ ret = (inst->driver->sql_query)(*handle, &inst->config, query);
switch (ret) {
case RLM_SQL_OK:
break;
*/
case RLM_SQL_QUERY_INVALID:
rlm_sql_print_error(inst, request, *handle, false);
- (inst->driver->sql_finish_query)(*handle, inst->config);
+ (inst->driver->sql_finish_query)(*handle, &inst->config);
break;
/*
case RLM_SQL_ERROR:
if (inst->driver->flags & RLM_SQL_RCODE_FLAGS_ALT_QUERY) {
rlm_sql_print_error(inst, request, *handle, false);
- (inst->driver->sql_finish_query)(*handle, inst->config);
+ (inst->driver->sql_finish_query)(*handle, &inst->config);
break;
}
ret = RLM_SQL_ALT_QUERY;
*/
case RLM_SQL_ALT_QUERY:
rlm_sql_print_error(inst, request, *handle, true);
- (inst->driver->sql_finish_query)(*handle, inst->config);
+ (inst->driver->sql_finish_query)(*handle, &inst->config);
break;
}
/** Call the driver's sql_select_query method, reconnecting if necessary.
*
- * @note Caller must call ``(inst->driver->sql_finish_select_query)(handle, inst->config);``
+ * @note Caller must call ``(inst->driver->sql_finish_select_query)(handle, &inst->config);``
* after they're done with the result.
*
* @param inst #rlm_sql_t instance data.
for (i = 0; i < (count + 1); i++) {
ROPTIONAL(RDEBUG2, DEBUG2, "Executing select query: %s", query);
- ret = (inst->driver->sql_select_query)(*handle, inst->config, query);
+ ret = (inst->driver->sql_select_query)(*handle, &inst->config, query);
switch (ret) {
case RLM_SQL_OK:
break;
case RLM_SQL_ERROR:
default:
rlm_sql_print_error(inst, request, *handle, false);
- (inst->driver->sql_finish_select_query)(*handle, inst->config);
+ (inst->driver->sql_finish_select_query)(*handle, &inst->config);
break;
}
if (sql_pair_afrom_row(ctx, request, out, row, &relative_vp) != 0) {
REDEBUG("Error parsing user data from database result");
- (inst->driver->sql_finish_select_query)(*handle, inst->config);
+ (inst->driver->sql_finish_select_query)(*handle, &inst->config);
return -1;
}
rows++;
}
- (inst->driver->sql_finish_select_query)(*handle, inst->config);
+ (inst->driver->sql_finish_select_query)(*handle, &inst->config);
return rows;
}
/*
* Log the query to a file.
*/
-void rlm_sql_query_log(rlm_sql_t const *inst, request_t *request, sql_acct_section_t *section, char const *query)
+void rlm_sql_query_log(rlm_sql_t const *inst, request_t *request, sql_acct_section_t const *section, char const *query)
{
int fd;
char const *filename = NULL;
size_t len;
bool failed = false; /* Write the log message outside of the critical region */
- filename = inst->config->logfile;
+ filename = inst->config.logfile;
if (section && section->logfile) filename = section->logfile;
if (!filename || !*filename) {
*/
if (!*handle) return -1;
- affected = (data->sql_inst->driver->sql_affected_rows)(*handle, data->sql_inst->config);
+ affected = (data->sql_inst->driver->sql_affected_rows)(*handle, &data->sql_inst->config);
- (data->sql_inst->driver->sql_finish_query)(*handle, data->sql_inst->config);
+ (data->sql_inst->driver->sql_finish_query)(*handle, &data->sql_inst->config);
return affected;
}
retval = rlen;
finish:
- (data->sql_inst->driver->sql_finish_select_query)(*handle, data->sql_inst->config);
+ (data->sql_inst->driver->sql_finish_select_query)(*handle, &data->sql_inst->config);
return retval;
}
projects / thirdparty / freeradius-server.git / commitdiff
