rlm_sql_db2.c

Go to the documentation of this file.

/*
 * sql_db2.c            IBM DB2 rlm_sql driver
 *
 * Version:     $Id: b3bedf83d808b8df0bf3d7f1803888dc84b03f52 $
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 *
 * @copyright 2000,2006 The FreeRADIUS server project
 * @copyright 2000 Mike Machado (mike@innercite.com)
 * @copyright 2000 Alan DeKok (aland@freeradius.org)
 * @copyright 2001 Joerg Wendland (wendland@scan-plus.de)
 */
 
/*
 * Modification of rlm_sql_db2 to handle IBM DB2 UDB V7
 * by Joerg Wendland <wendland@scan-plus.de>
 */
RCSID("$Id: b3bedf83d808b8df0bf3d7f1803888dc84b03f52 $")
 
#define LOG_PREFIX "sql - db2"
 
#include <freeradius-devel/server/base.h>
#include <freeradius-devel/util/debug.h>
 
#include <sys/stat.h>
 
#include <sqlcli.h>
#include "rlm_sql.h"
 
typedef struct {
        SQLHANDLE dbc_handle;
        SQLHANDLE env_handle;
        SQLHANDLE stmt;
} rlm_sql_db2_conn_t;
 
static int _sql_socket_destructor(rlm_sql_db2_conn_t *conn)
{
        DEBUG2("Socket destructor called, closing socket");
 
        if (conn->dbc_handle) {
                SQLDisconnect(conn->dbc_handle);
                SQLFreeHandle(SQL_HANDLE_DBC, conn->dbc_handle);
        }
 
        if (conn->env_handle) SQLFreeHandle(SQL_HANDLE_ENV, conn->env_handle);
 
        return RLM_SQL_OK;
}
 
static sql_rcode_t sql_socket_init(rlm_sql_handle_t *handle, rlm_sql_config_t const *config,
                                   UNUSED fr_time_delta_t timeout)
{
        SQLRETURN row;
#if 0
        uint32_t timeout_ms = FR_TIMEVAL_TO_MS(timeout);
#endif
        rlm_sql_db2_conn_t *conn;
 
        MEM(conn = handle->conn = talloc_zero(handle, rlm_sql_db2_conn_t));
        talloc_set_destructor(conn, _sql_socket_destructor);
 
        /* Allocate handles */
        SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(conn->env_handle));
        SQLAllocHandle(SQL_HANDLE_DBC, conn->env_handle, &(conn->dbc_handle));
 
        /* Set the connection timeout */
#if 0
        /* Not supported ? */
        SQLSetConnectAttr(conn->dbc_handle, SQL_ATTR_LOGIN_TIMEOUT, &timeout_ms, SQL_IS_UINTEGER);
#endif
 
        /*
         *      We probably want to use SQLDriverConnect, which connects
         *      to a remote server.
         *
         *      http://www.ibm.com/support/knowledgecenter/SSEPGG_10.5.0/com.ibm.db2.luw.apdv.cli.doc/doc/r0000584.html
         *      http://stackoverflow.com/questions/27167070/connection-string-to-a-remote-db2-db-in-another-server
         *
         *      And probably synthesise the retarded connection string ourselves,
         *      probably via config file expansions:
         *
         *      Driver={IBM DB2 ODBC Driver};Database=testDb;Hostname=remoteHostName.com;UID=username;PWD=mypasswd;PORT=50000
         */
        row = SQLConnect(conn->dbc_handle,
                         UNCONST(SQLCHAR *, config->sql_server), SQL_NTS,
                         UNCONST(SQLCHAR *, config->sql_login), SQL_NTS,
                         UNCONST(SQLCHAR *, config->sql_password), SQL_NTS);
        if (row != SQL_SUCCESS) {
                ERROR("could not connect to DB2 server %s", config->sql_server);
 
                return RLM_SQL_ERROR;
        }
 
        return RLM_SQL_OK;
}
 
static unlang_action_t sql_query(rlm_rcode_t *p_result, UNUSED int *priority, request_t *request, void *uctx)
{
        fr_sql_query_t          *query_ctx = talloc_get_type_abort(uctx, fr_sql_query_t);
        SQLRETURN row;
        rlm_sql_db2_conn_t *conn;
 
        conn = query_ctx->handle->conn;
 
        /* allocate handle for statement */
        SQLAllocHandle(SQL_HANDLE_STMT, conn->dbc_handle, &(conn->stmt));
 
        /* execute query */
        {
                SQLCHAR *db2_query;
                memcpy(&db2_query, &query_ctx->query_str, sizeof(query_ctx->query_str));
 
                row = SQLExecDirect(conn->stmt, db2_query, SQL_NTS);
                if(row != SQL_SUCCESS) {
                        /* XXX Check if row means we should return RLM_SQL_RECONNECT */
                        ERROR("Could not execute statement \"%s\"", query);
                        query_ctx->rcode = RLM_SQL_ERROR;
                        RETURN_MODULE_FAIL
                }
        }
 
        query_ctx->rcode = RLM_SQL_OK;
        RETURN_MODULE_OK;
}
 
