Change function signature of SQL driver sql_fetch_row() to unlang_function_t

diff --git a/src/modules/rlm_sql/drivers/rlm_sql_cassandra/rlm_sql_cassandra.c b/src/modules/rlm_sql/drivers/rlm_sql_cassandra/rlm_sql_cassandra.c
index eeb6f95968968e01e0c5eff4a7b41dc39e0a9b81..dea051ae847538d8eb2c31fc5161a8093671fcb5 100644 (file)
--- a/src/modules/rlm_sql/drivers/rlm_sql_cassandra/rlm_sql_cassandra.c
+++ b/src/modules/rlm_sql/drivers/rlm_sql_cassandra/rlm_sql_cassandra.c
@@ -518,13 +518,14 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
-
-       rlm_sql_cassandra_conn_t        *conn = handle->conn;
+       fr_sql_query_t                  *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_cassandra_conn_t        *conn = query_ctx->handle->conn;
        CassRow const                   *cass_row;
        int                             fields, i;
        char                            **row;
+       rlm_sql_handle_t                *handle = query_ctx->handle;
 
 #define RLM_CASS_ERR_DATA_RETRIVE(_t) \
 do {\
@@ -537,21 +538,26 @@ do {\
        sql_set_last_error_printf(conn, "Failed to retrieve " _t " data at column %s (%d): %s", \
                                  _col_name, i, cass_error_desc(_ret));\
        TALLOC_FREE(handle->row);\
-       return RLM_SQL_ERROR;\
+       query_ctx->rcode = RLM_SQL_ERROR;\
+       RETURN_MODULE_FAIL;\
 } while(0)
 
-       if (!conn->result) return RLM_SQL_OK;                           /* no result */
+       query_ctx->rcode = RLM_SQL_OK;
+       if (!conn->result) RETURN_MODULE_OK;                            /* no result */
 
        /*
         *      Start of the result set, initialise the iterator.
         */
        if (!conn->iterator) conn->iterator = cass_iterator_from_result(conn->result);
-       if (!conn->iterator) return RLM_SQL_OK;                         /* no result */
+       if (!conn->iterator) RETURN_MODULE_OK;                          /* no result */
 
-       if (!cass_iterator_next(conn->iterator)) return RLM_SQL_NO_MORE_ROWS;   /* no more rows */
+       if (!cass_iterator_next(conn->iterator)) {
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;                /* no more rows */
+               RETURN_MODULE_OK;
+       }
 
        cass_row = cass_iterator_get_row(conn->iterator);               /* this shouldn't fail ? */
-       fields = sql_num_fields(handle, config);                        /* get the number of fields... */
+       fields = sql_num_fields(handle, &query_ctx->inst->config);      /* get the number of fields... */
 
        /*
         *      Free the previous result (also gets called on finish_query)
@@ -639,12 +645,13 @@ do {\
                                                  "Failed to retrieve data at column %s (%d): Unsupported data type",
                                                  col_name, i);
                        talloc_free(handle->row);
-                       return RLM_SQL_ERROR;
+                       query_ctx->rcode = RLM_SQL_ERROR;
+                       RETURN_MODULE_FAIL;
                }
                }
        }
 
-       return RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)

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 629aae4b5ef3fa764a676184581bbcf9af1b0fe2..85ab3bbfde2e6497a9332718c5a9e06503a1e2d9 100644 (file)
--- 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
@@ -183,12 +183,14 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUS
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
        int                     c, i;
        SQLINTEGER              len, slen;
        rlm_sql_row_t           row;
        rlm_sql_db2_conn_t      *conn;
+       rlm_sql_handle_t        *handle = query_ctx->handle;
 
        TALLOC_FREE(handle->row);
 
@@ -196,7 +198,10 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
        c = sql_num_fields(handle, config);
 
        /* advance cursor */
-       if (SQLFetch(conn->stmt) == SQL_NO_DATA_FOUND) return RLM_SQL_NO_MORE_ROWS;
+       if (SQLFetch(conn->stmt) == SQL_NO_DATA_FOUND) {
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
+       }
 
        MEM(row = (rlm_sql_row_t)talloc_zero_array(handle, char *, c + 1));
        for (i = 0; i < c; i++) {
@@ -212,7 +217,8 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
 
        handle->row = row;
 
-       return RLM_SQL_OK;
+       query_ctx->rcode = RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)

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 a18a3c36353e74df287703ac4040a4987231a3b6..30206b080c15c4db9aa71409c22a32ac4ca7a76e 100644 (file)
--- 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
@@ -198,8 +198,10 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUS
 /** Returns an individual row.
  *
  */
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
        rlm_sql_firebird_conn_t *conn = handle->conn;
        int res;
 
@@ -207,12 +209,16 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config
 
        if (conn->statement_type != isc_info_sql_stmt_exec_procedure) {
                res = fb_fetch(conn);
-               if (res == 100) return RLM_SQL_NO_MORE_ROWS;
+               if (res == 100) {
+                       query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+                       RETURN_MODULE_OK;
+               }
 
                if (res) {
                        ERROR("Fetch problem: %s", conn->error);
 
-                       return RLM_SQL_ERROR;
+                       query_ctx->rcode = RLM_SQL_ERROR;
+                       RETURN_MODULE_FAIL;
                }
        } else {
                conn->statement_type = 0;
@@ -222,7 +228,8 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config
 
        handle->row = conn->row;
 
-       return RLM_SQL_OK;
+       query_ctx->rcode = RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 /** End the select query, such as freeing memory or result.

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 496354520578f73e5b4d8d886daa3789e1b7a9c4..0d4367da5e2c84fd90af1c936d83f82393623261 100644 (file)
--- 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
@@ -585,8 +585,10 @@ static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const
        return (conn->rows_affected);
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
        rlm_sql_freetds_conn_t *conn = handle->conn;
        CS_INT ret, count;
 
@@ -605,25 +607,30 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config
                        conn->command = NULL;
                }
 
-               return RLM_SQL_RECONNECT;
+               query_ctx->rcode = RLM_SQL_RECONNECT;
+               RETURN_MODULE_FAIL;
 
        case CS_END_DATA:
-               return RLM_SQL_NO_MORE_ROWS;
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
 
        case CS_SUCCEED:
                handle->row = conn->results;
 
-               return RLM_SQL_OK;
+               query_ctx->rcode = RLM_SQL_OK;
+               RETURN_MODULE_OK;
 
        case CS_ROW_FAIL:
                ERROR("recoverable failure fetching row data");
 
-               return RLM_SQL_RECONNECT;
+               query_ctx->rcode = RLM_SQL_RECONNECT;
+               RETURN_MODULE_FAIL;
 
        default:
                ERROR("unexpected returncode from ct_fetch");
 
-               return RLM_SQL_ERROR;
+               query_ctx->rcode = RLM_SQL_ERROR;
+               RETURN_MODULE_FAIL;
        }
 }
 

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 ad8e0635ccc40eacf434d9e06b8278bd741e401f..296f9e157cbb3edf9a252315abce6c99df993183 100644 (file)
--- 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
@@ -487,10 +487,11 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, rlm_
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
        rlm_sql_mysql_conn_t    *conn = talloc_get_type_abort(handle->conn, rlm_sql_mysql_conn_t);
-       sql_rcode_t             rcode;
        MYSQL_ROW               row;
        int                     ret;
        unsigned int            num_fields, i;
@@ -499,32 +500,43 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
        /*
         *  Check pointer before de-referencing it.
         */
-       if (!conn->result) return RLM_SQL_RECONNECT;
+       if (!conn->result) {
+               query_ctx->rcode = RLM_SQL_RECONNECT;
+               RETURN_MODULE_FAIL;
+       }
 
        TALLOC_FREE(handle->row);               /* Clear previous row set */
 
 retry_fetch_row:
        row = mysql_fetch_row(conn->result);
        if (!row) {
-               rcode = sql_check_error(conn->sock, 0);
-               if (rcode != RLM_SQL_OK) return rcode;
+               query_ctx->rcode = sql_check_error(conn->sock, 0);
+               if (query_ctx->rcode != RLM_SQL_OK) RETURN_MODULE_FAIL;
 
-               sql_free_result(handle, config);
+               sql_free_result(handle, &query_ctx->inst->config);
 
                ret = mysql_next_result(conn->sock);
                if (ret == 0) {
                        /* there are more results */
-                       if ((sql_store_result(handle, config) == 0) && (conn->result != NULL)) {
+                       if ((sql_store_result(handle, &query_ctx->inst->config) == 0) && (conn->result != NULL)) {
                                goto retry_fetch_row;
                        }
-               } else if (ret > 0) return sql_check_error(NULL, ret);
+               } else if (ret > 0) {
+                       query_ctx->rcode = sql_check_error(NULL, ret);
+                       if (query_ctx->rcode == RLM_SQL_OK) RETURN_MODULE_OK;
+                       RETURN_MODULE_FAIL;
+               }
                /* If ret is -1 then there are no more rows */
 
-               return RLM_SQL_NO_MORE_ROWS;
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
        }
 
        num_fields = mysql_num_fields(conn->result);
-       if (!num_fields) return RLM_SQL_NO_MORE_ROWS;
+       if (!num_fields) {
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
+       }
 
        field_lens = mysql_fetch_lengths(conn->result);
 
@@ -533,7 +545,8 @@ retry_fetch_row:
                MEM(handle->row[i] = talloc_bstrndup(handle->row, row[i], field_lens[i]));
        }
 
-       return RLM_SQL_OK;
+       query_ctx->rcode = RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)

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 369f1dc65b0544314e8c70f795bdcb73b6f3a992..649ec951d6624da00c458278f7bc587453c11acf 100644 (file)
--- 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
@@ -53,11 +53,12 @@ static int sql_num_rows(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_
        return 0;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle,
-                                UNUSED rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
-       handle->row = NULL;
-       return RLM_SQL_NO_MORE_ROWS;
+       fr_sql_query_t  *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       query_ctx->handle->row = NULL;
+       query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_free_result(UNUSED rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)

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 f676888e4fb819e599d102e69eb231f188b834a0..2f15d1f1ccb860b2399374280eb6bce68a968c44 100644 (file)
--- 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
@@ -250,7 +250,7 @@ static int mod_instantiate(module_inst_ctx_t const *mctx)
        return 0;
 }
 
