From: Arran Cudbard-Bell Date: Fri, 1 Mar 2013 06:18:47 +0000 (-0500) Subject: Rename SQL data types so they don't conflict with drivers X-Git-Tag: debian/3.0.0git+dfsg+moonshot3-2~67 X-Git-Url: http://www.project-moonshot.org/gitweb/?p=freeradius.git;a=commitdiff_plain;h=6affdffd383ccd7e5b0faa8693204f3d9ed6a5af Rename SQL data types so they don't conflict with drivers --- diff --git a/src/modules/rlm_sql/drivers/rlm_sql_db2/rlm_sql_db2.c b/src/modules/rlm_sql/drivers/rlm_sql_db2/rlm_sql_db2.c index 4b5ec23..f327183 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_db2/rlm_sql_db2.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_db2/rlm_sql_db2.c @@ -52,19 +52,19 @@ typedef struct rlm_sql_db2_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) { 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 */ @@ -95,10 +95,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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; } @@ -109,12 +109,12 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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, @@ -139,9 +139,9 @@ static int sql_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *querystr) * 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); } @@ -153,7 +153,7 @@ static int sql_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *query * 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; } @@ -167,12 +167,12 @@ static int sql_store_result(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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; } @@ -182,25 +182,25 @@ static int sql_num_fields(SQLSOCK * sqlsocket, SQL_CONFIG *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) +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; } @@ -217,7 +217,7 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config) retval[i][0] = '\0'; } - sqlsocket->row = retval; + handle->row = retval; return 0; } @@ -229,10 +229,10 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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; } @@ -247,7 +247,7 @@ static int sql_free_result(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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 @@ -258,7 +258,7 @@ static char *sql_error(SQLSOCK * sqlsocket, SQL_CONFIG *config) 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); @@ -276,11 +276,11 @@ static char *sql_error(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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); @@ -295,7 +295,7 @@ static int sql_close(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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; } @@ -309,9 +309,9 @@ static int sql_finish_query(SQLSOCK * sqlsocket, SQL_CONFIG *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_finish_query(sqlsocket, config); + return sql_finish_query(handle, config); } @@ -322,12 +322,12 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *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; @@ -335,7 +335,7 @@ static int sql_affected_rows(SQLSOCK * sqlsocket, SQL_CONFIG *config) 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); diff --git a/src/modules/rlm_sql/drivers/rlm_sql_firebird/rlm_sql_firebird.c b/src/modules/rlm_sql/drivers/rlm_sql_firebird/rlm_sql_firebird.c index 6721717..935a2e6 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_firebird/rlm_sql_firebird.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_firebird/rlm_sql_firebird.c @@ -26,11 +26,11 @@ RCSID("$Id$") /* 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); /************************************************************************* * @@ -39,17 +39,17 @@ static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *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; @@ -70,10 +70,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -87,8 +87,8 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * *************************************************************************/ -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 @@ -138,9 +138,9 @@ TryAgain: * 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)); } @@ -153,7 +153,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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; } @@ -167,8 +167,8 @@ static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -180,8 +180,8 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -190,16 +190,16 @@ static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *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_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; @@ -210,7 +210,7 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { } else firebird_sock->statement_type=0; fb_store_row(firebird_sock); - sqlsocket->row = firebird_sock->row; + handle->row = firebird_sock->row; return 0; } @@ -222,8 +222,8 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; @@ -236,8 +236,8 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) { * 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; } @@ -249,7 +249,7 @@ static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -261,8 +261,8 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -274,8 +274,8 @@ static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } /************************************************************************* @@ -286,10 +286,10 @@ static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.c b/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.c index d8c6107..bf85808 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.c @@ -303,7 +303,7 @@ int fb_init_socket(rlm_sql_firebird_sock *sock) { 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; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.h b/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.h index 94f1389..c7df04c 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.h +++ b/src/modules/rlm_sql/drivers/rlm_sql_firebird/sql_fbapi.h @@ -53,7 +53,7 @@ typedef struct rlm_sql_firebird_sock { int dpb_len; char *lasterror; - SQL_ROW row; + rlm_sql_row_t row; int *row_sizes; int row_fcount; @@ -68,7 +68,7 @@ typedef struct rlm_sql_firebird_sock { 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); diff --git a/src/modules/rlm_sql/drivers/rlm_sql_freetds/rlm_sql_freetds.c b/src/modules/rlm_sql/drivers/rlm_sql_freetds/rlm_sql_freetds.c index 273f9d4..f9c6e9e 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_freetds/rlm_sql_freetds.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_freetds/rlm_sql_freetds.c @@ -65,14 +65,14 @@ static int err_handler(UNUSED DBPROCESS *dbproc, UNUSED int severity, UNUSED int * 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; } } @@ -89,7 +89,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) 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); @@ -134,10 +134,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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; } @@ -150,9 +150,9 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -180,7 +180,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) * 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; @@ -195,7 +195,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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; @@ -210,9 +210,9 @@ static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config * 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); } @@ -226,7 +226,7 @@ static int sql_num_fields(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; @@ -236,12 +236,12 @@ static int sql_num_rows(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *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(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; } @@ -255,7 +255,7 @@ static int sql_fetch_row(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; @@ -270,7 +270,7 @@ static int sql_free_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -284,9 +284,9 @@ static const char *sql_error(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *confi * 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); @@ -304,7 +304,7 @@ static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; @@ -318,9 +318,9 @@ static int sql_finish_query(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *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_finish_query(sqlsocket, config); + return sql_finish_query(handle, config); } @@ -331,9 +331,9 @@ static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *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); } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_iodbc/rlm_sql_iodbc.c b/src/modules/rlm_sql/drivers/rlm_sql_iodbc/rlm_sql_iodbc.c index d0fc690..04b86de 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_iodbc/rlm_sql_iodbc.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_iodbc/rlm_sql_iodbc.c @@ -39,15 +39,15 @@ typedef struct rlm_sql_iodbc_sock { 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); /************************************************************************* * @@ -56,24 +56,24 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *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; } @@ -81,7 +81,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { &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; } @@ -90,7 +90,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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; } @@ -104,10 +104,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -119,16 +119,16 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -140,7 +140,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } @@ -155,19 +155,19 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { * 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))); @@ -207,7 +207,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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; } @@ -221,10 +221,10 @@ static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config * 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); @@ -239,7 +239,7 @@ static int sql_num_fields(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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 @@ -254,24 +254,24 @@ static int sql_num_rows(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *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, 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; } @@ -285,12 +285,12 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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; irow[i]); } free(iodbc_sock->row); @@ -310,13 +310,13 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); @@ -332,9 +332,9 @@ static const char *sql_error(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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); @@ -356,9 +356,9 @@ static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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); } @@ -370,8 +370,8 @@ static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *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); } @@ -383,10 +383,10 @@ static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *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; diff --git a/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c b/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c index d916f3a..8e4e275 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_mysql/rlm_sql_mysql.c @@ -49,11 +49,11 @@ typedef struct rlm_sql_mysql_sock { 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*); /************************************************************************* * @@ -62,18 +62,18 @@ static int sql_free_result(SQLSOCK*, SQL_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_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"); @@ -136,10 +136,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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; } @@ -182,10 +182,10 @@ static int sql_check_error(int error) * 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"); @@ -206,9 +206,9 @@ static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, * 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) { @@ -249,10 +249,10 @@ retry_store_result: * 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))) { @@ -274,15 +274,15 @@ static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -291,7 +291,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, * 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; } @@ -305,9 +305,9 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, * 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); @@ -320,14 +320,14 @@ static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *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, 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; /* @@ -338,9 +338,9 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) } 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"); @@ -349,11 +349,11 @@ retry_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) { @@ -376,9 +376,9 @@ retry_fetch_row: * 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); @@ -398,9 +398,9 @@ static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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"; @@ -417,9 +417,9 @@ static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -439,19 +439,19 @@ static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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) { @@ -476,18 +476,18 @@ skip_next_result: * 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'", @@ -506,9 +506,9 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *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_mysql_sock *mysql_sock = sqlsocket->conn; + rlm_sql_mysql_sock *mysql_sock = handle->conn; return mysql_affected_rows(mysql_sock->sock); } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_null/rlm_sql_null.c b/src/modules/rlm_sql/drivers/rlm_sql_null/rlm_sql_null.c index 2667373..dc792ce 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_null/rlm_sql_null.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_null/rlm_sql_null.c @@ -29,7 +29,7 @@ RCSID("$Id$") /* 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"; @@ -40,9 +40,9 @@ 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; } @@ -53,9 +53,9 @@ static int sql_init_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -68,7 +68,7 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -83,7 +83,7 @@ static int sql_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, UNUS * 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; } @@ -97,7 +97,7 @@ static int sql_store_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *confi * 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; } @@ -110,7 +110,7 @@ static int sql_num_fields(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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; @@ -125,7 +125,7 @@ static int sql_select_query(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config * 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; } @@ -135,12 +135,12 @@ static int sql_num_rows(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *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(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; } @@ -154,7 +154,7 @@ static int sql_fetch_row(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -169,7 +169,7 @@ static int sql_free_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config * 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"; } @@ -183,9 +183,9 @@ static const char *sql_error(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *conf * 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; } @@ -199,7 +199,7 @@ static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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; } @@ -213,7 +213,7 @@ static int sql_finish_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *confi * 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; } @@ -226,7 +226,7 @@ static int sql_finish_select_query(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG * 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; } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c b/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c index a93d76f..1338a25 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_oracle/rlm_sql_oracle.c @@ -52,11 +52,11 @@ typedef struct rlm_sql_oracle_sock { * 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"; @@ -79,10 +79,10 @@ static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -100,9 +100,9 @@ static int sql_check_error(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); @@ -120,7 +120,7 @@ static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) { oracle_sock->conn = NULL; free(oracle_sock); - sqlsocket->conn = NULL; + handle->conn = NULL; return 0; } @@ -133,19 +133,19 @@ static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *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_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, @@ -168,7 +168,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { (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; } @@ -178,8 +178,8 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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; } @@ -194,10 +194,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -209,10 +209,10 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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, @@ -222,7 +222,7 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) { (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; @@ -236,10 +236,10 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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"); @@ -249,7 +249,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } @@ -268,8 +268,8 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; @@ -284,7 +284,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { * 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; @@ -295,7 +295,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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"); @@ -305,7 +305,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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; } @@ -326,8 +326,8 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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); } /* @@ -337,7 +337,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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); */ @@ -357,7 +357,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys (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; } @@ -366,7 +366,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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; } @@ -392,7 +392,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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); @@ -432,7 +432,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys */ 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; } } @@ -452,7 +452,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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; } @@ -466,10 +466,10 @@ static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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, @@ -486,22 +486,22 @@ static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *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) { +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, @@ -510,14 +510,14 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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; @@ -534,12 +534,12 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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, @@ -548,7 +548,7 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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]); @@ -569,7 +569,7 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -583,10 +583,10 @@ static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *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) { 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++]); @@ -607,9 +607,9 @@ static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c index 42b5180..9c4b818 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_postgresql/rlm_sql_postgresql.c @@ -58,7 +58,7 @@ typedef struct rlm_sql_postgres_sock { } 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 @@ -141,7 +141,7 @@ static int check_fatal_error (char *errorcode) * 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; @@ -168,14 +168,14 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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), @@ -190,7 +190,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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; } @@ -204,10 +204,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; @@ -305,15 +305,15 @@ static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, /* 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; @@ -331,8 +331,8 @@ static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, * 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); } @@ -343,10 +343,10 @@ static int sql_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *query * 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; } @@ -354,17 +354,17 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *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, 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; @@ -385,7 +385,7 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) { 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; @@ -399,9 +399,9 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) { * 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) @@ -420,9 +420,9 @@ static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -444,9 +444,9 @@ static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) { * 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); } @@ -460,9 +460,9 @@ static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) { * 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; @@ -481,9 +481,9 @@ static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) { * 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); } @@ -495,9 +495,9 @@ static int sql_finish_query(SQLSOCK * sqlsocket, SQL_CONFIG *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); } @@ -508,15 +508,15 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *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); diff --git a/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c b/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c index e953fea..6d92f40 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_sqlite/rlm_sql_sqlite.c @@ -45,20 +45,20 @@ typedef struct rlm_sql_sqlite_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) { 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; @@ -83,10 +83,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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); @@ -107,11 +107,11 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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) { @@ -134,10 +134,10 @@ static int sql_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config, * 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); } @@ -149,7 +149,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, * 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; } @@ -163,9 +163,9 @@ static int sql_store_result(UNUSED SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *confi * 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); @@ -182,9 +182,9 @@ static int sql_num_fields(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -196,9 +196,9 @@ static int sql_num_rows(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) /************************************************************************* * 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) { @@ -208,8 +208,8 @@ static void sql_free_rowdata(SQLSOCK * sqlsocket, int colcount) rowdata[colindex] = NULL; } } - free(sqlsocket->row); - sqlsocket->row = NULL; + free(handle->row); + handle->row = NULL; } } @@ -218,15 +218,15 @@ static void sql_free_rowdata(SQLSOCK * sqlsocket, int colcount) * * 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; @@ -242,24 +242,24 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config) 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++) @@ -310,13 +310,13 @@ static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config) * 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); @@ -334,9 +334,9 @@ static int sql_free_result(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -355,10 +355,10 @@ static const char *sql_error(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -376,10 +376,10 @@ static int sql_close(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *config) * 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); @@ -398,9 +398,9 @@ static int sql_finish_query(SQLSOCK * sqlsocket, UNUSED SQL_CONFIG *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_finish_query(sqlsocket, config); + return sql_finish_query(handle, config); } @@ -412,11 +412,11 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *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); diff --git a/src/modules/rlm_sql/drivers/rlm_sql_sybase/rlm_sql_sybase.c b/src/modules/rlm_sql/drivers/rlm_sql_sybase/rlm_sql_sybase.c index db9e65c..c9a3381 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_sybase/rlm_sql_sybase.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_sybase/rlm_sql_sybase.c @@ -169,12 +169,12 @@ CS_SERVERMSG *msgp; * 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; @@ -241,18 +241,18 @@ static const char *sql_error(SQLSOCK *sqlsocket, SQL_CONFIG *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_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; @@ -333,7 +333,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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); @@ -344,7 +344,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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); @@ -356,7 +356,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { 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); @@ -374,10 +374,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -389,7 +389,7 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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; } @@ -401,9 +401,9 @@ static int sql_close(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; @@ -415,19 +415,19 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } @@ -448,7 +448,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } } @@ -458,18 +458,18 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } } @@ -484,7 +484,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } } @@ -494,18 +494,18 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } } @@ -524,11 +524,11 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; @@ -538,7 +538,7 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { 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; } @@ -553,14 +553,14 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { * 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; @@ -573,9 +573,9 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *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) { - 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); @@ -606,9 +606,9 @@ static int sql_finish_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; @@ -625,19 +625,19 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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; } @@ -673,7 +673,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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 */ @@ -686,7 +686,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys /* 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; } @@ -704,8 +704,8 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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; } @@ -719,11 +719,11 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys */ 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; @@ -731,7 +731,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys 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; } @@ -747,7 +747,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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 @@ -766,14 +766,14 @@ static int sql_store_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; @@ -784,17 +784,17 @@ static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *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'. * *************************************************************************/ -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); @@ -809,11 +809,11 @@ int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { */ 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; @@ -825,7 +825,7 @@ int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { case CS_SUCCEED: - sqlsocket->row = sybase_sock->results; + handle->row = sybase_sock->results; return 0; break; @@ -853,7 +853,7 @@ int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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 @@ -871,9 +871,9 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); @@ -893,9 +893,9 @@ static int sql_finish_query(SQLSOCK *sqlsocket, SQL_CONFIG *config) * 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); } diff --git a/src/modules/rlm_sql/drivers/rlm_sql_unixodbc/rlm_sql_unixodbc.c b/src/modules/rlm_sql/drivers/rlm_sql_unixodbc/rlm_sql_unixodbc.c index d408b25..6559cfb 100644 --- a/src/modules/rlm_sql/drivers/rlm_sql_unixodbc/rlm_sql_unixodbc.c +++ b/src/modules/rlm_sql/drivers/rlm_sql_unixodbc/rlm_sql_unixodbc.c @@ -31,7 +31,7 @@ typedef struct rlm_sql_unixodbc_sock { SQLHENV env_handle; SQLHDBC dbc_handle; SQLHSTMT stmt_handle; - SQL_ROW row; + rlm_sql_row_t row; void *conn; } rlm_sql_unixodbc_sock; @@ -40,11 +40,11 @@ typedef struct rlm_sql_unixodbc_sock { #include /* 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); /************************************************************************* @@ -54,28 +54,28 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *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); @@ -83,7 +83,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { } /* 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); @@ -95,7 +95,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { (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); @@ -105,7 +105,7 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { /* 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; @@ -122,10 +122,10 @@ static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -138,14 +138,14 @@ static int sql_destroy_socket(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) * 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; @@ -161,18 +161,18 @@ static int sql_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querystr) { * 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; @@ -197,7 +197,7 @@ static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config, char *querys * 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; } @@ -211,13 +211,13 @@ static int sql_store_result(UNUSED SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config * 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; @@ -232,8 +232,8 @@ static int sql_num_fields(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); } @@ -241,27 +241,27 @@ static int sql_num_rows(SQLSOCK *sqlsocket, SQL_CONFIG *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; } @@ -273,10 +273,10 @@ static int sql_fetch_row(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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; } @@ -288,8 +288,8 @@ static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config) { * 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; @@ -303,9 +303,9 @@ static int sql_finish_query(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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) { @@ -329,8 +329,8 @@ static int sql_free_result(SQLSOCK *sqlsocket, SQL_CONFIG *config) { * 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); @@ -348,14 +348,14 @@ static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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'; @@ -382,14 +382,14 @@ static const char *sql_error(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config) { * 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 */ @@ -435,13 +435,13 @@ static int sql_state(long err_handle, SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *con * 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; diff --git a/src/modules/rlm_sql/rlm_sql.c b/src/modules/rlm_sql/rlm_sql.c index bba5e24..6dd6c19 100644 --- a/src/modules/rlm_sql/rlm_sql.c +++ b/src/modules/rlm_sql/rlm_sql.c @@ -48,59 +48,59 @@ static const CONF_PARSER acct_section_config[] = { 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} }; @@ -119,7 +119,7 @@ static int fallthrough(VALUE_PAIR *vp) /* * 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); /* @@ -132,9 +132,9 @@ static size_t sql_escape_func(REQUEST *, char *out, size_t outlen, const char *i 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; @@ -155,8 +155,8 @@ static size_t sql_xlat(void *instance, REQUEST *request, 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); @@ -171,13 +171,13 @@ static size_t sql_xlat(void *instance, REQUEST *request, 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", @@ -197,51 +197,51 @@ static size_t sql_xlat(void *instance, REQUEST *request, 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; } @@ -249,15 +249,15 @@ static size_t sql_xlat(void *instance, REQUEST *request, 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; @@ -272,16 +272,16 @@ static int generate_sql_clients(SQL_INST *inst) 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; /* @@ -371,14 +371,14 @@ static int generate_sql_clients(SQL_INST *inst) 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 : ""); 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); @@ -386,8 +386,8 @@ static int generate_sql_clients(SQL_INST *inst) 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; } @@ -399,7 +399,7 @@ static int generate_sql_clients(SQL_INST *inst) 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]) { @@ -452,7 +452,7 @@ static size_t sql_escape_func(UNUSED REQUEST *request, char *out, size_t outlen, * 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; @@ -485,9 +485,9 @@ int sql_set_user(SQL_INST *inst, REQUEST *request, const char *username) } -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; @@ -497,12 +497,12 @@ static void sql_grouplist_free (SQL_GROUPLIST **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 */ @@ -518,32 +518,32 @@ static int sql_get_grouplist (SQL_INST *inst, SQLSOCK *sqlsocket, REQUEST *reque 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; } @@ -559,9 +559,9 @@ static int sql_get_grouplist (SQL_INST *inst, SQLSOCK *sqlsocket, REQUEST *reque 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; @@ -585,18 +585,18 @@ static int sql_groupcmp(void *instance, REQUEST *request, VALUE_PAIR *request_vp /* * 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; } @@ -606,14 +606,14 @@ static int sql_groupcmp(void *instance, REQUEST *request, VALUE_PAIR *request_vp 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); @@ -623,11 +623,11 @@ static int sql_groupcmp(void *instance, REQUEST *request, VALUE_PAIR *request_vp -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; @@ -636,7 +636,7 @@ static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sql /* * 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; } @@ -662,7 +662,7 @@ static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sql 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); @@ -690,7 +690,7 @@ static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sql 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 */ @@ -725,7 +725,7 @@ static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sql 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 */ @@ -756,7 +756,7 @@ static int rlm_sql_process_groups(SQL_INST *inst, REQUEST *request, SQLSOCK *sql static int rlm_sql_detach(void *instance) { - SQL_INST *inst = instance; + rlm_sql_t *inst = instance; paircompare_unregister(PW_SQL_GROUP, sql_groupcmp); @@ -781,7 +781,7 @@ static int rlm_sql_detach(void *instance) } static int parse_sub_section(CONF_SECTION *parent, - SQL_INST *inst, + rlm_sql_t *inst, sql_acct_section_t **config, rlm_components_t comp) { @@ -813,10 +813,10 @@ static int parse_sub_section(CONF_SECTION *parent, 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; /* @@ -837,7 +837,7 @@ static int rlm_sql_instantiate(CONF_SECTION *conf, void **instance) 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); @@ -967,8 +967,8 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) { 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; @@ -991,8 +991,8 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) * 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; /* @@ -1007,7 +1007,7 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) 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"); @@ -1045,7 +1045,7 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) 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"); @@ -1077,7 +1077,7 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) * 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"); @@ -1112,7 +1112,7 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) 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"); @@ -1129,7 +1129,7 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) ret = RLM_MODULE_FAIL; release: - sql_release_socket(inst, sqlsocket); + sql_release_socket(inst, handle); pairfree(&check_tmp); pairfree(&reply_tmp); @@ -1147,12 +1147,12 @@ static rlm_rcode_t rlm_sql_authorize(void *instance, REQUEST * request) * 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; @@ -1190,8 +1190,8 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request, 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); @@ -1225,11 +1225,11 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request, * 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 @@ -1237,14 +1237,14 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request, */ 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 @@ -1263,10 +1263,10 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request, 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; } @@ -1277,7 +1277,7 @@ static int acct_redundant(SQL_INST *inst, REQUEST *request, * 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); @@ -1299,9 +1299,9 @@ static rlm_rcode_t rlm_sql_accounting(void *instance, REQUEST * request) { */ 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; @@ -1330,34 +1330,34 @@ static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) { 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; } @@ -1367,13 +1367,13 @@ static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) { */ 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; } @@ -1388,19 +1388,19 @@ static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) { 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; } @@ -1455,15 +1455,15 @@ static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) { * 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, @@ -1478,7 +1478,7 @@ static rlm_rcode_t rlm_sql_checksimul(void *instance, REQUEST * request) { * 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); diff --git a/src/modules/rlm_sql/rlm_sql.h b/src/modules/rlm_sql/rlm_sql.h index acff410..486462f 100644 --- a/src/modules/rlm_sql/rlm_sql.h +++ b/src/modules/rlm_sql/rlm_sql.h @@ -1,9 +1,9 @@ /*************************************************************************** -* rlm_sql.h rlm_sql - FreeRADIUS SQL Module * -* * -* Header for main SQL module file * -* * -* Mike Machado * +* rlm_sql.h rlm_sql - FreeRADIUS SQL Module * +* * +* Header for main SQL module file * +* * +* Mike Machado * ***************************************************************************/ #ifndef _RLM_SQL_H #define _RLM_SQL_H @@ -19,18 +19,18 @@ RCSIDH(rlm_sql_h, "$Id$") #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 { @@ -42,7 +42,7 @@ 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; @@ -64,85 +64,84 @@ typedef struct sql_config { 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 diff --git a/src/modules/rlm_sql/sql.c b/src/modules/rlm_sql/sql.c index cea9bc9..ba35d14 100644 --- a/src/modules/rlm_sql/sql.c +++ b/src/modules/rlm_sql/sql.c @@ -43,38 +43,38 @@ RCSID("$Id$") 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; } @@ -87,7 +87,7 @@ static int sql_conn_delete(void *ctx, void *connection) * 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, @@ -105,7 +105,7 @@ int sql_init_socketpool(SQL_INST * inst) * 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); } @@ -115,10 +115,10 @@ void sql_poolfree(SQL_INST * inst) * * 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); } @@ -127,12 +127,12 @@ SQLSOCK * sql_get_socket(SQL_INST * inst) * * 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; } @@ -144,7 +144,7 @@ int sql_release_socket(SQL_INST * inst, SQLSOCK * sqlsocket) * 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; @@ -254,11 +254,11 @@ int sql_userparse(VALUE_PAIR **head, SQL_ROW row) * 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; } @@ -267,11 +267,11 @@ int rlm_sql_fetch_row(SQLSOCK **sqlsocket, SQL_INST *inst) * 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; @@ -284,7 +284,7 @@ int rlm_sql_fetch_row(SQLSOCK **sqlsocket, SQL_INST *inst) * 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; @@ -295,7 +295,7 @@ int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) return -1; } - if (!*sqlsocket || !(*sqlsocket)->conn) { + if (!*handle || !(*handle)->conn) { ret = -1; goto sql_down; } @@ -304,15 +304,15 @@ int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) 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; } @@ -321,7 +321,7 @@ int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) 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; @@ -335,7 +335,7 @@ int rlm_sql_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) * 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; @@ -346,7 +346,7 @@ int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) return -1; } - if (!*sqlsocket || !(*sqlsocket)->conn) { + if (!*handle || !(*handle)->conn) { ret = -1; goto sql_down; } @@ -355,15 +355,15 @@ int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) 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; } @@ -372,7 +372,7 @@ int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) 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; @@ -387,28 +387,28 @@ int rlm_sql_select_query(SQLSOCK **sqlsocket, SQL_INST *inst, char *query) * 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; } @@ -416,7 +416,7 @@ int sql_getvpdata(SQL_INST * inst, SQLSOCK **sqlsocket, VALUE_PAIR **pair, char /* * 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; diff --git a/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c b/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c index 382210d..2808f5c 100644 --- a/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c +++ b/src/modules/rlm_sqlhpwippool/rlm_sqlhpwippool.c @@ -51,7 +51,7 @@ static const char rcsid[] = "$Id$"; 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 */ @@ -103,7 +103,7 @@ static int nvp_log(unsigned int line, rlm_sqlhpwippool_t *data, int lvl, } /* 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]; @@ -120,7 +120,7 @@ static int nvp_vquery(unsigned int line, rlm_sqlhpwippool_t *data, /* 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; @@ -133,7 +133,7 @@ static int nvp_query(unsigned int line, rlm_sqlhpwippool_t *data, } /* 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); } @@ -143,7 +143,7 @@ static int nvp_finish(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock) * 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; @@ -177,14 +177,14 @@ static int nvp_select(unsigned int line, rlm_sqlhpwippool_t *data, 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` " @@ -206,7 +206,7 @@ static int nvp_freeclosed(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock) } /* 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` " @@ -231,7 +231,7 @@ static int nvp_syncfree(rlm_sqlhpwippool_t *data, SQLSOCK *sqlsock) /* 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); @@ -323,7 +323,7 @@ static int sqlhpwippool_instantiate(CONF_SECTION *conf, void **instance) } /* 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); @@ -336,7 +336,7 @@ static rlm_rcode_t sqlhpwippool_postauth(void *instance, REQUEST *request) 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 */ @@ -652,7 +652,7 @@ end_gid: 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 */ diff --git a/src/modules/rlm_sqlippool/rlm_sqlippool.c b/src/modules/rlm_sqlippool/rlm_sqlippool.c index f1446ac..3f6cbbf 100644 --- a/src/modules/rlm_sqlippool/rlm_sqlippool.c +++ b/src/modules/rlm_sqlippool/rlm_sqlippool.c @@ -39,7 +39,7 @@ typedef struct rlm_sqlippool_t { int lease_duration; - SQL_INST *sql_inst; + rlm_sql_t *sql_inst; char *pool_name; @@ -293,7 +293,7 @@ static int sqlippool_expand(char * out, int outlen, const char * fmt, /* * 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) { @@ -318,12 +318,12 @@ static int sqlippool_command(const char * fmt, SQLSOCK * sqlsocket, #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; } @@ -332,7 +332,7 @@ static int sqlippool_command(const char * fmt, SQLSOCK * sqlsocket, * 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]; @@ -356,7 +356,7 @@ static int sqlippool_query1(char * out, int outlen, const char * fmt, 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; @@ -364,11 +364,11 @@ static int sqlippool_query1(char * out, int outlen, const char * fmt, 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"); @@ -383,7 +383,7 @@ static int sqlippool_query1(char * out, int outlen, const char * fmt, 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; } @@ -488,7 +488,7 @@ static int sqlippool_instantiate(CONF_SECTION *conf, void **instance) return -1; } - inst->sql_inst = (SQL_INST *) sqlinst->insthandle; + inst->sql_inst = (rlm_sql_t *) sqlinst->insthandle; return 0; } @@ -515,7 +515,7 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) 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]; @@ -539,8 +539,8 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) 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; } @@ -552,20 +552,20 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) /* * 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); /* @@ -575,7 +575,7 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) /* * COMMIT */ - sqlippool_command(inst->allocate_commit, sqlsocket, instance, + sqlippool_command(inst->allocate_commit, handle, instance, request, (char *) NULL, 0); /* @@ -588,10 +588,10 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) * 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) { @@ -620,7 +620,7 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) } - 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, @@ -638,11 +638,11 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) /* * 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); @@ -652,7 +652,7 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) /* * 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); @@ -664,64 +664,64 @@ static rlm_rcode_t sqlippool_postauth(void *instance, REQUEST * request) /* * 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]; @@ -729,19 +729,19 @@ static int sqlippool_accounting_stop(SQLSOCK * sqlsocket, /* * 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); @@ -749,49 +749,49 @@ static int sqlippool_accounting_stop(SQLSOCK * sqlsocket, 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; @@ -808,7 +808,7 @@ static rlm_rcode_t sqlippool_accounting(void * instance, REQUEST * request) 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) { @@ -830,8 +830,8 @@ static rlm_rcode_t sqlippool_accounting(void * instance, REQUEST * request) 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; } @@ -842,27 +842,27 @@ static rlm_rcode_t sqlippool_accounting(void * instance, REQUEST * request) 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; }