* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
SQLRETURN retval;
rlm_sql_db2_sock *sock;
/* allocate socket */
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_db2_sock*)rad_malloc(sizeof(rlm_sql_db2_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_db2_sock*)rad_malloc(sizeof(rlm_sql_db2_sock));
+ if (!handle->conn) {
return -1;
}
}
- sock = sqlsocket->conn;
+ sock = handle->conn;
memset(sock, 0, sizeof(*sock));
/* allocate handles */
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *querystr)
+static int sql_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config, char *querystr)
{
SQLRETURN retval;
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
/* allocate handle for statement */
SQLAllocHandle(SQL_HANDLE_STMT, sock->hdbc,
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *querystr)
+static int sql_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config, char *querystr)
{
- return sql_query(sqlsocket, config, querystr);
+ return sql_query(handle, config, querystr);
}
* set for the query.
*
*************************************************************************/
-static int sql_store_result(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_store_result(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_num_fields(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
SQLSMALLINT c;
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
SQLNumResultCols(sock->stmt, &c);
return c;
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_fetch_row(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
int c, i;
SQLINTEGER len, slen;
- SQL_ROW retval;
+ rlm_sql_row_t retval;
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
- c = sql_num_fields(sqlsocket, config);
- retval = (SQL_ROW)rad_malloc(c*sizeof(char*)+1);
+ c = sql_num_fields(handle, config);
+ retval = (rlm_sql_row_t)rad_malloc(c*sizeof(char*)+1);
/* advance cursor */
if(SQLFetch(sock->stmt) == SQL_NO_DATA_FOUND) {
- sqlsocket->row = NULL;
+ handle->row = NULL;
return 0;
}
retval[i][0] = '\0';
}
- sqlsocket->row = retval;
+ handle->row = retval;
return 0;
}
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_free_result(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
SQLFreeHandle(SQL_HANDLE_STMT, sock->stmt);
return 0;
}
* connection
*
*************************************************************************/
-static char *sql_error(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static char *sql_error(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
/* this should really be enough, if not, you still got the sqlstate */
#define MSGLEN 512
SQLSMALLINT rl;
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
SQLGetDiagRec(SQL_HANDLE_STMT, sock->stmt,
1, sqlstate, &err, msg, MSGLEN, &rl);
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_close(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
SQLFreeHandle(SQL_HANDLE_DBC, sock->hdbc);
SQLFreeHandle(SQL_HANDLE_ENV, sock->henv);
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_finish_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
- return sql_finish_query(sqlsocket, config);
+ return sql_finish_query(handle, config);
}
* Purpose: Return the number of rows affected by the last query.
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_affected_rows(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
SQLINTEGER c;
rlm_sql_db2_sock *sock;
- sock = sqlsocket->conn;
+ sock = handle->conn;
SQLRowCount(sock->stmt, &c);
return c;
static int
-not_implemented(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+not_implemented(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
radlog(L_ERR, "sql_db2: calling unimplemented function");
exit(1);
/* Forward declarations */
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config);
+static const char *sql_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+static int 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_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
/*************************************************************************
*
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
rlm_sql_firebird_sock *firebird_sock;
long res;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_firebird_sock *)rad_malloc(sizeof(rlm_sql_firebird_sock));
- if (!sqlsocket->conn) return -1;
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_firebird_sock *)rad_malloc(sizeof(rlm_sql_firebird_sock));
+ if (!handle->conn) return -1;
}
- firebird_sock = sqlsocket->conn;
+ firebird_sock = handle->conn;
res=fb_init_socket(firebird_sock);
if (res) return -1;
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
- rlm_sql_firebird_sock *firebird_sock = sqlsocket->conn;
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
+ rlm_sql_firebird_sock *firebird_sock = handle->conn;
int deadlock=0;
#ifdef _PTHREAD_H
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
-// rlm_sql_firebird_sock *firebird_sock = sqlsocket->conn;
- return (sql_query(sqlsocket, config, querystr));
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
+// rlm_sql_firebird_sock *firebird_sock = handle->conn;
+ return (sql_query(handle, config, querystr));
}
* set for the query.
*
*************************************************************************/
-static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_store_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
/* Not used */
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- return ((rlm_sql_firebird_sock *) sqlsocket->conn)->sqlda_out->sqld;
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ return ((rlm_sql_firebird_sock *) handle->conn)->sqlda_out->sqld;
}
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- int res=sql_affected_rows(sqlsocket, config);
+static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ int res=sql_affected_rows(handle, config);
return res;
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_firebird_sock *firebird_sock = sqlsocket->conn;
+static int sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_firebird_sock *firebird_sock = handle->conn;
int res;
- sqlsocket->row = NULL;
+ handle->row = NULL;
if (firebird_sock->statement_type!=isc_info_sql_stmt_exec_procedure) {
res=fb_fetch(firebird_sock);
if (res==100) return 0;
} else firebird_sock->statement_type=0;
fb_store_row(firebird_sock);
- sqlsocket->row = firebird_sock->row;
+ handle->row = firebird_sock->row;
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) {
- rlm_sql_firebird_sock *sock=(rlm_sql_firebird_sock *) sqlsocket->conn;
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config) {
+ rlm_sql_firebird_sock *sock=(rlm_sql_firebird_sock *) handle->conn;
fb_commit(sock);
fb_close_cursor(sock);
return 0;
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
-// sql_free_result(sqlsocket,config);
+static int sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+// sql_free_result(handle,config);
return 0;
}
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
return 0;
}
* connection and cleans up any open handles.
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- fb_destroy_socket((rlm_sql_firebird_sock *) sqlsocket->conn);
+static int sql_close(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ fb_destroy_socket((rlm_sql_firebird_sock *) handle->conn);
return 0;
}
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_firebird_sock *firebird_sock = sqlsocket->conn;
+static const char *sql_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_firebird_sock *firebird_sock = handle->conn;
return firebird_sock->lasterror;
}
/*************************************************************************
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- int affected_rows=fb_affected_rows(sqlsocket->conn);
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ int affected_rows=fb_affected_rows(handle->conn);
if (affected_rows<0)
- radlog(L_ERR, "sql_affected_rows, rlm_sql_firebird. error:%s\n", sql_error(sqlsocket,config));
+ radlog(L_ERR, "sql_affected_rows, rlm_sql_firebird. error:%s\n", sql_error(handle,config));
return affected_rows;
}
return 0;
}
-int fb_connect(rlm_sql_firebird_sock * sock,SQL_CONFIG *config) {
+int fb_connect(rlm_sql_firebird_sock * sock,rlm_sql_config_t *config) {
char *p;
char * database;
int dpb_len;
char *lasterror;
- SQL_ROW row;
+ rlm_sql_row_t row;
int *row_sizes;
int row_fcount;
int fb_free_result(rlm_sql_firebird_sock *sock);
int fb_lasterror(rlm_sql_firebird_sock *);
int fb_init_socket(rlm_sql_firebird_sock *sock);
-int fb_connect(rlm_sql_firebird_sock * sock,SQL_CONFIG *config);
+int fb_connect(rlm_sql_firebird_sock * sock,rlm_sql_config_t *config);
int fb_disconnect(rlm_sql_firebird_sock * sock);
int fb_sql_query(rlm_sql_firebird_sock * sock,char *sqlstr);
int fb_affected_rows(rlm_sql_firebird_sock * sock);
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
LOGINREC *login;
rlm_sql_freetds_sock *freetds_sock;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_freetds_sock *)rad_malloc(sizeof(struct rlm_sql_freetds_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_freetds_sock *)rad_malloc(sizeof(struct rlm_sql_freetds_sock));
+ if (!handle->conn) {
return -1;
}
}
dbsetlogintime((unsigned long)config->query_timeout);
dbsettime((unsigned long)config->query_timeout);
- freetds_sock = sqlsocket->conn;
+ freetds_sock = handle->conn;
memset(freetds_sock, 0, sizeof(*freetds_sock));
DEBUG("rlm_sql_freetds (%s): Starting connect to FreeTDS/MSSQL server", config->xlat_name);
* Purpose: Free socket and any private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr)
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr)
{
- rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
+ rlm_sql_freetds_sock *freetds_sock = handle->conn;
if (freetds_sock->dbproc == NULL || DBDEAD(freetds_sock->dbproc)) {
radlog(L_ERR, "rlm_sql_freetds (%s): Socket not connected", config->xlat_name);
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr)
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr)
{
radlog(L_ERR, "rlm_sql_freetds sql_select_query(): unsupported");
return -1;
* set for the query.
*
*************************************************************************/
-static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_store_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
radlog(L_ERR, "rlm_sql_freetds sql_store_result(): unsupported");
return -1;
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
+ rlm_sql_freetds_sock *freetds_sock = handle->conn;
return dbnumcols(freetds_sock->dbproc);
}
* query
*
*************************************************************************/
-static int sql_num_rows(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_rows(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
return 0;
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if database is down.
*
*************************************************************************/
-static int sql_fetch_row(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_fetch_row(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* for a result set
*
*************************************************************************/
-static int sql_free_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
return 0;
* connection
*
*************************************************************************/
-static const char *sql_error(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static const char *sql_error(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
return NULL;
}
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_close(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
+ rlm_sql_freetds_sock *freetds_sock = handle->conn;
if (freetds_sock && freetds_sock->dbproc){
dbclose(freetds_sock->dbproc);
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
return 0;
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- return sql_finish_query(sqlsocket, config);
+ return sql_finish_query(handle, config);
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
+ rlm_sql_freetds_sock *freetds_sock = handle->conn;
return dbcount(freetds_sock->dbproc);
}
HDBC dbc_handle;
HSTMT stmt_handle;
int id;
- SQL_ROW row;
+ rlm_sql_row_t row;
struct sql_socket *next;
void *conn;
} rlm_sql_iodbc_sock;;
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config);
+static const char *sql_error(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);
/*************************************************************************
*
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
rlm_sql_iodbc_sock *iodbc_sock;
SQLRETURN rcode;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_iodbc_sock *)rad_malloc(sizeof(rlm_sql_iodbc_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_iodbc_sock *)rad_malloc(sizeof(rlm_sql_iodbc_sock));
+ if (!handle->conn) {
return -1;
}
}
- iodbc_sock = sqlsocket->conn;
+ iodbc_sock = handle->conn;
memset(iodbc_sock, 0, sizeof(*iodbc_sock));
rcode = SQLAllocEnv(&iodbc_sock->env_handle);
if (!SQL_SUCCEEDED(rcode)) {
radlog(L_ERR, "sql_create_socket: SQLAllocEnv failed: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
&iodbc_sock->dbc_handle);
if (!SQL_SUCCEEDED(rcode)) {
radlog(L_ERR, "sql_create_socket: SQLAllocConnect failed: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
config->sql_password, SQL_NTS);
if (!SQL_SUCCEEDED(rcode)) {
radlog(L_ERR, "sql_create_socket: SQLConnectfailed: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* the database.
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
SQLRETURN rcode;
rcode = SQLAllocStmt(iodbc_sock->dbc_handle,
&iodbc_sock->stmt_handle);
if (!SQL_SUCCEEDED(rcode)) {
radlog(L_ERR, "sql_create_socket: SQLAllocStmt failed: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
rcode = SQLExecDirect(iodbc_sock->stmt_handle, querystr, SQL_NTS);
if (!SQL_SUCCEEDED(rcode)) {
radlog(L_ERR, "sql_query: failed: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
int numfields = 0;
int i=0;
char **row=NULL;
SQLINTEGER len=0;
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
- if(sql_query(sqlsocket, config, querystr) < 0) {
+ if(sql_query(handle, config, querystr) < 0) {
return -1;
}
- numfields = sql_num_fields(sqlsocket, config);
+ numfields = sql_num_fields(handle, config);
row = (char **) rad_malloc(sizeof(char *) * (numfields+1));
memset(row, 0, (sizeof(char *) * (numfields)));
* set for the query.
*
*************************************************************************/
-static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_store_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLSMALLINT count=0;
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
SQLNumResultCols(iodbc_sock->stmt_handle, &count);
* query
*
*************************************************************************/
-static int sql_num_rows(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_num_rows(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
/*
* I presume this function is used to determine the number of
* rows in a result set *before* fetching them. I don't think
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLRETURN rc;
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
- sqlsocket->row = NULL;
+ handle->row = NULL;
if((rc = SQLFetch(iodbc_sock->stmt_handle)) == SQL_NO_DATA_FOUND) {
return 0;
}
/* XXX Check rc for database down, if so, return SQL_DOWN */
- sqlsocket->row = iodbc_sock->row;
+ handle->row = iodbc_sock->row;
return 0;
}
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
int i=0;
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
- for(i=0; i<sql_num_fields(sqlsocket, config); i++) {
+ for(i=0; i<sql_num_fields(handle, config); i++) {
free(iodbc_sock->row[i]);
}
free(iodbc_sock->row);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static const char *sql_error(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLINTEGER errornum = 0;
SQLSMALLINT length = 0;
SQLCHAR state[256] = "";
static SQLCHAR error[256] = "";
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
SQLError(iodbc_sock->env_handle, iodbc_sock->dbc_handle, iodbc_sock->stmt_handle,
state, &errornum, error, 256, &length);
* connection and cleans up any open handles.
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_close(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
SQLFreeStmt(iodbc_sock->stmt_handle, SQL_DROP);
SQLDisconnect(iodbc_sock->dbc_handle);
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- return sql_free_result(sqlsocket, config);
+ return sql_free_result(handle, config);
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- return sql_free_result(sqlsocket, config);
+static int sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ return sql_free_result(handle, config);
}
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLINTEGER count;
- rlm_sql_iodbc_sock *iodbc_sock = sqlsocket->conn;
+ rlm_sql_iodbc_sock *iodbc_sock = handle->conn;
SQLRowCount(iodbc_sock->stmt_handle, &count);
return (int)count;
MYSQL conn;
MYSQL *sock;
MYSQL_RES *result;
- SQL_ROW row;
+ rlm_sql_row_t row;
} rlm_sql_mysql_sock;
/* Prototypes */
-static int sql_free_result(SQLSOCK*, SQL_CONFIG*);
+static int sql_free_result(rlm_sql_handle_t*, rlm_sql_config_t*);
/*************************************************************************
*
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
rlm_sql_mysql_sock *mysql_sock;
unsigned long sql_flags;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_mysql_sock *)rad_malloc(sizeof(rlm_sql_mysql_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_mysql_sock *)rad_malloc(sizeof(rlm_sql_mysql_sock));
+ if (!handle->conn) {
return -1;
}
}
- mysql_sock = sqlsocket->conn;
+ mysql_sock = handle->conn;
memset(mysql_sock, 0, sizeof(*mysql_sock));
DEBUG("rlm_sql_mysql: Starting connect to MySQL server");
* Purpose: Free socket and any private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config,
+static int sql_query(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config,
char *querystr)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
if (mysql_sock->sock == NULL) {
radlog(L_ERR, "rlm_sql_mysql: Socket not connected");
* first non-empty one.
*
*************************************************************************/
-static int sql_store_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_store_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
int status;
if (mysql_sock->sock == NULL) {
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
int num = 0;
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
#if MYSQL_VERSION_ID >= 32224
if (!(num = mysql_field_count(mysql_sock->sock))) {
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config,
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
char *querystr)
{
int ret;
- ret = sql_query(sqlsocket, config, querystr);
+ ret = sql_query(handle, config, querystr);
if(ret)
return ret;
- ret = sql_store_result(sqlsocket, config);
+ ret = sql_store_result(handle, config);
if (ret) {
return ret;
}
* this cannot return an error. Perhaps just to complain if no
* fields are found?
*/
- sql_num_fields(sqlsocket, config);
+ sql_num_fields(handle, config);
return ret;
}
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
if (mysql_sock->result)
return mysql_num_rows(mysql_sock->result);
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if database is down.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_fetch_row(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
int status;
/*
}
retry_fetch_row:
- sqlsocket->row = mysql_fetch_row(mysql_sock->result);
+ handle->row = mysql_fetch_row(mysql_sock->result);
- if (sqlsocket->row == NULL) {
+ if (handle->row == NULL) {
status = sql_check_error(mysql_errno(mysql_sock->sock));
if (status != 0) {
radlog(L_ERR, "rlm_sql_mysql: Cannot fetch row");
return status;
}
#if (MYSQL_VERSION_ID >= 40100)
- sql_free_result(sqlsocket, config);
+ sql_free_result(handle, config);
status = mysql_next_result(mysql_sock->sock);
if (status == 0) {
/* there are more results */
- if ((sql_store_result(sqlsocket, config) == 0)
+ if ((sql_store_result(handle, config) == 0)
&& (mysql_sock->result != NULL))
goto retry_fetch_row;
} else if (status > 0) {
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_free_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
if (mysql_sock->result) {
mysql_free_result(mysql_sock->result);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static const char *sql_error(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
if (mysql_sock == NULL || mysql_sock->sock == NULL) {
return "rlm_sql_mysql: no connection to db";
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_close(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
if (mysql_sock && mysql_sock->sock){
mysql_close(mysql_sock->sock);
* whether more results exist and process them in turn if so.
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_finish_query(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
#if (MYSQL_VERSION_ID >= 40100)
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
int status;
skip_next_result:
- status = sql_store_result(sqlsocket, config);
+ status = sql_store_result(handle, config);
if (status != 0) {
return status;
} else if (mysql_sock->result != NULL) {
radlog(L_DBG, "rlm_sql_mysql: SQL statement returned unexpected result");
- sql_free_result(sqlsocket, config);
+ sql_free_result(handle, config);
}
status = mysql_next_result(mysql_sock->sock);
if (status == 0) {
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
#if (MYSQL_VERSION_ID >= 40100)
int status;
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
#endif
- sql_free_result(sqlsocket, config);
+ sql_free_result(handle, config);
#if (MYSQL_VERSION_ID >= 40100)
status = mysql_next_result(mysql_sock->sock);
if (status == 0) {
/* there are more results */
- sql_finish_query(sqlsocket, config);
+ sql_finish_query(handle, config);
} else if (status > 0) {
radlog(L_ERR, "rlm_sql_mysql: Cannot get next result");
radlog(L_ERR, "rlm_sql_mysql: MySQL error '%s'",
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_affected_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
+ rlm_sql_mysql_sock *mysql_sock = handle->conn;
return mysql_affected_rows(mysql_sock->sock);
}
/* Prototypes */
-static int sql_free_result(SQLSOCK*, SQL_CONFIG*);
+static int sql_free_result(rlm_sql_handle_t*, rlm_sql_config_t*);
static const void *fake = "fake";
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_init_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- memcpy(&sqlsocket->conn, &fake, sizeof(sqlsocket->conn));
+ memcpy(&handle->conn, &fake, sizeof(handle->conn));
return 0;
}
* Purpose: Free socket and any private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- sqlsocket->conn = NULL;
+ handle->conn = NULL;
return 0;
}
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, UNUSED char *querystr)
+static int sql_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config, UNUSED char *querystr)
{
return 0;
}
* first non-empty one.
*
*************************************************************************/
-static int sql_store_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_store_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_fields(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config,
+static int sql_select_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config,
UNUSED char *querystr)
{
return 0;
* query
*
*************************************************************************/
-static int sql_num_rows(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if database is down.
*
*************************************************************************/
-static int sql_fetch_row(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_fetch_row(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* for a result set
*
*************************************************************************/
-static int sql_free_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_free_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* connection
*
*************************************************************************/
-static const char *sql_error(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static const char *sql_error(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return "Unknown error";
}
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_close(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- sqlsocket->conn = NULL;
+ handle->conn = NULL;
return 0;
}
* whether more results exist and process them in turn if so.
*
*************************************************************************/
-static int sql_finish_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_finish_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_finish_select_query(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_affected_rows(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_affected_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 1;
}
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static const char *sql_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
static char msgbuf[512];
sb4 errcode = 0;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (!oracle_sock) return "rlm_sql_oracle: no connection to db";
* Purpose: check the error to see if the server is down
*
*************************************************************************/
-static int sql_check_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_check_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- if (strstr(sql_error(sqlsocket, config), "ORA-03113") ||
- strstr(sql_error(sqlsocket, config), "ORA-03114")) {
+ if (strstr(sql_error(handle, config), "ORA-03113") ||
+ strstr(sql_error(handle, config), "ORA-03114")) {
radlog(L_ERR,"rlm_sql_oracle: OCI_SERVER_NOT_CONNECTED");
return SQL_DOWN;
}
* connection and cleans up any open handles.
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_close(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (oracle_sock->conn) {
OCILogoff (oracle_sock->conn, oracle_sock->errHandle);
oracle_sock->conn = NULL;
free(oracle_sock);
- sqlsocket->conn = NULL;
+ handle->conn = NULL;
return 0;
}
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
rlm_sql_oracle_sock *oracle_sock;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_oracle_sock *)rad_malloc(sizeof(rlm_sql_oracle_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_oracle_sock *)rad_malloc(sizeof(rlm_sql_oracle_sock));
+ if (!handle->conn) {
return -1;
}
}
- memset(sqlsocket->conn,0,sizeof(rlm_sql_oracle_sock));
+ memset(handle->conn,0,sizeof(rlm_sql_oracle_sock));
- oracle_sock = sqlsocket->conn;
+ oracle_sock = handle->conn;
if (OCIEnvCreate(&oracle_sock->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0,
(dvoid * (*)(dvoid *, size_t)) 0,
(ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0))
{
radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
config->sql_password, strlen(config->sql_password),
config->sql_db, strlen(config->sql_db)))
{
- radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(sqlsocket, config));
- sql_close(sqlsocket,config);
+ radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(handle, config));
+ sql_close(handle,config);
return -1;
}
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
ub4 count;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
/* get the number of columns in the select list */
if (OCIAttrGet ((dvoid *)oracle_sock->queryHandle,
(ub4)OCI_ATTR_PARAM_COUNT,
oracle_sock->errHandle)) {
radlog(L_ERR,"rlm_sql_oracle: Error retrieving column count in sql_num_fields: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
return count;
* the database.
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
int x;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (oracle_sock->conn == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
if (OCIStmtPrepare (oracle_sock->queryHandle, oracle_sock->errHandle,
querystr, strlen(querystr),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
- radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_query: %s",sql_error(sqlsocket, config));
+ radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_query: %s",sql_error(handle, config));
return -1;
}
if (x == OCI_ERROR) {
radlog(L_ERR,"rlm_sql_oracle: execute query failed in sql_query: %s",
- sql_error(sqlsocket, config));
- return sql_check_error(sqlsocket, config);
+ sql_error(handle, config));
+ return sql_check_error(handle, config);
}
else {
return -1;
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
int x;
int y;
ub2 dsize;
char **rowdata=NULL;
sb2 *indicators;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (oracle_sock->conn == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
if (OCIStmtPrepare (oracle_sock->queryHandle, oracle_sock->errHandle,
querystr, strlen(querystr),
OCI_NTV_SYNTAX, OCI_DEFAULT)) {
- radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_select_query: %s",sql_error(sqlsocket, config));
+ radlog(L_ERR,"rlm_sql_oracle: prepare failed in sql_select_query: %s",sql_error(handle, config));
return -1;
}
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: query failed in sql_select_query: %s",
- sql_error(sqlsocket, config));
- return sql_check_error(sqlsocket, config);
+ sql_error(handle, config));
+ return sql_check_error(handle, config);
}
/*
* all data to strings for ease of use. Fortunately, most
* of the data we deal with is already in string format.
*/
- colcount = sql_num_fields(sqlsocket, config);
+ colcount = sql_num_fields(handle, config);
/* DEBUG2("sql_select_query(): colcount=%d",colcount); */
(ub4) y);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIParamGet() failed in sql_select_query: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
oracle_sock->errHandle);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIAttrGet() failed in sql_select_query: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
oracle_sock->errHandle);
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIAttrGet() failed in sql_select_query: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
rowdata[y-1]=rad_malloc(dsize+1);
*/
if (x != OCI_SUCCESS) {
radlog(L_ERR,"rlm_sql_oracle: OCIDefineByPos() failed in sql_select_query: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
}
* set for the query.
*
*************************************************************************/
-static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_store_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
/* Not needed for Oracle */
return 0;
}
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
ub4 rows=0;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
OCIAttrGet((CONST dvoid *)oracle_sock->queryHandle,
OCI_HTYPE_STMT,
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if database is down.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
int x;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (oracle_sock->conn == NULL) {
radlog(L_ERR, "rlm_sql_oracle: Socket not connected");
return SQL_DOWN;
}
- sqlsocket->row = NULL;
+ handle->row = NULL;
x=OCIStmtFetch(oracle_sock->queryHandle,
oracle_sock->errHandle,
OCI_DEFAULT);
if (x == OCI_SUCCESS) {
- sqlsocket->row = oracle_sock->results;
+ handle->row = oracle_sock->results;
return 0;
}
if (x == OCI_ERROR) {
radlog(L_ERR,"rlm_sql_oracle: fetch failed in sql_fetch_row: %s",
- sql_error(sqlsocket, config));
- return sql_check_error(sqlsocket, config);
+ sql_error(handle, config));
+ return sql_check_error(handle, config);
}
else {
return -1;
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
int x;
int num_fields;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
/* Cancel the cursor first */
x=OCIStmtFetch(oracle_sock->queryHandle,
OCI_FETCH_NEXT,
OCI_DEFAULT);
- num_fields = sql_num_fields(sqlsocket, config);
+ num_fields = sql_num_fields(handle, config);
if (num_fields >= 0) {
for(x=0; x < num_fields; x++) {
free(oracle_sock->results[x]);
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
int x=0;
- rlm_sql_oracle_sock *oracle_sock = sqlsocket->conn;
+ rlm_sql_oracle_sock *oracle_sock = handle->conn;
if (oracle_sock->results) {
while(oracle_sock->results[x]) free(oracle_sock->results[x++]);
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- return sql_num_rows(sqlsocket, config);
+ return sql_num_rows(handle, config);
}
} rlm_sql_postgres_sock;
/* Prototypes */
-static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config);
+static int sql_close(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
/* Internal function. Return true if the postgresql status value
* indicates successful completion of the query. Return false otherwise
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
char connstring[2048];
const char *port, *host;
rlm_sql_postgres_sock *pg_sock;
port = "";
}
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_postgres_sock *)rad_malloc(sizeof(rlm_sql_postgres_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_postgres_sock *)rad_malloc(sizeof(rlm_sql_postgres_sock));
+ if (!handle->conn) {
return -1;
}
}
- pg_sock = sqlsocket->conn;
+ pg_sock = handle->conn;
memset(pg_sock, 0, sizeof(*pg_sock));
snprintf(connstring, sizeof(connstring),
if (PQstatus(pg_sock->conn) != CONNECTION_OK) {
radlog(L_ERR, "rlm_sql_postgresql: Couldn't connect socket to PostgreSQL server %s@%s:%s", config->sql_login, config->sql_server, config->sql_db);
/*radlog(L_ERR, "rlm_sql_postgresql: Postgresql error '%s'", PQerrorMessage(pg_sock->conn));*/
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
return SQL_DOWN;
}
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config,
+static int sql_query(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config,
char *querystr) {
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
int numfields = 0;
char *errorcode;
char *errormsg;
/*
Note to self ... sql_store_result returns 0 anyway
- after setting the sqlsocket->affected_rows..
+ after setting the handle->affected_rows..
sql_num_fields returns 0 at worst case which means the check below
has a really small chance to return false..
lets remove it then .. yuck!!
*/
/*
} else {
- if ((sql_store_result(sqlsocket, config) == 0)
- && (sql_num_fields(sqlsocket, config) >= 0))
+ if ((sql_store_result(handle, config) == 0)
+ && (sql_num_fields(handle, config) >= 0))
return 0;
else
return -1;
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *querystr) {
- return sql_query(sqlsocket, config, querystr);
+static int sql_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config, char *querystr) {
+ return sql_query(handle, config, querystr);
}
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_fetch_row(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config) {
int records, i, len;
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
- sqlsocket->row = NULL;
+ handle->row = NULL;
if (pg_sock->cur_row >= PQntuples(pg_sock->result))
return 0;
strlcpy(pg_sock->row[i], PQgetvalue(pg_sock->result, pg_sock->cur_row,i),len + 1);
}
pg_sock->cur_row++;
- sqlsocket->row = pg_sock->row;
+ handle->row = pg_sock->row;
}
return 0;
* query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
pg_sock->affected_rows = PQntuples(pg_sock->result);
if (pg_sock->result)
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_free_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config) {
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
if (pg_sock->result) {
PQclear(pg_sock->result);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) {
+static const char *sql_error(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config) {
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
return PQerrorMessage(pg_sock->conn);
}
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_close(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config) {
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
if (!pg_sock->conn) return 0;
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) {
+static int sql_finish_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config) {
- return sql_free_result(sqlsocket, config);
+ return sql_free_result(handle, config);
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) {
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config) {
- return sql_free_result(sqlsocket, config);
+ return sql_free_result(handle, config);
}
* Purpose: Return the number of rows affected by the last query.
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) {
- rlm_sql_postgres_sock *pg_sock = sqlsocket->conn;
+static int sql_affected_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config) {
+ rlm_sql_postgres_sock *pg_sock = handle->conn;
return pg_sock->affected_rows;
}
static int NEVER_RETURNS
-not_implemented(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+not_implemented(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
radlog(L_ERR, "sql_postgresql: calling unimplemented function");
exit(1);
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
int status;
rlm_sql_sqlite_sock *sqlite_sock;
char *filename;
char buffer[2048];
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_sqlite_sock *)rad_malloc(sizeof(rlm_sql_sqlite_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_sqlite_sock *)rad_malloc(sizeof(rlm_sql_sqlite_sock));
+ if (!handle->conn) {
return -1;
}
}
- sqlite_sock = sqlsocket->conn;
+ sqlite_sock = handle->conn;
memset(sqlite_sock, 0, sizeof(rlm_sql_sqlite_sock));
filename = config->sql_file;
* Purpose: Free socket and any private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
int status = 0;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock && sqlite_sock->pDb) {
status = sqlite3_close(sqlite_sock->pDb);
* Purpose: Issue a query to the database
*
*************************************************************************/
-static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config,
+static int sql_query(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config,
char *querystr)
{
int status;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
const char *zTail;
if (sqlite_sock->pDb == NULL) {
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config,
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config,
char *querystr)
{
- return sql_query(sqlsocket, config, querystr);
+ return sql_query(handle, config, querystr);
}
* set for the query.
*
*************************************************************************/
-static int sql_store_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_store_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pStmt)
return sqlite3_column_count(sqlite_sock->pStmt);
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_num_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pStmt)
return sqlite3_data_count(sqlite_sock->pStmt);
/*************************************************************************
* Function: sql_free_rowdata
*************************************************************************/
-static void sql_free_rowdata(SQLSOCK * sqlsocket, int colcount)
+static void sql_free_rowdata(rlm_sql_handle_t * handle, int colcount)
{
- char **rowdata = sqlsocket->row;
+ char **rowdata = handle->row;
int colindex;
if (rowdata != NULL) {
rowdata[colindex] = NULL;
}
}
- free(sqlsocket->row);
- sqlsocket->row = NULL;
+ free(handle->row);
+ handle->row = NULL;
}
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if database is down.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_fetch_row(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
int returnCode = -1;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
const char *blob;
int blobLen;
int status;
status = sqlite3_step(sqlite_sock->pStmt);
radlog(L_DBG, "rlm_sql_sqlite: sqlite3_step = %d\n", status);
if (status == SQLITE_DONE) {
- sql_free_rowdata(sqlsocket, sqlite_sock->columnCount);
+ sql_free_rowdata(handle, sqlite_sock->columnCount);
return 0;
}
else if (status == SQLITE_ROW) {
if (sqlite_sock->columnCount == 0) {
- sqlite_sock->columnCount = sql_num_fields(sqlsocket, config);
+ sqlite_sock->columnCount = sql_num_fields(handle, config);
}
colcount = sqlite_sock->columnCount;
if (colcount == 0)
return -1;
- sql_free_rowdata(sqlsocket, colcount);
+ sql_free_rowdata(handle, colcount);
ret_blob_size = sizeof(char *) * (colcount+1);
rowdata = (char **)rad_malloc(ret_blob_size); /* Space for pointers */
if (rowdata != NULL) {
memset(rowdata, 0, ret_blob_size); /* NULL-pad the pointers */
- sqlsocket->row = rowdata;
+ handle->row = rowdata;
}
for (colindex = 0; colindex < colcount; colindex++)
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_free_result(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
int status = 0;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pStmt != NULL) {
- sql_free_rowdata(sqlsocket, sqlite_sock->columnCount);
+ sql_free_rowdata(handle, sqlite_sock->columnCount);
status = sqlite3_finalize(sqlite_sock->pStmt);
sqlite_sock->pStmt = NULL;
radlog(L_DBG, "rlm_sql_sqlite: sqlite3_finalize() = %d\n", status);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static const char *sql_error(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pDb != NULL) {
return sqlite3_errmsg(sqlite_sock->pDb);
* connection
*
*************************************************************************/
-static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_close(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
int status = 0;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock && sqlite_sock->pDb) {
status = sqlite3_close(sqlite_sock->pDb);
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_finish_query(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
int status = 0;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pStmt) {
status = sqlite3_finalize(sqlite_sock->pStmt);
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config)
{
- return sql_finish_query(sqlsocket, config);
+ return sql_finish_query(handle, config);
}
* statement
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_affected_rows(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t *config)
{
int result = -1;
- rlm_sql_sqlite_sock *sqlite_sock = sqlsocket->conn;
+ rlm_sql_sqlite_sock *sqlite_sock = handle->conn;
if (sqlite_sock->pDb != NULL) {
result = sqlite3_changes(sqlite_sock->pDb);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static const char *sql_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
static char msg='\0';
/*
static char msgbuf[2048];
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
CS_INT msgcount;
CS_CLIENTMSG cmsg;
CS_SERVERMSG smsg;
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
rlm_sql_sybase_sock *sybase_sock;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_sybase_sock *)rad_malloc(sizeof(rlm_sql_sybase_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_sybase_sock *)rad_malloc(sizeof(rlm_sql_sybase_sock));
+ if (!handle->conn) {
return -1;
}
}
- sybase_sock = sqlsocket->conn;
+ sybase_sock = handle->conn;
memset(sybase_sock, 0, sizeof(*sybase_sock));
sybase_sock->results=NULL;
if (ct_con_props(sybase_sock->connection, CS_SET, CS_USERNAME, config->sql_login,
strlen(config->sql_login), NULL) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_init_socket): Unable to set username for connection (ct_con_props())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
if (sybase_sock->context != (CS_CONTEXT *)NULL) {
ct_exit(sybase_sock->context, CS_FORCE_EXIT);
cs_ctx_drop(sybase_sock->context);
if (ct_con_props(sybase_sock->connection, CS_SET, CS_PASSWORD, config->sql_password,
strlen(config->sql_password), NULL) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_init_socket): Unable to set password for connection (ct_con_props())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
if (sybase_sock->context != (CS_CONTEXT *)NULL) {
ct_exit(sybase_sock->context, CS_FORCE_EXIT);
cs_ctx_drop(sybase_sock->context);
if (ct_connect(sybase_sock->connection, config->sql_server, strlen(config->sql_server)) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_init_socket): Unable to establish connection to symbolic servername %s\n%s",
- config->sql_server, sql_error(sqlsocket, config));
+ config->sql_server, sql_error(handle, config));
if (sybase_sock->context != (CS_CONTEXT *)NULL) {
ct_exit(sybase_sock->context, CS_FORCE_EXIT);
cs_ctx_drop(sybase_sock->context);
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* connection and cleans up any open handles.
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_close(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
return 0;
}
* the database.
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
CS_RETCODE ret, results_ret;
CS_INT result_type;
if (ct_cmd_alloc(sybase_sock->connection, &sybase_sock->command) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unable to allocate command structure (ct_cmd_alloc())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
if (ct_command(sybase_sock->command, CS_LANG_CMD, querystr, CS_NULLTERM, CS_UNUSED) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unable to initiate command structure (ct_command())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
if (ct_send(sybase_sock->command) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unable to send command (ct_send())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
radlog(L_ERR,"rlm_sql_sybase(sql_query): sql_query processed a query returning rows. Use sql_select_query instead!");
}
radlog(L_ERR,"rlm_sql_sybase(sql_query): Result failure or unexpected result type from query\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
}
case CS_FAIL: /* Serious failure, sybase requires us to cancel and maybe even close connection */
radlog(L_ERR,"rlm_sql_sybase(sql_query): Failure retrieving query results\n%s"
- , sql_error(sqlsocket, config));
+ , sql_error(handle, config));
if ((ret = ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL)) == CS_FAIL) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): cleaning up.");
ct_close(sybase_sock->connection, CS_FORCE_CLOSE);
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
}
return -1;
break;
default:
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unexpected return value from ct_results()\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
}
if ((results_ret = ct_results(sybase_sock->command, &result_type)) == CS_SUCCEED) {
if (result_type != CS_CMD_DONE) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): Result failure or unexpected result type from query\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
}
case CS_FAIL: /* Serious failure, sybase requires us to cancel and maybe even close connection */
radlog(L_ERR,"rlm_sql_sybase(sql_query): Failure retrieving query results\n%s"
- , sql_error(sqlsocket, config));
+ , sql_error(handle, config));
if ((ret = ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL)) == CS_FAIL) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): cleaning up.");
ct_close(sybase_sock->connection, CS_FORCE_CLOSE);
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
}
return -1;
break;
default:
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unexpected return value from ct_results()\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
}
case CS_FAIL: /* Serious failure, sybase requires us to cancel and maybe even close connection */
radlog(L_ERR,"rlm_sql_sybase(sql_query): Failure retrieving query results\n%s"
- , sql_error(sqlsocket, config));
+ , sql_error(handle, config));
if ((ret = ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL)) == CS_FAIL) {
radlog(L_ERR,"rlm_sql_sybase(sql_query): cleaning up.");
ct_close(sybase_sock->connection, CS_FORCE_CLOSE);
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
}
return -1;
break;
default:
radlog(L_ERR,"rlm_sql_sybase(sql_query): Unexpected return value from ct_results()\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
break;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
int num;
if (ct_res_info(sybase_sock->command, CS_NUMDATA, (CS_INT *)&num, CS_UNUSED, NULL) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_num_fields): error retrieving column count: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
return num;
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
int i=0;
ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL);
* be discarded.
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
CS_RETCODE ret, results_ret;
CS_INT result_type;
if (ct_cmd_alloc(sybase_sock->connection, &sybase_sock->command) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Unable to allocate command structure (ct_cmd_alloc())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
if (ct_command(sybase_sock->command, CS_LANG_CMD, querystr, CS_NULLTERM, CS_UNUSED) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Unable to initiate command structure (ct_command())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
if (ct_send(sybase_sock->command) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Unable to send command (ct_send())\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
descriptor.locale = NULL; /* Don't do NLS stuff */
- colcount = sql_num_fields(sqlsocket, config); /* Get number of elements in row result */
+ colcount = sql_num_fields(handle, config); /* Get number of elements in row result */
rowdata=(char **)rad_malloc(sizeof(char *) * (colcount+1)); /* Space for pointers */
/* Associate the target buffer with the data */
if (ct_bind(sybase_sock->command, i+1, &descriptor, rowdata[i], NULL, NULL) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): ct_bind() failed)\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
default:
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Unexpected result type from query\n%s",
- sql_error(sqlsocket, config));
- sql_finish_select_query(sqlsocket, config);
+ sql_error(handle, config));
+ sql_finish_select_query(handle, config);
return -1;
break;
}
*/
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Failure retrieving query results\n%s"
- , sql_error(sqlsocket, config));
+ , sql_error(handle, config));
if ((ret = ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL)) == CS_FAIL) {
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): cleaning up.");
ct_close(sybase_sock->connection, CS_FORCE_CLOSE);
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
}
return -1;
break;
default:
radlog(L_ERR,"rlm_sql_sybase(sql_select_query): Unexpected return value from ct_results()\n%s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
break;
}
* set for the query.
*
*************************************************************************/
-static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_store_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
/*
** Not needed for Sybase, code that may have gone here is
** in sql_select_query and sql_fetch_row
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
int num;
if (ct_res_info(sybase_sock->command, CS_ROW_COUNT, (CS_INT *)&num, CS_UNUSED, NULL) != CS_SUCCEED) {
radlog(L_ERR,"rlm_sql_sybase(sql_num_rows): error retrieving row count: %s",
- sql_error(sqlsocket, config));
+ sql_error(handle, config));
return -1;
}
return num;
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'.
*
*************************************************************************/
-int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+int sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
CS_INT ret, count;
- sqlsocket->row = NULL;
+ handle->row = NULL;
ret = ct_fetch(sybase_sock->command, CS_UNUSED, CS_UNUSED, CS_UNUSED, &count);
*/
radlog(L_ERR,"rlm_sql_sybase(sql_fetch_row): Failure fething row data\n%s"
- , sql_error(sqlsocket, config));
+ , sql_error(handle, config));
if ((ret = ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL)) == CS_FAIL) {
radlog(L_ERR,"rlm_sql_sybase(sql_fetch_row): cleaning up.");
ct_close(sybase_sock->connection, CS_FORCE_CLOSE);
- sql_close(sqlsocket, config);
+ sql_close(handle, config);
}
return SQL_DOWN;
break;
case CS_SUCCEED:
- sqlsocket->row = sybase_sock->results;
+ handle->row = sybase_sock->results;
return 0;
break;
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
/*
** Not implemented, never called from rlm_sql anyway
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config)
+static int sql_finish_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
{
- rlm_sql_sybase_sock *sybase_sock = sqlsocket->conn;
+ rlm_sql_sybase_sock *sybase_sock = handle->conn;
ct_cancel(NULL, sybase_sock->command, CS_CANCEL_ALL);
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
- return sql_num_rows(sqlsocket, config);
+ return sql_num_rows(handle, config);
}
SQLHENV env_handle;
SQLHDBC dbc_handle;
SQLHSTMT stmt_handle;
- SQL_ROW row;
+ rlm_sql_row_t row;
void *conn;
} rlm_sql_unixodbc_sock;
#include <sqlext.h>
/* Forward declarations */
-static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_state(long err_handle, SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config);
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config);
+static const char *sql_error(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+static int sql_state(long err_handle, rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+static int 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);
/*************************************************************************
* Purpose: Establish connection to the db
*
*************************************************************************/
-static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
+static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
rlm_sql_unixodbc_sock *unixodbc_sock;
long err_handle;
- if (!sqlsocket->conn) {
- sqlsocket->conn = (rlm_sql_unixodbc_sock *)rad_malloc(sizeof(rlm_sql_unixodbc_sock));
- if (!sqlsocket->conn) {
+ if (!handle->conn) {
+ handle->conn = (rlm_sql_unixodbc_sock *)rad_malloc(sizeof(rlm_sql_unixodbc_sock));
+ if (!handle->conn) {
return -1;
}
}
- unixodbc_sock = sqlsocket->conn;
+ unixodbc_sock = handle->conn;
memset(unixodbc_sock, 0, sizeof(*unixodbc_sock));
/* 1. Allocate environment handle and register version */
err_handle = SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&unixodbc_sock->env_handle);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
{
radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate environment handle\n");
return -1;
}
err_handle = SQLSetEnvAttr(unixodbc_sock->env_handle, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
{
radlog(L_ERR, "rlm_sql_unixodbc: Can't register ODBC version\n");
SQLFreeHandle(SQL_HANDLE_ENV, unixodbc_sock->env_handle);
}
/* 2. Allocate connection handle */
err_handle = SQLAllocHandle(SQL_HANDLE_DBC, unixodbc_sock->env_handle, &unixodbc_sock->dbc_handle);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
{
radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate connection handle\n");
SQLFreeHandle(SQL_HANDLE_ENV, unixodbc_sock->env_handle);
(SQLCHAR*) config->sql_server, strlen(config->sql_server),
(SQLCHAR*) config->sql_login, strlen(config->sql_login),
(SQLCHAR*) config->sql_password, strlen(config->sql_password));
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
{
radlog(L_ERR, "rlm_sql_unixodbc: Connection failed\n");
SQLFreeHandle(SQL_HANDLE_DBC, unixodbc_sock->dbc_handle);
/* 4. Allocate the statement */
err_handle = SQLAllocStmt(unixodbc_sock->dbc_handle, &unixodbc_sock->stmt_handle);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
{
radlog(L_ERR, "rlm_sql_unixodbc: Can't allocate the statement\n");
return -1;
* Purpose: Free socket and private connection data
*
*************************************************************************/
-static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
+static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
{
- free(sqlsocket->conn);
- sqlsocket->conn = NULL;
+ free(handle->conn);
+ handle->conn = NULL;
return 0;
}
* the database.
*
*************************************************************************/
-static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
long err_handle;
int state;
/* Executing query */
err_handle = SQLExecDirect(unixodbc_sock->stmt_handle, (SQLCHAR *)querystr, strlen(querystr));
- if ((state = sql_state(err_handle, sqlsocket, config))) {
+ if ((state = sql_state(err_handle, handle, config))) {
if(state == SQL_DOWN)
DEBUG("rlm_sql_unixodbc: rlm_sql will attempt to reconnect\n");
return state;
* Purpose: Issue a select query to the database
*
*************************************************************************/
-static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
SQLINTEGER column;
SQLLEN len;
int numfields;
int state;
/* Only state = 0 means success */
- if((state = sql_query(sqlsocket, config, querystr)))
+ if((state = sql_query(handle, config, querystr)))
return state;
- numfields=sql_num_fields(sqlsocket, config);
+ numfields=sql_num_fields(handle, config);
if(numfields < 0)
return -1;
* set for the query.
*
*************************************************************************/
-static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_store_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
/* Not used */
return 0;
}
* of columns from query
*
*************************************************************************/
-static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_num_fields(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
long err_handle;
SQLSMALLINT num_fields = 0;
err_handle = SQLNumResultCols(unixodbc_sock->stmt_handle,&num_fields);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
return -1;
return num_fields;
* query
*
*************************************************************************/
-static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- return sql_affected_rows(sqlsocket, config);
+static int sql_num_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ return sql_affected_rows(handle, config);
}
*
* Function: sql_fetch_row
*
- * Purpose: database specific fetch_row. Returns a SQL_ROW struct
- * with all the data for the query in 'sqlsocket->row'. Returns
+ * Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
+ * with all the data for the query in 'handle->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'.
*
*************************************************************************/
-static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
long err_handle;
int state;
- sqlsocket->row = NULL;
+ handle->row = NULL;
err_handle = SQLFetch(unixodbc_sock->stmt_handle);
if(err_handle == SQL_NO_DATA_FOUND)
return 0;
- if ((state = sql_state(err_handle, sqlsocket, config))) {
+ if ((state = sql_state(err_handle, handle, config))) {
if(state == SQL_DOWN)
DEBUG("rlm_sql_unixodbc: rlm_sql will attempt to reconnect");
return state;
}
- sqlsocket->row = unixodbc_sock->row;
+ handle->row = unixodbc_sock->row;
return 0;
}
* Purpose: End the select query, such as freeing memory or result
*
*************************************************************************/
-static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
- sql_free_result(sqlsocket, config);
+ sql_free_result(handle, config);
SQLFreeStmt(unixodbc_sock->stmt_handle, SQL_CLOSE);
return 0;
}
* Purpose: End the query, such as freeing memory
*
*************************************************************************/
-static int sql_finish_query(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_finish_query(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
SQLFreeStmt(unixodbc_sock->stmt_handle, SQL_CLOSE);
return 0;
* for a result set
*
*************************************************************************/
-static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
- int column, numfileds=sql_num_fields(sqlsocket, config);
+static int sql_free_result(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
+ int column, numfileds=sql_num_fields(handle, config);
/* Freeing reserved memory */
if(unixodbc_sock->row != NULL) {
* connection and cleans up any open handles.
*
*************************************************************************/
-static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_close(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
SQLFreeStmt(unixodbc_sock->stmt_handle, SQL_DROP);
SQLDisconnect(unixodbc_sock->dbc_handle);
* connection
*
*************************************************************************/
-static const char *sql_error(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static const char *sql_error(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLCHAR state[256];
SQLCHAR error[256];
SQLINTEGER errornum = 0;
SQLSMALLINT length = 255;
static char result[1024]; /* NOT thread-safe! */
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
error[0] = state[0] = '\0';
* connection related or -1 for other errors
*
*************************************************************************/
-static int sql_state(long err_handle, SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) {
+static int sql_state(long err_handle, rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config) {
SQLCHAR state[256];
SQLCHAR error[256];
SQLINTEGER errornum = 0;
SQLSMALLINT length = 255;
int res = -1;
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
if(SQL_SUCCEEDED(err_handle))
return 0; /* on success, just return 0 */
* or insert)
*
*************************************************************************/
-static int sql_affected_rows(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
- rlm_sql_unixodbc_sock *unixodbc_sock = sqlsocket->conn;
+static int sql_affected_rows(rlm_sql_handle_t *handle, rlm_sql_config_t *config) {
+ rlm_sql_unixodbc_sock *unixodbc_sock = handle->conn;
long err_handle;
SQLLEN affected_rows;
err_handle = SQLRowCount(unixodbc_sock->stmt_handle, &affected_rows);
- if (sql_state(err_handle, sqlsocket, config))
+ if (sql_state(err_handle, handle, config))
return -1;
return affected_rows;
static const CONF_PARSER module_config[] = {
{"driver", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_driver), NULL, "mysql"},
+ offsetof(rlm_sql_config_t,sql_driver), NULL, "mysql"},
{"server", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_server), NULL, "localhost"},
+ offsetof(rlm_sql_config_t,sql_server), NULL, "localhost"},
{"port", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_port), NULL, ""},
+ offsetof(rlm_sql_config_t,sql_port), NULL, ""},
{"login", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_login), NULL, ""},
+ offsetof(rlm_sql_config_t,sql_login), NULL, ""},
{"password", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_password), NULL, ""},
+ offsetof(rlm_sql_config_t,sql_password), NULL, ""},
{"radius_db", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,sql_db), NULL, "radius"},
+ offsetof(rlm_sql_config_t,sql_db), NULL, "radius"},
{"filename", PW_TYPE_FILENAME, /* for sqlite */
- offsetof(SQL_CONFIG,sql_file), NULL, NULL},
+ offsetof(rlm_sql_config_t,sql_file), NULL, NULL},
{"read_groups", PW_TYPE_BOOLEAN,
- offsetof(SQL_CONFIG,read_groups), NULL, "yes"},
+ offsetof(rlm_sql_config_t,read_groups), NULL, "yes"},
{"readclients", PW_TYPE_BOOLEAN,
- offsetof(SQL_CONFIG,do_clients), NULL, "no"},
+ offsetof(rlm_sql_config_t,do_clients), NULL, "no"},
{"deletestalesessions", PW_TYPE_BOOLEAN,
- offsetof(SQL_CONFIG,deletestalesessions), NULL, "yes"},
+ offsetof(rlm_sql_config_t,deletestalesessions), NULL, "yes"},
{"sql_user_name", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,query_user), NULL, ""},
+ offsetof(rlm_sql_config_t,query_user), NULL, ""},
{"logfile", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,logfile), NULL, NULL},
+ offsetof(rlm_sql_config_t,logfile), NULL, NULL},
{"default_user_profile", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,default_profile), NULL, ""},
+ offsetof(rlm_sql_config_t,default_profile), NULL, ""},
{"nas_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,nas_query), NULL,
+ offsetof(rlm_sql_config_t,nas_query), NULL,
"SELECT id,nasname,shortname,type,secret FROM nas"},
{"authorize_check_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,authorize_check_query), NULL, ""},
+ offsetof(rlm_sql_config_t,authorize_check_query), NULL, ""},
{"authorize_reply_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,authorize_reply_query), NULL, NULL},
+ offsetof(rlm_sql_config_t,authorize_reply_query), NULL, NULL},
{"authorize_group_check_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,authorize_group_check_query), NULL, ""},
+ offsetof(rlm_sql_config_t,authorize_group_check_query), NULL, ""},
{"authorize_group_reply_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,authorize_group_reply_query), NULL, ""},
+ offsetof(rlm_sql_config_t,authorize_group_reply_query), NULL, ""},
{"group_membership_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,groupmemb_query), NULL, NULL},
+ offsetof(rlm_sql_config_t,groupmemb_query), NULL, NULL},
#ifdef WITH_SESSION_MGMT
{"simul_count_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,simul_count_query), NULL, ""},
+ offsetof(rlm_sql_config_t,simul_count_query), NULL, ""},
{"simul_verify_query", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,simul_verify_query), NULL, ""},
+ offsetof(rlm_sql_config_t,simul_verify_query), NULL, ""},
#endif
{"safe-characters", PW_TYPE_STRING_PTR,
- offsetof(SQL_CONFIG,allowed_chars), NULL,
+ offsetof(rlm_sql_config_t,allowed_chars), NULL,
"@abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-_: /"},
/*
* This only works for a few drivers.
*/
{"query_timeout", PW_TYPE_INTEGER,
- offsetof(SQL_CONFIG,query_timeout), NULL, NULL},
+ offsetof(rlm_sql_config_t,query_timeout), NULL, NULL},
{NULL, -1, 0, NULL, NULL}
};
/*
* Yucky prototype.
*/
-static int generate_sql_clients(SQL_INST *inst);
+static int generate_sql_clients(rlm_sql_t *inst);
static size_t sql_escape_func(REQUEST *, char *out, size_t outlen, const char *in, void *arg);
/*
static size_t sql_xlat(void *instance, REQUEST *request,
const char *fmt, char *out, size_t freespace)
{
- SQLSOCK *sqlsocket;
- SQL_ROW row;
- SQL_INST *inst = instance;
+ rlm_sql_handle_t *handle;
+ rlm_sql_row_t row;
+ rlm_sql_t *inst = instance;
char querystr[MAX_QUERY_LEN];
size_t ret = 0;
return 0;
}
- sqlsocket = sql_get_socket(inst);
- if (sqlsocket == NULL)
+ handle = sql_get_socket(inst);
+ if (handle == NULL)
return 0;
rlm_sql_query_log(inst, request, NULL, querystr);
int numaffected;
char buffer[21]; /* 64bit max is 20 decimal chars + null byte */
- if (rlm_sql_query(&sqlsocket,inst,querystr)) {
- sql_release_socket(inst,sqlsocket);
+ if (rlm_sql_query(&handle,inst,querystr)) {
+ sql_release_socket(inst,handle);
return 0;
}
- numaffected = (inst->module->sql_affected_rows)(sqlsocket,
+ numaffected = (inst->module->sql_affected_rows)(handle,
inst->config);
if (numaffected < 1) {
RDEBUG("rlm_sql (%s): SQL query affected no rows",
if (ret >= freespace){
RDEBUG("rlm_sql (%s): Can't write result, insufficient string space",
inst->config->xlat_name);
- (inst->module->sql_finish_query)(sqlsocket,
+ (inst->module->sql_finish_query)(handle,
inst->config);
- sql_release_socket(inst,sqlsocket);
+ sql_release_socket(inst,handle);
return 0;
}
memcpy(out, buffer, ret + 1); /* we did bounds checking above */
- (inst->module->sql_finish_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return ret;
} /* else it's a SELECT statement */
- if (rlm_sql_select_query(&sqlsocket,inst,querystr)){
- sql_release_socket(inst,sqlsocket);
+ if (rlm_sql_select_query(&handle,inst,querystr)){
+ sql_release_socket(inst,handle);
return 0;
}
- ret = rlm_sql_fetch_row(&sqlsocket, inst);
+ ret = rlm_sql_fetch_row(&handle, inst);
if (ret) {
RDEBUG("SQL query did not succeed");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return 0;
}
- row = sqlsocket->row;
+ row = handle->row;
if (row == NULL) {
RDEBUG("SQL query did not return any results");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return 0;
}
if (row[0] == NULL){
RDEBUG("Null value in first column");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return 0;
}
ret = strlen(row[0]);
if (ret >= freespace){
RDEBUG("Insufficient string space");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return 0;
}
RDEBUG("sql_xlat finished");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst,sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst,handle);
return ret;
}
-static int generate_sql_clients(SQL_INST *inst)
+static int generate_sql_clients(rlm_sql_t *inst)
{
- SQLSOCK *sqlsocket;
- SQL_ROW row;
+ rlm_sql_handle_t *handle;
+ rlm_sql_row_t row;
char querystr[MAX_QUERY_LEN];
RADCLIENT *c;
char *prefix_ptr = NULL;
DEBUG("rlm_sql (%s) in generate_sql_clients: query is %s",
inst->config->xlat_name, querystr);
- sqlsocket = sql_get_socket(inst);
- if (sqlsocket == NULL)
+ handle = sql_get_socket(inst);
+ if (handle == NULL)
return -1;
- if (rlm_sql_select_query(&sqlsocket,inst,querystr)){
+ if (rlm_sql_select_query(&handle,inst,querystr)){
return -1;
}
- while(rlm_sql_fetch_row(&sqlsocket, inst) == 0) {
+ while(rlm_sql_fetch_row(&handle, inst) == 0) {
i++;
- row = sqlsocket->row;
+ row = handle->row;
if (row == NULL)
break;
/*
if(row[3] != NULL)
c->nastype = strdup(row[3]);
- numf = (inst->module->sql_num_fields)(sqlsocket, inst->config);
+ numf = (inst->module->sql_num_fields)(handle, inst->config);
if ((numf > 5) && (row[5] != NULL) && *row[5]) c->server = strdup(row[5]);
DEBUG("rlm_sql (%s): Adding client %s (%s, server=%s) to clients list",
inst->config->xlat_name,
c->longname,c->shortname, c->server ? c->server : "<none>");
if (!client_add(NULL, c)) {
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
DEBUG("rlm_sql (%s): Failed to add client %s (%s) to clients list. Maybe there's a duplicate?",
inst->config->xlat_name,
c->longname,c->shortname);
return -1;
}
}
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
return 0;
}
static size_t sql_escape_func(UNUSED REQUEST *request, char *out, size_t outlen,
const char *in, void *arg)
{
- SQL_INST *inst = arg;
+ rlm_sql_t *inst = arg;
size_t len = 0;
while (in[0]) {
* escape it twice. (it will make things wrong if we have an
* escape candidate character in the username)
*/
-int sql_set_user(SQL_INST *inst, REQUEST *request, const char *username)
+int sql_set_user(rlm_sql_t *inst, REQUEST *request, const char *username)
{
char buffer[254];
VALUE_PAIR *vp = NULL;
}
-static void sql_grouplist_free (SQL_GROUPLIST **group_list)
+static void sql_grouplist_free (rlm_sql_grouplist_t **group_list)
{
- SQL_GROUPLIST *last;
+ rlm_sql_grouplist_t *last;
while(*group_list) {
last = *group_list;
}
-static int sql_get_grouplist (SQL_INST *inst, SQLSOCK *sqlsocket, REQUEST *request, SQL_GROUPLIST **group_list)
+static int sql_get_grouplist (rlm_sql_t *inst, rlm_sql_handle_t *handle, REQUEST *request, rlm_sql_grouplist_t **group_list)
{
char querystr[MAX_QUERY_LEN];
int num_groups = 0;
- SQL_ROW row;
- SQL_GROUPLIST *group_list_tmp;
+ rlm_sql_row_t row;
+ rlm_sql_grouplist_t *group_list_tmp;
/* NOTE: sql_set_user should have been run before calling this function */
return -1;
}
- if (rlm_sql_select_query(&sqlsocket, inst, querystr) < 0) {
+ if (rlm_sql_select_query(&handle, inst, querystr) < 0) {
return -1;
}
- while (rlm_sql_fetch_row(&sqlsocket, inst) == 0) {
- row = sqlsocket->row;
+ while (rlm_sql_fetch_row(&handle, inst) == 0) {
+ row = handle->row;
if (row == NULL)
break;
if (row[0] == NULL){
RDEBUG("row[0] returned NULL");
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
sql_grouplist_free(group_list);
return -1;
}
if (*group_list == NULL) {
- *group_list = rad_malloc(sizeof(SQL_GROUPLIST));
+ *group_list = rad_malloc(sizeof(rlm_sql_grouplist_t));
group_list_tmp = *group_list;
} else {
rad_assert(group_list_tmp != NULL);
- group_list_tmp->next = rad_malloc(sizeof(SQL_GROUPLIST));
+ group_list_tmp->next = rad_malloc(sizeof(rlm_sql_grouplist_t));
group_list_tmp = group_list_tmp->next;
}
group_list_tmp->next = NULL;
strlcpy(group_list_tmp->groupname, row[0], MAX_STRING_LEN);
}
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
return num_groups;
}
static int sql_groupcmp(void *instance, REQUEST *request, VALUE_PAIR *request_vp, VALUE_PAIR *check,
VALUE_PAIR *check_pairs, VALUE_PAIR **reply_pairs)
{
- SQLSOCK *sqlsocket;
- SQL_INST *inst = instance;
- SQL_GROUPLIST *group_list, *group_list_tmp;
+ rlm_sql_handle_t *handle;
+ rlm_sql_t *inst = instance;
+ rlm_sql_grouplist_t *group_list, *group_list_tmp;
check_pairs = check_pairs;
reply_pairs = reply_pairs;
/*
* Get a socket for this lookup
*/
- sqlsocket = sql_get_socket(inst);
- if (sqlsocket == NULL) {
+ handle = sql_get_socket(inst);
+ if (handle == NULL) {
return 1;
}
/*
* Get the list of groups this user is a member of
*/
- if (sql_get_grouplist(inst, sqlsocket, request, &group_list) < 0) {
+ if (sql_get_grouplist(inst, handle, request, &group_list) < 0) {
radlog_request(L_ERR, 0, request,
"Error getting group membership");
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
return 1;
}
check->vp_strvalue);
/* Free the grouplist */
sql_grouplist_free(&group_list);
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
return 0;
}
}
/* Free the grouplist */
sql_grouplist_free(&group_list);
- sql_release_socket(inst,sqlsocket);
+ sql_release_socket(inst,handle);
RDEBUG("sql_groupcmp finished: User is NOT a member of group %s",
check->vp_strvalue);
-static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sqlsocket, int *dofallthrough)
+static int rlm_sql_process_groups(rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t *handle, int *dofallthrough)
{
VALUE_PAIR *check_tmp = NULL;
VALUE_PAIR *reply_tmp = NULL;
- SQL_GROUPLIST *group_list, *group_list_tmp;
+ rlm_sql_grouplist_t *group_list, *group_list_tmp;
VALUE_PAIR *sql_group = NULL;
char querystr[MAX_QUERY_LEN];
int found = 0;
/*
* Get the list of groups this user is a member of
*/
- if (sql_get_grouplist(inst, sqlsocket, request, &group_list) < 0) {
+ if (sql_get_grouplist(inst, handle, request, &group_list) < 0) {
radlog_request(L_ERR, 0, request, "Error retrieving group list");
return -1;
}
sql_grouplist_free(&group_list);
return -1;
}
- rows = sql_getvpdata(inst, &sqlsocket, &check_tmp, querystr);
+ rows = sql_getvpdata(inst, &handle, &check_tmp, querystr);
if (rows < 0) {
radlog_request(L_ERR, 0, request, "Error retrieving check pairs for group %s",
group_list_tmp->groupname);
sql_grouplist_free(&group_list);
return -1;
}
- if (sql_getvpdata(inst, &sqlsocket, &reply_tmp, querystr) < 0) {
+ if (sql_getvpdata(inst, &handle, &reply_tmp, querystr) < 0) {
radlog_request(L_ERR, 0, request, "Error retrieving reply pairs for group %s",
group_list_tmp->groupname);
/* Remove the grouup we added above */
sql_grouplist_free(&group_list);
return -1;
}
- if (sql_getvpdata(inst, &sqlsocket, &reply_tmp, querystr) < 0) {
+ if (sql_getvpdata(inst, &handle, &reply_tmp, querystr) < 0) {
radlog_request(L_ERR, 0, request, "Error retrieving reply pairs for group %s",
group_list_tmp->groupname);
/* Remove the grouup we added above */
static int rlm_sql_detach(void *instance)
{
- SQL_INST *inst = instance;
+ rlm_sql_t *inst = instance;
paircompare_unregister(PW_SQL_GROUP, sql_groupcmp);
}
static int parse_sub_section(CONF_SECTION *parent,
- SQL_INST *inst,
+ rlm_sql_t *inst,
sql_acct_section_t **config,
rlm_components_t comp)
{
static int rlm_sql_instantiate(CONF_SECTION *conf, void **instance)
{
- SQL_INST *inst;
+ rlm_sql_t *inst;
const char *xlat_name;
- *instance = inst = talloc_zero(conf, SQL_INST);
+ *instance = inst = talloc_zero(conf, rlm_sql_t);
if (!inst) return -1;
/*
inst->sql_select_query = rlm_sql_select_query;
inst->sql_fetch_row = rlm_sql_fetch_row;
- inst->config = talloc_zero(inst, SQL_CONFIG);
+ inst->config = talloc_zero(inst, rlm_sql_config_t);
inst->cs = conf;
xlat_name = cf_section_name2(conf);
{
int ret = RLM_MODULE_NOTFOUND;
- SQL_INST *inst = instance;
- SQLSOCK *sqlsocket;
+ rlm_sql_t *inst = instance;
+ rlm_sql_handle_t *handle;
VALUE_PAIR *check_tmp = NULL;
VALUE_PAIR *reply_tmp = NULL;
* After this point use goto error or goto release to cleanup sockets
* temporary pairlists and temporary attributes.
*/
- sqlsocket = sql_get_socket(inst);
- if (sqlsocket == NULL)
+ handle = sql_get_socket(inst);
+ if (handle == NULL)
goto error;
/*
goto error;
}
- rows = sql_getvpdata(inst, &sqlsocket, &check_tmp, querystr);
+ rows = sql_getvpdata(inst, &handle, &check_tmp, querystr);
if (rows < 0) {
radlog_request(L_ERR, 0, request, "SQL query error; rejecting user");
goto error;
}
- rows = sql_getvpdata(inst, &sqlsocket, &reply_tmp, querystr);
+ rows = sql_getvpdata(inst, &handle, &reply_tmp, querystr);
if (rows < 0) {
radlog_request(L_ERR, 0, request, "SQL query error; rejecting user");
* the groups as well.
*/
if (dofallthrough) {
- rows = rlm_sql_process_groups(inst, request, sqlsocket, &dofallthrough);
+ rows = rlm_sql_process_groups(inst, request, handle, &dofallthrough);
if (rows < 0) {
radlog_request(L_ERR, 0, request, "Error processing groups; rejecting user");
goto error;
}
- rows = rlm_sql_process_groups(inst, request, sqlsocket, &dofallthrough);
+ rows = rlm_sql_process_groups(inst, request, handle, &dofallthrough);
if (rows < 0) {
radlog_request(L_ERR, 0, request, "Error processing profile groups; rejecting user");
ret = RLM_MODULE_FAIL;
release:
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
pairfree(&check_tmp);
pairfree(&reply_tmp);
* doesn't update any rows, the next matching config item is used.
*
*/
-static int acct_redundant(SQL_INST *inst, REQUEST *request,
+static int acct_redundant(rlm_sql_t *inst, REQUEST *request,
sql_acct_section_t *section)
{
int ret = RLM_MODULE_OK;
- SQLSOCK *sqlsocket = NULL;
+ rlm_sql_handle_t *handle = NULL;
int sql_ret;
int numaffected = 0;
RDEBUG2("Using query template '%s'", attr);
- sqlsocket = sql_get_socket(inst);
- if (sqlsocket == NULL)
+ handle = sql_get_socket(inst);
+ if (handle == NULL)
return RLM_MODULE_FAIL;
sql_set_user(inst, request, NULL);
* were exhausted, and we couldn't create a new connection,
* so we do not need to call sql_release_socket.
*/
- sql_ret = rlm_sql_query(&sqlsocket, inst, querystr);
+ sql_ret = rlm_sql_query(&handle, inst, querystr);
if (sql_ret == SQL_DOWN)
return RLM_MODULE_FAIL;
- rad_assert(sqlsocket);
+ rad_assert(handle);
/*
* Assume all other errors are incidental, and just meant our
*/
if (sql_ret == 0) {
numaffected = (inst->module->sql_affected_rows)
- (sqlsocket, inst->config);
+ (handle, inst->config);
if (numaffected > 0)
break;
RDEBUG("No records updated");
}
- (inst->module->sql_finish_query)(sqlsocket, inst->config);
+ (inst->module->sql_finish_query)(handle, inst->config);
/*
* We assume all entries with the same name form a redundant
RDEBUG("Trying next query...");
}
- (inst->module->sql_finish_query)(sqlsocket, inst->config);
+ (inst->module->sql_finish_query)(handle, inst->config);
release:
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
return ret;
}
* Accounting: Insert or update session data in our sql table
*/
static rlm_rcode_t rlm_sql_accounting(void *instance, REQUEST * request) {
- SQL_INST *inst = instance;
+ rlm_sql_t *inst = instance;
if (inst->config->accounting) {
return acct_redundant(inst, request, inst->config->accounting);
*/
static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) {
- SQLSOCK *sqlsocket;
- SQL_INST *inst = instance;
- SQL_ROW row;
+ rlm_sql_handle_t *handle;
+ rlm_sql_t *inst = instance;
+ rlm_sql_row_t row;
char querystr[MAX_QUERY_LEN];
int check = 0;
uint32_t ipno = 0;
radius_xlat(querystr, sizeof(querystr), inst->config->simul_count_query, request, sql_escape_func, inst);
/* initialize the sql socket */
- sqlsocket = sql_get_socket(inst);
- if(sqlsocket == NULL)
+ handle = sql_get_socket(inst);
+ if(handle == NULL)
return RLM_MODULE_FAIL;
- if(rlm_sql_select_query(&sqlsocket, inst, querystr)) {
- sql_release_socket(inst, sqlsocket);
+ if(rlm_sql_select_query(&handle, inst, querystr)) {
+ sql_release_socket(inst, handle);
return RLM_MODULE_FAIL;
}
- ret = rlm_sql_fetch_row(&sqlsocket, inst);
+ ret = rlm_sql_fetch_row(&handle, inst);
if (ret != 0) {
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
return RLM_MODULE_FAIL;
}
- row = sqlsocket->row;
+ row = handle->row;
if (row == NULL) {
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
return RLM_MODULE_FAIL;
}
request->simul_count = atoi(row[0]);
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
if(request->simul_count < request->simul_max) {
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
return RLM_MODULE_OK;
}
*/
if (!inst->config->simul_verify_query ||
(inst->config->simul_verify_query[0] == '\0')) {
- sql_release_socket(inst, sqlsocket);
+ sql_release_socket(inst, handle);
return RLM_MODULE_OK;
}
radius_xlat(querystr, sizeof(querystr), inst->config->simul_verify_query, request, sql_escape_func, inst);
- if(rlm_sql_select_query(&sqlsocket, inst, querystr)) {
- sql_release_socket(inst, sqlsocket);
+ if(rlm_sql_select_query(&handle, inst, querystr)) {
+ sql_release_socket(inst, handle);
return RLM_MODULE_FAIL;
}
call_num = vp->vp_strvalue;
- while (rlm_sql_fetch_row(&sqlsocket, inst) == 0) {
- row = sqlsocket->row;
+ while (rlm_sql_fetch_row(&handle, inst) == 0) {
+ row = handle->row;
if (row == NULL)
break;
if (!row[2]){
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
RDEBUG("Cannot zap stale entry. No username present in entry.", inst->config->xlat_name);
return RLM_MODULE_FAIL;
}
if (!row[1]){
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
RDEBUG("Cannot zap stale entry. No session id in entry.", inst->config->xlat_name);
return RLM_MODULE_FAIL;
}
* Failed to check the terminal server for
* duplicate logins: return an error.
*/
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
radlog_request(L_ERR, 0, request, "Failed to check the terminal server for user '%s'.", row[2]);
return RLM_MODULE_FAIL;
}
}
- (inst->module->sql_finish_select_query)(sqlsocket, inst->config);
- sql_release_socket(inst, sqlsocket);
+ (inst->module->sql_finish_select_query)(handle, inst->config);
+ sql_release_socket(inst, handle);
/*
* The Auth module apparently looks at request->simul_count,
* Postauth: Write a record of the authentication attempt
*/
static rlm_rcode_t rlm_sql_postauth(void *instance, REQUEST * request) {
- SQL_INST *inst = instance;
+ rlm_sql_t *inst = instance;
if (inst->config->postauth) {
return acct_redundant(inst, request, inst->config->postauth);
/***************************************************************************
-* rlm_sql.h rlm_sql - FreeRADIUS SQL Module *
-* *
-* Header for main SQL module file *
-* *
-* Mike Machado <mike@innercite.com> *
+* rlm_sql.h rlm_sql - FreeRADIUS SQL Module *
+* *
+* Header for main SQL module file *
+* *
+* Mike Machado <mike@innercite.com> *
***************************************************************************/
#ifndef _RLM_SQL_H
#define _RLM_SQL_H
#define PW_ITEM_CHECK 0
#define PW_ITEM_REPLY 1
-typedef char** SQL_ROW;
+typedef char** rlm_sql_row_t;
/*
- * Sections where we dynamically resolve the config entry to use,
- * by xlating reference.
+ * Sections where we dynamically resolve the config entry to use,
+ * by xlating reference.
*/
typedef struct sql_acct_section {
CONF_SECTION *cs;
- const char *reference;
+ const char *reference;
- const char *logfile;
+ const char *logfile;
} sql_acct_section_t;
typedef struct sql_config {
const char *sql_login;
const char *sql_password;
const char *sql_db;
- const char *sql_file; /* for sqlite */
+ const char *sql_file; /*for sqlite */
const char *query_user;
int const deletestalesessions;
const char *allowed_chars;
int const query_timeout;
- void *localcfg; /* individual driver config */
+ void *localcfg; /*individual driver config */
- /*
- * TODO: The rest of the queries should also be moved into their own
- * sections.
+ /*
+ *TODO: The rest of the queries should also be moved into their own
+ *sections.
*/
- /* Section configurations */
+ /*Section configurations */
sql_acct_section_t *postauth;
sql_acct_section_t *accounting;
-} SQL_CONFIG;
+} rlm_sql_config_t;
-typedef struct sql_socket {
+typedef struct rlm_sql_handle {
void *conn;
- SQL_ROW row;
-} SQLSOCK;
+ rlm_sql_row_t row;
+} rlm_sql_handle_t;
typedef struct rlm_sql_module_t {
const char *name;
- int (*sql_init_socket)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_destroy_socket)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_query)(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *query);
- int (*sql_select_query)(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *query);
- int (*sql_store_result)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_num_fields)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_num_rows)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_fetch_row)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_free_result)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- const char *(*sql_error)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_close)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_finish_query)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_finish_select_query)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
- int (*sql_affected_rows)(SQLSOCK *sqlsocket, SQL_CONFIG *config);
+ int (*sql_init_socket)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_destroy_socket)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *query);
+ int (*sql_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *query);
+ int (*sql_store_result)(rlm_sql_handle_t *handle, rlm_sql_config_t *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_fetch_row)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_free_result)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ const char *(*sql_error)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_close)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_finish_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_finish_select_query)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
+ int (*sql_affected_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t *config);
} rlm_sql_module_t;
-typedef struct sql_inst SQL_INST;
+typedef struct sql_inst rlm_sql_t;
struct sql_inst {
- fr_connection_pool_t *pool;
- SQL_CONFIG *config;
- CONF_SECTION *cs;
+ fr_connection_pool_t *pool;
+ rlm_sql_config_t *config;
+ CONF_SECTION *cs;
- const DICT_ATTR *sql_user; //!< Cached pointer to SQL-User-Name
- //!< dictionary attribute.
+ const DICT_ATTR *sql_user; //!< Cached pointer to SQL-User-Name
+ //!< dictionary attribute.
lt_dlhandle handle;
rlm_sql_module_t *module;
- int (*sql_set_user)(SQL_INST *inst, REQUEST *request, const char *username);
- SQLSOCK *(*sql_get_socket)(SQL_INST * inst);
- int (*sql_release_socket)(SQL_INST * inst, SQLSOCK * sqlsocket);
+ int (*sql_set_user)(rlm_sql_t *inst, REQUEST *request, const char *username);
+ rlm_sql_handle_t *(*sql_get_socket)(rlm_sql_t *inst);
+ int (*sql_release_socket)(rlm_sql_t *inst, rlm_sql_handle_t *handle);
size_t (*sql_escape_func)(REQUEST *, char *out, size_t outlen, const char *in, void *arg);
- int (*sql_query)(SQLSOCK **sqlsocket, SQL_INST *inst, char *query);
- int (*sql_select_query)(SQLSOCK **sqlsocket, SQL_INST *inst, char *query);
- int (*sql_fetch_row)(SQLSOCK **sqlsocket, SQL_INST *inst);
+ int (*sql_query)(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query);
+ int (*sql_select_query)(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query);
+ int (*sql_fetch_row)(rlm_sql_handle_t **handle, rlm_sql_t *inst);
};
typedef struct sql_grouplist {
char groupname[MAX_STRING_LEN];
struct sql_grouplist *next;
-} SQL_GROUPLIST;
-
-
-int sql_init_socketpool(SQL_INST * inst);
-void sql_poolfree(SQL_INST * inst);
-int sql_close_socket(SQL_INST *inst, SQLSOCK * sqlsocket);
-SQLSOCK *sql_get_socket(SQL_INST * inst);
-int sql_release_socket(SQL_INST * inst, SQLSOCK * sqlsocket);
-int sql_userparse(VALUE_PAIR ** first_pair, SQL_ROW row);
-int sql_read_realms(SQLSOCK * sqlsocket);
-int sql_getvpdata(SQL_INST * inst, SQLSOCK ** sqlsocket, VALUE_PAIR **pair, char *query);
-int sql_read_naslist(SQLSOCK * sqlsocket);
-int sql_read_clients(SQLSOCK * sqlsocket);
-int sql_dict_init(SQLSOCK * sqlsocket);
-void rlm_sql_query_log(SQL_INST *inst, REQUEST *request,
+} rlm_sql_grouplist_t;
+
+int sql_init_socketpool(rlm_sql_t *inst);
+void sql_poolfree(rlm_sql_t *inst);
+int sql_close_socket(rlm_sql_t *inst, rlm_sql_handle_t *handle);
+rlm_sql_handle_t *sql_get_socket(rlm_sql_t *inst);
+int sql_release_socket(rlm_sql_t *inst, rlm_sql_handle_t *handle);
+int sql_userparse(VALUE_PAIR **first_pair, rlm_sql_row_t row);
+int sql_read_realms(rlm_sql_handle_t *handle);
+int sql_getvpdata(rlm_sql_t *inst, rlm_sql_handle_t **handle, VALUE_PAIR **pair, char *query);
+int sql_read_naslist(rlm_sql_handle_t *handle);
+int sql_read_clients(rlm_sql_handle_t *handle);
+int sql_dict_init(rlm_sql_handle_t *handle);
+void rlm_sql_query_log(rlm_sql_t *inst, REQUEST *request,
sql_acct_section_t *section, char *querystr);
-int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query);
-int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query);
-int rlm_sql_fetch_row(SQLSOCK **sqlsocket, SQL_INST *inst);
-int sql_set_user(SQL_INST *inst, REQUEST *request, const char *username);
+int rlm_sql_select_query(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query);
+int rlm_sql_query(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query);
+int rlm_sql_fetch_row(rlm_sql_handle_t **handle, rlm_sql_t *inst);
+int sql_set_user(rlm_sql_t *inst, REQUEST *request, const char *username);
#endif
static void *sql_conn_create(void *ctx)
{
int rcode;
- SQL_INST *inst = ctx;
- SQLSOCK *sqlsocket;
+ rlm_sql_t *inst = ctx;
+ rlm_sql_handle_t *handle;
- sqlsocket = rad_calloc(sizeof(*sqlsocket));
+ handle = rad_calloc(sizeof(*handle));
- rcode = (inst->module->sql_init_socket)(sqlsocket, inst->config);
+ rcode = (inst->module->sql_init_socket)(handle, inst->config);
if (rcode == 0) {
exec_trigger(NULL, inst->cs, "modules.sql.open", FALSE);
- return sqlsocket;
+ return handle;
}
exec_trigger(NULL, inst->cs, "modules.sql.fail", TRUE);
- free(sqlsocket);
+ free(handle);
return NULL;
}
static int sql_conn_delete(void *ctx, void *connection)
{
- SQL_INST *inst = ctx;
- SQLSOCK *sqlsocket = connection;
+ rlm_sql_t *inst = ctx;
+ rlm_sql_handle_t *handle = connection;
exec_trigger(NULL, inst->cs, "modules.sql.close", FALSE);
- if (sqlsocket->conn) {
- (inst->module->sql_close)(sqlsocket, inst->config);
+ if (handle->conn) {
+ (inst->module->sql_close)(handle, inst->config);
}
if (inst->module->sql_destroy_socket) {
- (inst->module->sql_destroy_socket)(sqlsocket, inst->config);
+ (inst->module->sql_destroy_socket)(handle, inst->config);
}
- free(sqlsocket);
+ free(handle);
return 0;
}
* Purpose: Connect to the sql server, if possible
*
*************************************************************************/
-int sql_init_socketpool(SQL_INST * inst)
+int sql_init_socketpool(rlm_sql_t * inst)
{
inst->pool = fr_connection_pool_init(inst->cs, inst,
sql_conn_create,
* Purpose: Clean up and free sql pool
*
*************************************************************************/
-void sql_poolfree(SQL_INST * inst)
+void sql_poolfree(rlm_sql_t * inst)
{
fr_connection_pool_delete(inst->pool);
}
*
* Function: sql_get_socket
*
- * Purpose: Return a SQL sqlsocket from the connection pool
+ * Purpose: Return a SQL handle from the connection pool
*
*************************************************************************/
-SQLSOCK * sql_get_socket(SQL_INST * inst)
+rlm_sql_handle_t * sql_get_socket(rlm_sql_t * inst)
{
return fr_connection_get(inst->pool);
}
*
* Function: sql_release_socket
*
- * Purpose: Frees a SQL sqlsocket back to the connection pool
+ * Purpose: Frees a SQL handle back to the connection pool
*
*************************************************************************/
-int sql_release_socket(SQL_INST * inst, SQLSOCK * sqlsocket)
+int sql_release_socket(rlm_sql_t * inst, rlm_sql_handle_t * handle)
{
- fr_connection_release(inst->pool, sqlsocket);
+ fr_connection_release(inst->pool, handle);
return 0;
}
* Purpose: Read entries from the database and fill VALUE_PAIR structures
*
*************************************************************************/
-int sql_userparse(VALUE_PAIR **head, SQL_ROW row)
+int sql_userparse(VALUE_PAIR **head, rlm_sql_row_t row)
{
VALUE_PAIR *vp;
const char *ptr, *value;
* Purpose: call the module's sql_fetch_row and implement re-connect
*
*************************************************************************/
-int rlm_sql_fetch_row(SQLSOCK **sqlsocket, SQL_INST *inst)
+int rlm_sql_fetch_row(rlm_sql_handle_t **handle, rlm_sql_t *inst)
{
int ret;
- if (!*sqlsocket || !(*sqlsocket)->conn) {
+ if (!*handle || !(*handle)->conn) {
return -1;
}
* the original connection to free up queries or result sets associated with
* that connection.
*/
- ret = (inst->module->sql_fetch_row)(*sqlsocket, inst->config);
+ ret = (inst->module->sql_fetch_row)(*handle, inst->config);
if (ret < 0) {
radlog(L_ERR, "rlm_sql (%s): Error fetching row: %s", inst->config->xlat_name,
- (inst->module->sql_error)(*sqlsocket, inst->config));
+ (inst->module->sql_error)(*handle, inst->config));
}
return ret;
* Purpose: call the module's sql_query and implement re-connect
*
*************************************************************************/
-int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query)
+int rlm_sql_query(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query)
{
int ret;
return -1;
}
- if (!*sqlsocket || !(*sqlsocket)->conn) {
+ if (!*handle || !(*handle)->conn) {
ret = -1;
goto sql_down;
}
DEBUG("rlm_sql (%s): Executing query: '%s'",
inst->config->xlat_name, query);
- ret = (inst->module->sql_query)(*sqlsocket, inst->config, query);
+ ret = (inst->module->sql_query)(*handle, inst->config, query);
/*
* Run through all available sockets until we exhaust all existing
* sockets in the pool and fail to establish a *new* connection.
*/
if (ret == SQL_DOWN) {
sql_down:
- *sqlsocket = fr_connection_reconnect(inst->pool, *sqlsocket);
- if (!*sqlsocket) return SQL_DOWN;
+ *handle = fr_connection_reconnect(inst->pool, *handle);
+ if (!*handle) return SQL_DOWN;
continue;
}
radlog(L_ERR,
"rlm_sql (%s): Database query error: '%s'",
inst->config->xlat_name,
- (inst->module->sql_error)(*sqlsocket, inst->config));
+ (inst->module->sql_error)(*handle, inst->config));
}
return ret;
* Purpose: call the module's sql_select_query and implement re-connect
*
*************************************************************************/
-int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query)
+int rlm_sql_select_query(rlm_sql_handle_t **handle, rlm_sql_t *inst, char *query)
{
int ret;
return -1;
}
- if (!*sqlsocket || !(*sqlsocket)->conn) {
+ if (!*handle || !(*handle)->conn) {
ret = -1;
goto sql_down;
}
DEBUG("rlm_sql (%s): Executing query: '%s'",
inst->config->xlat_name, query);
- ret = (inst->module->sql_select_query)(*sqlsocket, inst->config, query);
+ ret = (inst->module->sql_select_query)(*handle, inst->config, query);
/*
* Run through all available sockets until we exhaust all existing
* sockets in the pool and fail to establish a *new* connection.
*/
if (ret == SQL_DOWN) {
sql_down:
- *sqlsocket = fr_connection_reconnect(inst->pool, *sqlsocket);
- if (!*sqlsocket) return SQL_DOWN;
+ *handle = fr_connection_reconnect(inst->pool, *handle);
+ if (!*handle) return SQL_DOWN;
continue;
}
radlog(L_ERR,
"rlm_sql (%s): Database query error '%s'",
inst->config->xlat_name,
- (inst->module->sql_error)(*sqlsocket, inst->config));
+ (inst->module->sql_error)(*handle, inst->config));
}
return ret;
* Purpose: Get any group check or reply pairs
*
*************************************************************************/
-int sql_getvpdata(SQL_INST * inst, SQLSOCK **sqlsocket, VALUE_PAIR **pair, char *query)
+int sql_getvpdata(rlm_sql_t * inst, rlm_sql_handle_t **handle, VALUE_PAIR **pair, char *query)
{
- SQL_ROW row;
+ rlm_sql_row_t row;
int rows = 0;
- if (rlm_sql_select_query(sqlsocket, inst, query))
+ if (rlm_sql_select_query(handle, inst, query))
return -1;
- while (rlm_sql_fetch_row(sqlsocket, inst) == 0) {
- row = (*sqlsocket)->row;
+ while (rlm_sql_fetch_row(handle, inst) == 0) {
+ row = (*handle)->row;
if (!row)
break;
if (sql_userparse(pair, row) != 0) {
radlog(L_ERR, "rlm_sql (%s): Error getting data from database", inst->config->xlat_name);
- (inst->module->sql_finish_select_query)(*sqlsocket, inst->config);
+ (inst->module->sql_finish_select_query)(*handle, inst->config);
return -1;
}
rows++;
}
- (inst->module->sql_finish_select_query)(*sqlsocket, inst->config);
+ (inst->module->sql_finish_select_query)(*handle, inst->config);
return rows;
}
/*
* Log the query to a file.
*/
-void rlm_sql_query_log(SQL_INST *inst, REQUEST *request,
+void rlm_sql_query_log(rlm_sql_t *inst, REQUEST *request,
sql_acct_section_t *section, char *query)
{
int fd;
typedef struct rlm_sqlhpwippool_t {
const char *myname; /* name of this instance */
- SQL_INST *sqlinst; /* SQL_INST for requested instance */
+ rlm_sql_t *sqlinst; /* rlm_sql_t for requested instance */
rlm_sql_module_t *db; /* here the fun takes place ;-) */
#ifdef HAVE_PTHREAD_D
pthread_mutex_t mutex; /* used "with" syncafter */
}
/* handy SQL query tool */
static int nvp_vquery(unsigned int line, rlm_sqlhpwippool_t *data,
- SQLSOCK *sqlsock, const char *fmt, va_list ap)
+ rlm_sql_handle_t *sqlsock, const char *fmt, va_list ap)
{
char query[MAX_QUERY_LEN];
/* wrapper around nvp_vquery */
static int nvp_query(unsigned int line, rlm_sqlhpwippool_t *data,
- SQLSOCK *sqlsock, const char *fmt, ...)
+ rlm_sql_handle_t *sqlsock, const char *fmt, ...)
{
int r;
va_list ap;
}
/* handy wrapper around data->db->sql_finish_query() */
-static int nvp_finish(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock)
+static int nvp_finish(rlm_sqlhpwippool_t *data, rlm_sql_handle_t *sqlsock)
{
return (data->db->sql_finish_query)(sqlsock, data->sqlinst->config);
}
* 0 on db error
* 1 on success */
static int nvp_select(unsigned int line, rlm_sqlhpwippool_t *data,
- SQLSOCK *sqlsock, const char *fmt, ...)
+ rlm_sql_handle_t *sqlsock, const char *fmt, ...)
{
va_list ap;
return 1;
}
-static int nvp_select_finish(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock)
+static int nvp_select_finish(rlm_sqlhpwippool_t *data, rlm_sql_handle_t *sqlsock)
{
return ((data->db->sql_free_result)(sqlsock, data->sqlinst->config) ||
nvp_finish(data, sqlsock));
}
/* frees IPs of closed sessions (eg. by external modifications to db) */
-static int nvp_freeclosed(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock)
+static int nvp_freeclosed(rlm_sqlhpwippool_t *data, rlm_sql_handle_t *sqlsock)
{
if (!nvp_query(__LINE__, data, sqlsock,
"UPDATE `%s`.`ips`, `radacct` "
}
/* updates number of free IP addresses in pools */
-static int nvp_syncfree(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock)
+static int nvp_syncfree(rlm_sqlhpwippool_t *data, rlm_sql_handle_t *sqlsock)
{
if (!nvp_query(__LINE__, data, sqlsock,
"UPDATE `%s`.`ip_pools` "
/* cleanup IP pools and sync them with radacct */
static int nvp_cleanup(rlm_sqlhpwippool_t *data)
{
- SQLSOCK *sqlsock;
+ rlm_sql_handle_t *sqlsock;
/* initialize the SQL socket */
sqlsock = sql_get_socket(data->sqlinst);
}
/* save pointers to useful "objects" */
- inst->sqlinst = (SQL_INST *) sqlinst->insthandle;
+ inst->sqlinst = (rlm_sql_t *) sqlinst->insthandle;
inst->db = (rlm_sql_module_t *) inst->sqlinst->module;
return ((nvp_cleanup(inst)) ? 0 : -1);
char *pname; /* name of requested IP pool */
uint32_t nasip; /* NAS IP in host byte order */
struct in_addr ip = {0}; /* reserved IP for client (net. byte order) */
- SQLSOCK *sqlsock;
+ rlm_sql_handle_t *sqlsock;
unsigned long s_gid, /* _s_elected in sql result set */
s_prio, /* as above */
s_pid, /* as above */
static rlm_rcode_t sqlhpwippool_accounting(void *instance, REQUEST *request)
{
VALUE_PAIR *vp;
- SQLSOCK *sqlsock;
+ rlm_sql_handle_t *sqlsock;
struct in_addr nasip; /* NAS IP */
char *sessid; /* unique session id */
char nasipstr[16]; /* NAS IP in string format */
int lease_duration;
- SQL_INST *sql_inst;
+ rlm_sql_t *sql_inst;
char *pool_name;
/*
* Query the database executing a command with no result rows
*/
-static int sqlippool_command(const char * fmt, SQLSOCK * sqlsocket,
+static int sqlippool_command(const char * fmt, rlm_sql_handle_t * handle,
rlm_sqlippool_t *data, REQUEST * request,
char * param, int param_len)
{
#if 0
DEBUG2("sqlippool_command: '%s'", query);
#endif
- if (data->sql_inst->sql_query(&sqlsocket, data->sql_inst, query)){
+ if (data->sql_inst->sql_query(&handle, data->sql_inst, query)){
radlog(L_ERR, "sqlippool_command: database query error in: '%s'", query);
return 0;
}
- (data->sql_inst->module->sql_finish_query)(sqlsocket,
+ (data->sql_inst->module->sql_finish_query)(handle,
data->sql_inst->config);
return 0;
}
* Query the database expecting a single result row
*/
static int sqlippool_query1(char * out, int outlen, const char * fmt,
- SQLSOCK * sqlsocket, rlm_sqlippool_t *data,
+ rlm_sql_handle_t * handle, rlm_sqlippool_t *data,
REQUEST * request, char * param, int param_len)
{
char expansion[MAX_QUERY_LEN];
strcpy(query, expansion);
}
- if (data->sql_inst->sql_select_query(&sqlsocket, data->sql_inst, query)){
+ if (data->sql_inst->sql_select_query(&handle, data->sql_inst, query)){
radlog(L_ERR, "sqlippool_query1: database query error");
out[0] = '\0';
return 0;
out[0] = '\0';
- if (!data->sql_inst->sql_fetch_row(&sqlsocket, data->sql_inst)) {
- if (sqlsocket->row) {
- if (sqlsocket->row[0]) {
- if ((rlen = strlen(sqlsocket->row[0])) < outlen) {
- strcpy(out, sqlsocket->row[0]);
+ if (!data->sql_inst->sql_fetch_row(&handle, data->sql_inst)) {
+ if (handle->row) {
+ if (handle->row[0]) {
+ if ((rlen = strlen(handle->row[0])) < outlen) {
+ strcpy(out, handle->row[0]);
retval = rlen;
} else {
RDEBUG("insufficient string space");
RDEBUG("SQL query did not succeed");
}
- (data->sql_inst->module->sql_finish_select_query)(sqlsocket,
+ (data->sql_inst->module->sql_finish_select_query)(handle,
data->sql_inst->config);
return retval;
}
return -1;
}
- inst->sql_inst = (SQL_INST *) sqlinst->insthandle;
+ inst->sql_inst = (rlm_sql_t *) sqlinst->insthandle;
return 0;
}
int allocation_len;
uint32_t ip_allocation;
VALUE_PAIR * vp;
- SQLSOCK * sqlsocket;
+ rlm_sql_handle_t * handle;
fr_ipaddr_t ipaddr;
char logstr[MAX_STRING_LEN];
return do_logging(logstr, RLM_MODULE_NOOP);
}
- sqlsocket = inst->sql_inst->sql_get_socket(inst->sql_inst);
- if (sqlsocket == NULL) {
+ handle = inst->sql_inst->sql_get_socket(inst->sql_inst);
+ if (handle == NULL) {
RDEBUG("cannot allocate sql connection");
return RLM_MODULE_FAIL;
}
/*
* BEGIN
*/
- sqlippool_command(inst->allocate_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->allocate_begin, handle, inst, request,
(char *) NULL, 0);
/*
* CLEAR
*/
- sqlippool_command(inst->allocate_clear, sqlsocket, inst, request,
+ sqlippool_command(inst->allocate_clear, handle, inst, request,
(char *) NULL, 0);
/*
* FIND
*/
allocation_len = sqlippool_query1(allocation, sizeof(allocation),
- inst->allocate_find, sqlsocket,
+ inst->allocate_find, handle,
inst, request, (char *) NULL, 0);
/*
/*
* COMMIT
*/
- sqlippool_command(inst->allocate_commit, sqlsocket, instance,
+ sqlippool_command(inst->allocate_commit, handle, instance,
request, (char *) NULL, 0);
/*
* Let's check if the pool exists at all
*/
allocation_len = sqlippool_query1(allocation, sizeof(allocation),
- inst->pool_check, sqlsocket, inst, request,
+ inst->pool_check, handle, inst, request,
(char *) NULL, 0);
- inst->sql_inst->sql_release_socket(inst->sql_inst, sqlsocket);
+ inst->sql_inst->sql_release_socket(inst->sql_inst, handle);
if (allocation_len) {
}
- inst->sql_inst->sql_release_socket(inst->sql_inst, sqlsocket);
+ inst->sql_inst->sql_release_socket(inst->sql_inst, handle);
RDEBUG("IP address could not be allocated.");
radius_xlat(logstr, sizeof(logstr), inst->log_failed,
/*
* COMMIT
*/
- sqlippool_command(inst->allocate_commit, sqlsocket, instance,
+ sqlippool_command(inst->allocate_commit, handle, instance,
request, (char *) NULL, 0);
RDEBUG("Invalid IP number [%s] returned from instbase query.", allocation);
- inst->sql_inst->sql_release_socket(inst->sql_inst, sqlsocket);
+ inst->sql_inst->sql_release_socket(inst->sql_inst, handle);
radius_xlat(logstr, sizeof(logstr), inst->log_failed,
request, NULL, NULL);
/*
* UPDATE
*/
- sqlippool_command(inst->allocate_update, sqlsocket, inst, request,
+ sqlippool_command(inst->allocate_update, handle, inst, request,
allocation, allocation_len);
RDEBUG("Allocated IP %s [%08x]", allocation, ip_allocation);
/*
* COMMIT
*/
- sqlippool_command(inst->allocate_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->allocate_commit, handle, inst, request,
(char *) NULL, 0);
- inst->sql_inst->sql_release_socket(inst->sql_inst, sqlsocket);
+ inst->sql_inst->sql_release_socket(inst->sql_inst, handle);
radius_xlat(logstr, sizeof(logstr), inst->log_success, request, NULL, NULL);
return do_logging(logstr, RLM_MODULE_OK);
}
-static int sqlippool_accounting_start(SQLSOCK * sqlsocket,
+static int sqlippool_accounting_start(rlm_sql_handle_t * handle,
rlm_sqlippool_t *inst, REQUEST *request)
{
/*
* BEGIN
*/
- sqlippool_command(inst->start_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->start_begin, handle, inst, request,
(char *) NULL, 0);
/*
* UPDATE
*/
- sqlippool_command(inst->start_update, sqlsocket, inst, request,
+ sqlippool_command(inst->start_update, handle, inst, request,
(char *) NULL, 0);
/*
* COMMIT
*/
- sqlippool_command(inst->start_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->start_commit, handle, inst, request,
(char *) NULL, 0);
return RLM_MODULE_OK;
}
-static int sqlippool_accounting_alive(SQLSOCK * sqlsocket,
+static int sqlippool_accounting_alive(rlm_sql_handle_t * handle,
rlm_sqlippool_t *inst, REQUEST *request)
{
/*
* BEGIN
*/
- sqlippool_command(inst->alive_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->alive_begin, handle, inst, request,
(char *) NULL, 0);
/*
* UPDATE
*/
- sqlippool_command(inst->alive_update, sqlsocket, inst, request,
+ sqlippool_command(inst->alive_update, handle, inst, request,
(char *) NULL, 0);
/*
* COMMIT
*/
- sqlippool_command(inst->alive_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->alive_commit, handle, inst, request,
(char *) NULL, 0);
return RLM_MODULE_OK;
}
-static int sqlippool_accounting_stop(SQLSOCK * sqlsocket,
+static int sqlippool_accounting_stop(rlm_sql_handle_t * handle,
rlm_sqlippool_t *inst, REQUEST *request)
{
char logstr[MAX_STRING_LEN];
/*
* BEGIN
*/
- sqlippool_command(inst->stop_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->stop_begin, handle, inst, request,
(char *) NULL, 0);
/*
* CLEAR
*/
- sqlippool_command(inst->stop_clear, sqlsocket, inst, request,
+ sqlippool_command(inst->stop_clear, handle, inst, request,
(char *) NULL, 0);
/*
* COMMIT
*/
- sqlippool_command(inst->stop_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->stop_commit, handle, inst, request,
(char *) NULL, 0);
radius_xlat(logstr, sizeof(logstr), inst->log_clear, request, NULL, NULL);
return do_logging(logstr, RLM_MODULE_OK);
}
-static int sqlippool_accounting_on(SQLSOCK * sqlsocket,
+static int sqlippool_accounting_on(rlm_sql_handle_t * handle,
rlm_sqlippool_t *inst, REQUEST *request)
{
/*
* BEGIN
*/
- sqlippool_command(inst->on_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->on_begin, handle, inst, request,
(char *) NULL, 0);
/*
* CLEAR
*/
- sqlippool_command(inst->on_clear, sqlsocket, inst, request,
+ sqlippool_command(inst->on_clear, handle, inst, request,
(char *) NULL, 0);
/*
* COMMIT
*/
- sqlippool_command(inst->on_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->on_commit, handle, inst, request,
(char *) NULL, 0);
return RLM_MODULE_OK;
}
-static int sqlippool_accounting_off(SQLSOCK * sqlsocket,
+static int sqlippool_accounting_off(rlm_sql_handle_t * handle,
rlm_sqlippool_t *inst, REQUEST *request)
{
/*
* BEGIN
*/
- sqlippool_command(inst->off_begin, sqlsocket, inst, request,
+ sqlippool_command(inst->off_begin, handle, inst, request,
(char *) NULL, 0);
/*
* CLEAR
*/
- sqlippool_command(inst->off_clear, sqlsocket, inst, request,
+ sqlippool_command(inst->off_clear, handle, inst, request,
(char *) NULL, 0);
/*
* COMMIT
*/
- sqlippool_command(inst->off_commit, sqlsocket, inst, request,
+ sqlippool_command(inst->off_commit, handle, inst, request,
(char *) NULL, 0);
return RLM_MODULE_OK;
VALUE_PAIR * vp;
int acct_status_type;
rlm_sqlippool_t * inst = (rlm_sqlippool_t *) instance;
- SQLSOCK * sqlsocket;
+ rlm_sql_handle_t * handle;
vp = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY);
if (!vp) {
return RLM_MODULE_NOOP;
}
- sqlsocket = inst->sql_inst->sql_get_socket(inst->sql_inst);
- if (sqlsocket == NULL) {
+ handle = inst->sql_inst->sql_get_socket(inst->sql_inst);
+ if (handle == NULL) {
RDEBUG("cannot allocate sql connection");
return RLM_MODULE_NOOP;
}
switch (acct_status_type) {
case PW_STATUS_START:
- rcode = sqlippool_accounting_start(sqlsocket, inst, request);
+ rcode = sqlippool_accounting_start(handle, inst, request);
break;
case PW_STATUS_ALIVE:
- rcode = sqlippool_accounting_alive(sqlsocket, inst, request);
+ rcode = sqlippool_accounting_alive(handle, inst, request);
break;
case PW_STATUS_STOP:
- rcode = sqlippool_accounting_stop(sqlsocket, inst, request);
+ rcode = sqlippool_accounting_stop(handle, inst, request);
break;
case PW_STATUS_ACCOUNTING_ON:
- rcode = sqlippool_accounting_on(sqlsocket, inst, request);
+ rcode = sqlippool_accounting_on(handle, inst, request);
break;
case PW_STATUS_ACCOUNTING_OFF:
- rcode = sqlippool_accounting_off(sqlsocket, inst, request);
+ rcode = sqlippool_accounting_off(handle, inst, request);
break;
}
- inst->sql_inst->sql_release_socket(inst->sql_inst, sqlsocket);
+ inst->sql_inst->sql_release_socket(inst->sql_inst, handle);
return rcode;
}
projects / freeradius.git / commitdiff