-static int sql_check_reconnect(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static sql_rcode_t sql_check_reconnect(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
 {
        char errbuff[512];
 
@@ -261,7 +261,7 @@ static int sql_check_reconnect(rlm_sql_handle_t *handle, rlm_sql_config_t const
                return RLM_SQL_RECONNECT;
        }
 
-       return -1;
+       return RLM_SQL_ERROR;
 }
 
 static int _sql_socket_destructor(rlm_sql_oracle_conn_t *conn)
@@ -546,15 +546,18 @@ static int sql_num_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const
        return rows;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
-       int status;
-       rlm_sql_oracle_conn_t *conn = handle->conn;
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       int                     status;
+       rlm_sql_handle_t        *handle = query_ctx->handle;
+       rlm_sql_oracle_conn_t   *conn = handle->conn;
 
        if (!conn->ctx) {
                ERROR("Socket not connected");
 
-               return RLM_SQL_RECONNECT;
+               query_ctx->rcode = RLM_SQL_RECONNECT;
+               RETURN_MODULE_FAIL;
        }
 
        handle->row = NULL;
@@ -563,19 +566,23 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
        if (status == OCI_SUCCESS) {
                handle->row = conn->row;
 
-               return RLM_SQL_OK;
+               query_ctx->rcode = RLM_SQL_OK;
+               RETURN_MODULE_OK;
        }
 
        if (status == OCI_NO_DATA) {
-               return RLM_SQL_NO_MORE_ROWS;
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
        }
 
        if (status == OCI_ERROR) {
                ERROR("fetch failed in sql_fetch_row");
-               return sql_check_reconnect(handle, config);
+               query_ctx->rcode = sql_check_reconnect(handle, &query_ctx->inst->config);
+               RETURN_MODULE_FAIL;
        }
 
-       return RLM_SQL_ERROR;
+       query_ctx->rcode = RLM_SQL_ERROR;
+       RETURN_MODULE_FAIL;
 }
 
 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *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 076c36a3bf005b31acefd85776ec0c7d0a6974e0..fb5aaef2a12aeeb380b6b9b1e5c7e0ada0a442c1 100644 (file)
--- 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
@@ -422,15 +422,17 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUS
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
-
-       int records, i, len;
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
+       int                     records, i, len;
        rlm_sql_postgres_conn_t *conn = handle->conn;
 
        handle->row = NULL;
 
-       if (conn->cur_row >= PQntuples(conn->result)) return RLM_SQL_NO_MORE_ROWS;
+       query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+       if (conn->cur_row >= PQntuples(conn->result)) RETURN_MODULE_OK;
 
        free_result_row(conn);
 
@@ -447,10 +449,10 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, UNUSED rlm_sql_config
                conn->cur_row++;
                handle->row = conn->row;
 
-               return RLM_SQL_OK;
+               query_ctx->rcode = RLM_SQL_OK;
        }
 
