src/modules/rlm_sql/drivers/rlm_sql_mysql/sql_mysql.c

   1 /*
   2  * sql_mysql.c          SQL Module
   3  *
   4  * Version:     $Id$
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  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
  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 2000  The FreeRADIUS server project
  21  * Copyright 2000  Mike Machado <mike@innercite.com>
  22  * Copyright 2000  Alan DeKok <aland@ox.org>
  23  */
  24
  25 #include <stdio.h>
  26 #include <sys/stat.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include <mysql/errmsg.h>
  31
  32 #include        "radiusd.h"
  33
  34 #include        <mysql/mysql.h>
  35 #include        "rlm_sql.h"
  36
  37 typedef struct rlm_sql_mysql_sock {
  38         MYSQL conn;
  39         MYSQL *sock;
  40         MYSQL_RES *result;
  41         SQL_ROW row;
  42 } rlm_sql_mysql_sock;
  43
  44 /*************************************************************************
  45  *
  46  *      Function: sql_create_socket
  47  *
  48  *      Purpose: Establish connection to the db
  49  *
  50  *************************************************************************/
  51 static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
  52 {
  53         rlm_sql_mysql_sock *mysql_sock;
  54
  55         if (!sqlsocket->conn) {
  56                 sqlsocket->conn = (rlm_sql_mysql_sock *)rad_malloc(sizeof(rlm_sql_mysql_sock));
  57                 if (!sqlsocket->conn) {
  58                         return -1;
  59                 }
  60         }
  61         mysql_sock = sqlsocket->conn;
  62         memset(mysql_sock, 0, sizeof(*mysql_sock));
  63
  64         radlog(L_INFO, "rlm_sql_mysql: Starting connect to MySQL server for #%d",
  65                         sqlsocket->id);
  66
  67         mysql_init(&(mysql_sock->conn));
  68         if (!(mysql_sock->sock = mysql_real_connect(&(mysql_sock->conn),
  69                                                     config->sql_server,
  70                                                     config->sql_login,
  71                                                     config->sql_password,
  72                                                     config->sql_db,
  73                                                     atoi(config->sql_port),
  74                                                     NULL,
  75                                                     CLIENT_FOUND_ROWS))) {
  76                 radlog(L_ERR, "rlm_sql_mysql: Couldn't connect socket to MySQL server %s@%s:%s", config->sql_login, config->sql_server, config->sql_db);
  77                 radlog(L_ERR, "rlm_sql_mysql: Mysql error '%s'", mysql_error(&mysql_sock->conn));
  78                 mysql_sock->sock = NULL;
  79                 return -1;
  80         }
  81
  82
  83         return 0;
  84 }
  85
  86
  87 /*************************************************************************
  88  *
  89  *      Function: sql_destroy_socket
  90  *
  91  *      Purpose: Free socket and any private connection data
  92  *
  93  *************************************************************************/
  94 static int sql_destroy_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config)
  95 {
  96         free(sqlsocket->conn);
  97         sqlsocket->conn = NULL;
  98
  99         return 0;
 100 }
 101
 102
 103 /*************************************************************************
 104  *
 105  *      Function: sql_check_error
 106  *
 107  *      Purpose: check the error to see if the server is down
 108  *
 109  *************************************************************************/
 110 static int sql_check_error(int error)
 111 {
 112         switch(error) {
 113         case CR_SERVER_GONE_ERROR:
 114         case CR_SERVER_LOST:
 115         case -1:
 116                 radlog(L_DBG, "rlm_sql_mysql: MYSQL check_error: %d, returning SQL_DOWN", error);
 117                 return SQL_DOWN;
 118                 break;
 119         case 0:
 120                 return 0;
 121                 break;
 122         case CR_OUT_OF_MEMORY:
 123         case CR_COMMANDS_OUT_OF_SYNC:
 124         case CR_UNKNOWN_ERROR:
 125         default:
 126                 radlog(L_DBG, "rlm_sql_mysql: MYSQL check_error: %d received", error);
 127                 return -1;
 128                 break;
 129         }
 130 }
 131
 132
 133 /*************************************************************************
 134  *
 135  *      Function: sql_query
 136  *
 137  *      Purpose: Issue a query to the database
 138  *
 139  *************************************************************************/
 140 static int sql_query(SQLSOCK * sqlsocket, SQL_CONFIG *config, char *querystr)
 141 {
 142         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 143
 144         if (config->sqltrace)
 145                 radlog(L_DBG,"rlm_sql_mysql: query:  %s", querystr);
 146         if (mysql_sock->sock == NULL) {
 147                 radlog(L_ERR, "rlm_sql_mysql: Socket not connected");
 148                 return SQL_DOWN;
 149         }
 150
 151         mysql_query(mysql_sock->sock, querystr);
 152         return sql_check_error(mysql_errno(mysql_sock->sock));
 153 }
 154
 155
 156 /*************************************************************************
 157  *
 158  *      Function: sql_store_result
 159  *
 160  *      Purpose: database specific store_result function. Returns a result
 161  *               set for the query.
 162  *
 163  *************************************************************************/
 164 static int sql_store_result(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 165 {
 166         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 167
 168         if (mysql_sock->sock == NULL) {
 169                 radlog(L_ERR, "rlm_sql_mysql: Socket not connected");
 170                 return SQL_DOWN;
 171         }
 172         if (!(mysql_sock->result = mysql_store_result(mysql_sock->sock))) {
 173                 radlog(L_ERR, "rlm_sql_mysql: MYSQL Error: Cannot get result");
 174                 radlog(L_ERR, "rlm_sql_mysql: MYSQL Error: %s",
 175                        mysql_error(mysql_sock->sock));
 176                 return sql_check_error(mysql_errno(mysql_sock->sock));
 177         }
 178         return 0;
 179 }
 180
 181
 182 /*************************************************************************
 183  *
 184  *      Function: sql_num_fields
 185  *
 186  *      Purpose: database specific num_fields function. Returns number
 187  *               of columns from query
 188  *
 189  *************************************************************************/
 190 static int sql_num_fields(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 191 {
 192         int     num = 0;
 193         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 194
 195 #if MYSQL_VERSION_ID >= 32224
 196         if (!(num = mysql_field_count(mysql_sock->sock))) {
 197 #else
 198         if (!(num = mysql_num_fields(mysql_sock->sock))) {
 199 #endif
 200                 radlog(L_ERR, "rlm_sql_mysql: MYSQL Error: No Fields");
 201                 radlog(L_ERR, "rlm_sql_mysql: MYSQL error: %s",
 202                        mysql_error(mysql_sock->sock));
 203         }
 204         return num;
 205 }
 206
 207
 208 /*************************************************************************
 209  *
 210  *      Function: sql_select_query
 211  *
 212  *      Purpose: Issue a select query to the database
 213  *
 214  *************************************************************************/
 215 static int sql_select_query(SQLSOCK *sqlsocket, SQL_CONFIG *config,
 216                             char *querystr)
 217 {
 218         int ret;
 219
 220         ret = sql_query(sqlsocket, config, querystr);
 221         if(ret)
 222                 return ret;
 223         ret = sql_store_result(sqlsocket, config);
 224         if (ret) {
 225                 return ret;
 226         }
 227
 228         /* Why? Per http://www.mysql.com/doc/n/o/node_591.html,
 229          * this cannot return an error.  Perhaps just to complain if no
 230          * fields are found?
 231          */
 232         sql_num_fields(sqlsocket, config);
 233
 234         return ret;
 235 }
 236
 237
 238 /*************************************************************************
 239  *
 240  *      Function: sql_num_rows
 241  *
 242  *      Purpose: database specific num_rows. Returns number of rows in
 243  *               query
 244  *
 245  *************************************************************************/
 246 static int sql_num_rows(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 247 {
 248         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 249
 250         if (mysql_sock->result)
 251                 return mysql_num_rows(mysql_sock->result);
 252
 253         return 0;
 254 }
 255
 256
 257 /*************************************************************************
 258  *
 259  *      Function: sql_fetch_row
 260  *
 261  *      Purpose: database specific fetch_row. Returns a SQL_ROW struct
 262  *               with all the data for the query in 'sqlsocket->row'. Returns
 263  *               0 on success, -1 on failure, SQL_DOWN if database is down.
 264  *
 265  *************************************************************************/
 266 static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 267 {
 268         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 269
 270         /*
 271          *  Check pointer before de-referencing it.
 272          */
 273         if (!mysql_sock->result) {
 274                 return SQL_DOWN;
 275         }
 276
 277         sqlsocket->row = mysql_fetch_row(mysql_sock->result);
 278
 279         if (sqlsocket->row == NULL) {
 280                 return sql_check_error(mysql_errno(mysql_sock->sock));
 281         }
 282         return 0;
 283 }
 284
 285
 286 /*************************************************************************
 287  *
 288  *      Function: sql_free_result
 289  *
 290  *      Purpose: database specific free_result. Frees memory allocated
 291  *               for a result set
 292  *
 293  *************************************************************************/
 294 static int sql_free_result(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 295 {
 296         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 297
 298         if (mysql_sock->result) {
 299                 mysql_free_result(mysql_sock->result);
 300                 mysql_sock->result = NULL;
 301         }
 302
 303         return 0;
 304 }
 305
 306
 307
 308 /*************************************************************************
 309  *
 310  *      Function: sql_error
 311  *
 312  *      Purpose: database specific error. Returns error associated with
 313  *               connection
 314  *
 315  *************************************************************************/
 316 static char *sql_error(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 317 {
 318         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 319
 320         if (mysql_sock == NULL || mysql_sock->sock == NULL) {
 321                 return "rlm_sql_mysql: no connection to db";
 322         }
 323         return mysql_error(mysql_sock->sock);
 324 }
 325
 326
 327 /*************************************************************************
 328  *
 329  *      Function: sql_close
 330  *
 331  *      Purpose: database specific close. Closes an open database
 332  *               connection
 333  *
 334  *************************************************************************/
 335 static int sql_close(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 336 {
 337         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 338
 339         if (mysql_sock && mysql_sock->sock){
 340                 mysql_close(mysql_sock->sock);
 341                 mysql_sock->sock = NULL;
 342         }
 343
 344         return 0;
 345 }
 346
 347
 348 /*************************************************************************
 349  *
 350  *      Function: sql_finish_query
 351  *
 352  *      Purpose: End the query, such as freeing memory
 353  *
 354  *************************************************************************/
 355 static int sql_finish_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 356 {
 357         return 0;
 358 }
 359
 360
 361
 362 /*************************************************************************
 363  *
 364  *      Function: sql_finish_select_query
 365  *
 366  *      Purpose: End the select query, such as freeing memory or result
 367  *
 368  *************************************************************************/
 369 static int sql_finish_select_query(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 370 {
 371         sql_free_result(sqlsocket, config);
 372
 373         return 0;
 374 }
 375
 376
 377 /*************************************************************************
 378  *
 379  *      Function: sql_affected_rows
 380  *
 381  *      Purpose: End the select query, such as freeing memory or result
 382  *
 383  *************************************************************************/
 384 static int sql_affected_rows(SQLSOCK * sqlsocket, SQL_CONFIG *config)
 385 {
 386         rlm_sql_mysql_sock *mysql_sock = sqlsocket->conn;
 387
 388         return mysql_affected_rows(mysql_sock->sock);
 389 }
 390
 391
 392 /* Exported to rlm_sql */
 393 rlm_sql_module_t rlm_sql_mysql = {
 394         "rlm_sql_mysql",
 395         sql_init_socket,
 396         sql_destroy_socket,
 397         sql_query,
 398         sql_select_query,
 399         sql_store_result,
 400         sql_num_fields,
 401         sql_num_rows,
 402         sql_fetch_row,
 403         sql_free_result,
 404         sql_error,
 405         sql_close,
 406         sql_finish_query,
 407         sql_finish_select_query,
 408         sql_affected_rows
 409 };