src/modules/rlm_sql/drivers/rlm_sql_freetds/rlm_sql_freetds.c

   1 /*
   2  *  sql_freetds.c
   3  *  freeradius
   4  *
   5  * Version:     $Id$
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License version 2 only, as published by
   9  *   the Free Software Foundation.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License version 2
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * Copyright 2009 Gabriel Blanchard gabe@teksavvy.com
  21  */
  22
  23 #include <freeradius-devel/ident.h>
  24 RCSID("$Id$")
  25
  26 #include <freeradius-devel/radiusd.h>
  27
  28 #include <sybdb.h>
  29 #include <sybfront.h>
  30
  31 #include <sys/time.h>
  32 #include <sys/stat.h>
  33
  34 #include "rlm_sql.h"
  35 static int query_timeout_handler(void *dbproc);
  36 static int err_handler(UNUSED DBPROCESS *dbproc, UNUSED int severity, UNUSED int dberr, UNUSED int oserr, char *dberrstr, char *oserrstr);
  37
  38 // As defined in tds.h
  39 #define TDS_INT_CONTINUE 1
  40 #define TDS_INT_CANCEL 2
  41 #define TDS_INT_TIMEOUT 3
  42
  43 typedef struct rlm_sql_freetds_sock {
  44         DBPROCESS *dbproc;
  45 } rlm_sql_freetds_sock;
  46
  47 /*
  48  * FreeTDS calls this handler when dbsqlexec() or dbsqlok() blocks every seconds
  49  * This ensures that FreeTDS doesn't stay stuck on the same query for ever.
  50  */
  51 static int query_timeout_handler(void *dbproc) {
  52         return TDS_INT_CONTINUE;
  53 }
  54
  55 static int err_handler(UNUSED DBPROCESS *dbproc, UNUSED int severity, UNUSED int dberr, UNUSED int oserr, char *dberrstr, char *oserrstr)
  56 {
  57                 radlog(L_ERR, "rlm_sql_freetds: FreeTDS error: %s\n", dberrstr);
  58                 radlog(L_ERR, "rlm_sql_freetds: OS error: %s\n", oserrstr);
  59                 return 0;
  60 }
  61
  62 /*************************************************************************
  63  *
  64  *      Function: sql_create_socket
  65  *
  66  *      Purpose: Establish connection to the db
  67  *
  68  *************************************************************************/
  69 static int sql_init_socket(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
  70 {
  71         LOGINREC *login;
  72         rlm_sql_freetds_sock *freetds_sock;
  73
  74         if (!handle->conn) {
  75                 handle->conn = (rlm_sql_freetds_sock *)rad_malloc(sizeof(struct rlm_sql_freetds_sock));
  76                 if (!handle->conn) {
  77                         return -1;
  78                 }
  79         }
  80
  81         if (dbinit() == FAIL) {
  82                 radlog(L_ERR, "rlm_sql_freetds: Unable to init FreeTDS");
  83                 return -1;
  84         }
  85
  86         dbsetversion(DBVERSION_80);
  87         dberrhandle(err_handler);
  88
  89         // Timeout so that FreeTDS doesn't wait for ever.
  90         dbsetlogintime((unsigned long)config->query_timeout);
  91         dbsettime((unsigned long)config->query_timeout);
  92
  93         freetds_sock = handle->conn;
  94         memset(freetds_sock, 0, sizeof(*freetds_sock));
  95
  96         DEBUG("rlm_sql_freetds (%s): Starting connect to FreeTDS/MSSQL server", config->xlat_name);
  97
  98         if (!(login = dblogin())) {
  99                 radlog(L_ERR, "rlm_sql_freetds (%s): Unable to allocate login record", config->xlat_name);
 100                 return -1;
 101         }
 102
 103         DBSETLUSER(login, config->sql_login);
 104         DBSETLPWD(login, config->sql_password);
 105
 106         if ((freetds_sock->dbproc = dbopen(login, config->sql_server)) == FAIL) {
 107                 radlog(L_ERR, "rlm_sql_freetds (%s): Unable to connect to FreeTDS/MSSQL server %s@%s",
 108                            config->xlat_name, config->sql_login, config->sql_server);
 109                 dbloginfree(login);
 110                 return -1;
 111         }
 112
 113         dbloginfree(login);
 114
 115         if ((dbuse(freetds_sock->dbproc, config->sql_db)) == FAIL) {
 116                 radlog(L_ERR, "rlm_sql_freetds (%s): Unable to select database on FreeTDS/MSSQL server %s@%s:%s",
 117                            config->xlat_name, config->sql_login, config->sql_server, config->sql_db);
 118                 return -1;
 119         }
 120
 121         /* I know this may look strange, but it sets a pointer to
 122          the freetds_sock struct so that it can be used within the
 123          query_timeout_handler function to be able to timeout properly */
 124         dbsetinterrupt(freetds_sock->dbproc, query_timeout_handler, query_timeout_handler);
 125         dbsetuserdata(freetds_sock->dbproc, (BYTE *)freetds_sock);
 126
 127         return 0;
 128 }
 129
 130
 131 /*************************************************************************
 132  *
 133  *      Function: sql_destroy_socket
 134  *
 135  *      Purpose: Free socket and any private connection data
 136  *
 137  *************************************************************************/
 138 static int sql_destroy_socket(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 139 {
 140         free(handle->conn);
 141         handle->conn = NULL;
 142
 143         return 0;
 144 }
 145
 146
 147 /*************************************************************************
 148  *
 149  *      Function: sql_query
 150  *
 151  *      Purpose: Issue a query to the database
 152  *
 153  *************************************************************************/
 154 static int sql_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr)
 155 {
 156         rlm_sql_freetds_sock *freetds_sock = handle->conn;
 157
 158         if (freetds_sock->dbproc == NULL || DBDEAD(freetds_sock->dbproc)) {
 159                 radlog(L_ERR, "rlm_sql_freetds (%s): Socket not connected", config->xlat_name);
 160                 return SQL_DOWN;
 161         }
 162
 163         if ((dbcmd(freetds_sock->dbproc, querystr)) == FAIL) {
 164                 radlog(L_ERR, "rlm_sql_freetds (%s): Unable to allocate SQL query", config->xlat_name);
 165                 return -1;
 166         }
 167
 168         if ((dbsqlexec(freetds_sock->dbproc)) == FAIL) {
 169                 radlog(L_ERR, "rlm_sql_freetds (%s): SQL query failed", config->xlat_name);
 170                 return -1;
 171         }
 172
 173         return 0;
 174 }
 175
 176
 177 /*************************************************************************
 178  *
 179  *      Function: sql_select_query
 180  *
 181  *      Purpose: Issue a select query to the database
 182  *
 183  *************************************************************************/
 184 static int sql_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config, char *querystr)
 185 {
 186         radlog(L_ERR, "rlm_sql_freetds sql_select_query(): unsupported");
 187         return -1;
 188 }
 189
 190
 191 /*************************************************************************
 192  *
 193  *      Function: sql_store_result
 194  *
 195  *      Purpose: database specific store_result function. Returns a result
 196  *               set for the query.
 197  *
 198  *************************************************************************/
 199 static int sql_store_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 200 {
 201         radlog(L_ERR, "rlm_sql_freetds sql_store_result(): unsupported");
 202         return -1;
 203 }
 204
 205
 206 /*************************************************************************
 207  *
 208  *      Function: sql_num_fields
 209  *
 210  *      Purpose: database specific num_fields function. Returns number
 211  *               of columns from query
 212  *
 213  *************************************************************************/
 214 static int sql_num_fields(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 215 {
 216         rlm_sql_freetds_sock *freetds_sock = handle->conn;
 217
 218         return dbnumcols(freetds_sock->dbproc);
 219 }
 220
 221
 222 /*************************************************************************
 223  *
 224  *      Function: sql_num_rows
 225  *
 226  *      Purpose: database specific num_rows. Returns number of rows in
 227  *               query
 228  *
 229  *************************************************************************/
 230 static int sql_num_rows(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 231 {
 232
 233         return 0;
 234 }
 235
 236 /*************************************************************************
 237  *
 238  *      Function: sql_fetch_row
 239  *
 240  *      Purpose: database specific fetch_row. Returns a rlm_sql_row_t struct
 241  *               with all the data for the query in 'handle->row'. Returns
 242  *               0 on success, -1 on failure, SQL_DOWN if database is down.
 243  *
 244  *************************************************************************/
 245 static int sql_fetch_row(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 246 {
 247         return 0;
 248 }
 249
 250
 251 /*************************************************************************
 252  *
 253  *      Function: sql_free_result
 254  *
 255  *      Purpose: database specific free_result. Frees memory allocated
 256  *               for a result set
 257  *
 258  *************************************************************************/
 259 static int sql_free_result(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 260 {
 261
 262         return 0;
 263 }
 264
 265
 266 /*************************************************************************
 267  *
 268  *      Function: sql_error
 269  *
 270  *      Purpose: database specific error. Returns error associated with
 271  *               connection
 272  *
 273  *************************************************************************/
 274 static const char *sql_error(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 275 {
 276         return NULL;
 277 }
 278
 279
 280 /*************************************************************************
 281  *
 282  *      Function: sql_close
 283  *
 284  *      Purpose: database specific close. Closes an open database
 285  *               connection
 286  *
 287  *************************************************************************/
 288 static int sql_close(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 289 {
 290         rlm_sql_freetds_sock *freetds_sock = handle->conn;
 291
 292         if (freetds_sock && freetds_sock->dbproc){
 293                 dbclose(freetds_sock->dbproc);
 294                 freetds_sock->dbproc = NULL;
 295         }
 296
 297         return 0;
 298 }
 299
 300
 301 /*************************************************************************
 302  *
 303  *      Function: sql_finish_query
 304  *
 305  *      Purpose: End the query, such as freeing memory
 306  *
 307  *************************************************************************/
 308 static int sql_finish_query(UNUSED rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 309 {
 310
 311         return 0;
 312 }
 313
 314
 315 /*************************************************************************
 316  *
 317  *      Function: sql_finish_select_query
 318  *
 319  *      Purpose: End the select query, such as freeing memory or result
 320  *
 321  *************************************************************************/
 322 static int sql_finish_select_query(rlm_sql_handle_t *handle, rlm_sql_config_t *config)
 323 {
 324         return sql_finish_query(handle, config);
 325 }
 326
 327
 328 /*************************************************************************
 329  *
 330  *      Function: sql_affected_rows
 331  *
 332  *      Purpose: End the select query, such as freeing memory or result
 333  *
 334  *************************************************************************/
 335 static int sql_affected_rows(rlm_sql_handle_t *handle, UNUSED rlm_sql_config_t *config)
 336 {
 337         rlm_sql_freetds_sock *freetds_sock = handle->conn;
 338
 339         return dbcount(freetds_sock->dbproc);
 340 }
 341
 342
 343 /* Exported to rlm_sql */
 344 rlm_sql_module_t rlm_sql_freetds = {
 345         "rlm_sql_freetds",
 346         sql_init_socket,
 347         sql_destroy_socket,
 348         sql_query,
 349         sql_select_query,
 350         sql_store_result,
 351         sql_num_fields,
 352         sql_num_rows,
 353         sql_fetch_row,
 354         sql_free_result,
 355         sql_error,
 356         sql_close,
 357         sql_finish_query,
 358         sql_finish_select_query,
 359         sql_affected_rows
 360 };