-       return RLM_SQL_NO_MORE_ROWS;
+       RETURN_MODULE_OK;
 }
 
 static int sql_num_fields(rlm_sql_handle_t * handle, UNUSED rlm_sql_config_t const *config)

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 f8e06ac54bb867ca0319c6f3c0425aa659639f8b..9845b45131dc4b9e977b23039a62c69e006d53e2 100644 (file)
--- 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
@@ -521,14 +521,13 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUS
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
-       int status;
-       rlm_sql_sqlite_conn_t *conn = handle->conn;
-
-       int i = 0;
-
-       char **row;
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
+       int                     status, i = 0;
+       rlm_sql_sqlite_conn_t   *conn = handle->conn;
+       char                    **row;
 
        TALLOC_FREE(handle->row);
 
@@ -540,20 +539,27 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
        /*
         *      Error getting next row
         */
-       if (sql_check_error(conn->db, status) != RLM_SQL_OK) return RLM_SQL_ERROR;
+       if (sql_check_error(conn->db, status) != RLM_SQL_OK) {
+       error:
+               query_ctx->rcode = RLM_SQL_ERROR;
+               RETURN_MODULE_FAIL;
+       }
 
        /*
         *      No more rows to process (we're done)
         */
-       if (status == SQLITE_DONE) return RLM_SQL_NO_MORE_ROWS;
+       if (status == SQLITE_DONE) {
+               query_ctx->rcode =  RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
+       }
 
        /*
         *      We only need to do this once per result set, because
         *      the number of columns won't change.
         */
        if (conn->col_count == 0) {
-               conn->col_count = sql_num_fields(handle, config);
-               if (conn->col_count == 0) return RLM_SQL_ERROR;
+               conn->col_count = sql_num_fields(handle, &query_ctx->inst->config);
+               if (conn->col_count == 0) goto error;
        }
 
        /*
@@ -600,7 +606,8 @@ static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t cons
                }
        }
 
-       return RLM_SQL_OK;
+       query_ctx->rcode = RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_free_result(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t const *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 3e9003afadded07f12d54697e7c5069e4351b390..9e7c8435ad2fca124b8915a87a898de2a898cda1 100644 (file)
--- 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
@@ -215,22 +215,28 @@ static sql_rcode_t sql_fields(char const **out[], rlm_sql_handle_t *handle, UNUS
        return RLM_SQL_OK;
 }
 
-static sql_rcode_t sql_fetch_row(rlm_sql_handle_t *handle, rlm_sql_config_t const *config)
+static unlang_action_t sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, UNUSED request_t *request, void *uctx)
 {
+       fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
+       rlm_sql_handle_t        *handle = query_ctx->handle;
        rlm_sql_unixodbc_conn_t *conn = handle->conn;
-       long err_handle;
-       int state;
+       long                    err_handle;
 
        handle->row = NULL;
 
        err_handle = SQLFetch(conn->stmt);
-       if (err_handle == SQL_NO_DATA_FOUND) return RLM_SQL_NO_MORE_ROWS;
+       if (err_handle == SQL_NO_DATA_FOUND) {
+               query_ctx->rcode = RLM_SQL_NO_MORE_ROWS;
+               RETURN_MODULE_OK;
+       }
 
-       if ((state = sql_check_error(err_handle, handle, config))) return state;
+       query_ctx->rcode = sql_check_error(err_handle, handle, &query_ctx->inst->config);
+       if (query_ctx->rcode != RLM_SQL_OK) RETURN_MODULE_FAIL;
 
        handle->row = conn->row;
 
-       return RLM_SQL_OK;
+       query_ctx->rcode = RLM_SQL_OK;
+       RETURN_MODULE_OK;
 }
 
 static sql_rcode_t sql_finish_select_query(rlm_sql_handle_t * handle, rlm_sql_config_t const *config)

diff --git a/src/modules/rlm_sql/rlm_sql.h b/src/modules/rlm_sql/rlm_sql.h
index acebf0ea1a5f42f3668e36d2244ec6210a6d67fb..4821e85758e14a0254ea506b6151be09b989ae91 100644 (file)
--- a/src/modules/rlm_sql/rlm_sql.h
+++ b/src/modules/rlm_sql/rlm_sql.h
@@ -183,7 +183,7 @@ typedef struct {
        int             (*sql_num_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
        int             (*sql_affected_rows)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
 
-       sql_rcode_t     (*sql_fetch_row)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
+       unlang_function_t       sql_fetch_row;
        sql_rcode_t     (*sql_fields)(char const **out[], rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
        sql_rcode_t     (*sql_free_result)(rlm_sql_handle_t *handle, rlm_sql_config_t const *config);
 

diff --git a/src/modules/rlm_sql/sql.c b/src/modules/rlm_sql/sql.c
index 9ee03861fe5122efbd8764b620c3a7dcc92bacbc..e79022ba18606797ed527bc589ac53a8b4be4b51 100644 (file)
--- a/src/modules/rlm_sql/sql.c
+++ b/src/modules/rlm_sql/sql.c
@@ -320,7 +320,7 @@ unlang_action_t rlm_sql_fetch_row(rlm_rcode_t *p_result, UNUSED int *priority, r
         *      may require the original connection to free up queries or
         *      result sets associated with that connection.
         */
-       query_ctx->rcode = (inst->driver->sql_fetch_row)(query_ctx->handle, &inst->config);
+       (inst->driver->sql_fetch_row)(p_result, NULL, request, query_ctx);
        switch (query_ctx->rcode) {
        case RLM_SQL_OK:
                fr_assert(query_ctx->handle->row != NULL);