static sql_rcode_t sql_fields(char const **out[], fr_sql_query_t *query_ctx, UNUSED rlm_sql_config_t const *config)
{
        rlm_sql_db2_conn_t *conn = query_ctx->handle->conn;
 
        SQLSMALLINT     fields, len, i;
 
        char const      **names;
        char            field[128];
 
        SQLNumResultCols(conn->stmt, &fields);
        if (fields == 0) return RLM_SQL_ERROR;
 
        MEM(names = talloc_array(query_ctx, char const *, fields));
 
        for (i = 0; i < fields; i++) {
                char *p;
 
                switch (SQLColAttribute(conn->stmt, i, SQL_DESC_BASE_COLUMN_NAME,
                                        field, sizeof(field), &len, NULL)) {
                case SQL_INVALID_HANDLE:
                case SQL_ERROR:
                        ERROR("Failed retrieving field name at index %i", i);
                        talloc_free(names);
                        return RLM_SQL_ERROR;
 
                default:
                        break;
                }
 
                MEM(p = talloc_array(names, char, (size_t)len + 1));
                strlcpy(p, field, (size_t)len + 1);
                names[i] = p;
        }
        *out = names;
 
        return RLM_SQL_OK;
}
 
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                     i;
        SQLINTEGER              len, slen;
        SQLSMALLINT             c;
        rlm_sql_row_t           row;
        rlm_sql_db2_conn_t      *conn;
        rlm_sql_handle_t        *handle = query_ctx->handle;
 
        TALLOC_FREE(query_ctx->row);
 
        conn = handle->conn;
        SQLNumResultCols(conn->stmt, &c);
 
        /* advance cursor */
        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(query_ctx, char *, c + 1));
        for (i = 0; i < c; i++) {
                /* get column length */
                SQLColAttribute(conn->stmt, i + 1, SQL_DESC_DISPLAY_SIZE, NULL, 0, NULL, &len);
 
                MEM(row[i] = talloc_array(row, char, len + 1));
 
                /* get the actual column */
                SQLGetData(conn->stmt, i + 1, SQL_C_CHAR, row[i], len + 1, &slen);
                if (slen == SQL_NULL_DATA) row[i][0] = '\0';
        }
 
        query_ctx->row = row;
 
        query_ctx->rcode = RLM_SQL_OK;
        RETURN_MODULE_OK;
}
 
static sql_rcode_t sql_free_result(fr_sql_query_t *query_, UNUSED rlm_sql_config_t const *config)
{
        rlm_sql_db2_conn_t *conn;
 
        conn = query_ctx->handle->conn;
        TALLOC_FREE(query_ctx->row);
        SQLFreeHandle(SQL_HANDLE_STMT, conn->stmt);
 
        return RLM_SQL_OK;
}
 
/** Retrieves any errors associated with the query context
 *
 * @note Caller will free any memory allocated in ctx.
 *
 * @param ctx to allocate temporary error buffers in.
 * @param out Array of sql_log_entrys to fill.
 * @param outlen Length of out array.
 * @param query_ctx Query context to retrieve error for.
 * @param config rlm_sql config.
 * @return number of errors written to the #sql_log_entry_t array.
 */
static size_t sql_error(TALLOC_CTX *ctx, sql_log_entry_t out[], NDEBUG_UNUSED size_t outlen,
                        fr_sql_query_t *query_ctx, UNUSED rlm_sql_config_t const *config)
{
        char                    state[6];
        char                    errbuff[1024];
        SQLINTEGER              err;
        SQLSMALLINT             rl;
        rlm_sql_db2_conn_t      *conn = query_ctx->handle->conn;
 
        fr_assert(conn);
        fr_assert(outlen > 0);
 
        errbuff[0] = '\0';
        SQLGetDiagRec(SQL_HANDLE_STMT, conn->stmt, 1, (SQLCHAR *) state, &err,
                      (SQLCHAR *) errbuff, sizeof(errbuff), &rl);
        if (errbuff[0] == '\0') return 0;
 
        out[0].type = L_ERR;
        out[0].msg = talloc_typed_asprintf(ctx, "%s: %s", state, errbuff);
 
        return 1;
}
 
static sql_rcode_t sql_finish_query(UNUSED fr_sql_query_t *query_ctx, UNUSED rlm_sql_config_t const *config)
{
        return RLM_SQL_OK;
}
 
static int sql_affected_rows(fr_sql_query_t *query_ctx, UNUSED rlm_sql_config_t const *config)
{
        SQLINTEGER c;
        rlm_sql_db2_conn_t *conn = query_ctx->handle->conn;
 
        SQLRowCount(conn->stmt, &c);
 
        return c;
}
 
/* Exported to rlm_sql */
extern rlm_sql_driver_t rlm_sql_db2;
rlm_sql_driver_t rlm_sql_db2 = {
        .common = {
                .magic                          = MODULE_MAGIC_INIT,
                .name                           = "sql_db2",
        },
        .sql_socket_init                = sql_socket_init,
        .sql_query                      = sql_query,
        .sql_select_query               = sql_query,
        .sql_affected_rows              = sql_affected_rows,
        .sql_fields                     = sql_fields,
        .sql_fetch_row                  = sql_fetch_row,
        .sql_free_result                = sql_free_result,
        .sql_error                      = sql_error,
        .sql_finish_query               = sql_finish_query,
        .sql_finish_select_query        = sql_finish_query
};