src/modules/rlm_sql/sql.c

   1 /*
   2  *  sql.c               rlm_sql - FreeRADIUS SQL Module
   3  *              Main code directly taken from ICRADIUS
   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 as published by
   9  *   the Free Software Foundation; either version 2 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with this program; if not, write to the Free Software
  19  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  *
  21  * Copyright 2001,2006  The FreeRADIUS server project
  22  * Copyright 2000  Mike Machado <mike@innercite.com>
  23  * Copyright 2000  Alan DeKok <aland@ox.org>
  24  * Copyright 2001  Chad Miller <cmiller@surfsouth.com>
  25  */
  26
  27 RCSID("$Id$")
  28
  29 #include        <freeradius-devel/radiusd.h>
  30 #include        <freeradius-devel/rad_assert.h>
  31
  32 #include        <sys/file.h>
  33 #include        <sys/stat.h>
  34
  35 #include        <ctype.h>
  36
  37 #include        "rlm_sql.h"
  38
  39 #ifdef HAVE_PTHREAD_H
  40 #endif
  41
  42 /*
  43  *      Translate rlm_sql rcodes to humanly
  44  *      readable reason strings.
  45  */
  46 const FR_NAME_NUMBER sql_rcode_table[] = {
  47         { "success",            RLM_SQL_OK              },
  48         { "need alt query",     RLM_SQL_ALT_QUERY       },
  49         { "server error",       RLM_SQL_ERROR           },
  50         { "query invalid",      RLM_SQL_QUERY_INVALID   },
  51         { "no connection",      RLM_SQL_RECONNECT       },
  52         { NULL, 0 }
  53 };
  54
  55
  56 static int _mod_conn_free(rlm_sql_handle_t *conn)
  57 {
  58         rlm_sql_t *inst = conn->inst;
  59
  60         rad_assert(inst);
  61
  62         exec_trigger(NULL, inst->cs, "modules.sql.close", false);
  63
  64         return 0;
  65 }
  66
  67 void *mod_conn_create(TALLOC_CTX *ctx, void *instance)
  68 {
  69         int rcode;
  70         rlm_sql_t *inst = instance;
  71         rlm_sql_handle_t *handle;
  72
  73         /*
  74          *      Connections cannot be alloced from the inst or
  75          *      pool contexts due to threading issues.
  76          */
  77         handle = talloc_zero(ctx, rlm_sql_handle_t);
  78         if (!handle) return NULL;
  79
  80         handle->log_ctx = talloc_pool(handle, 2048);
  81         if (!handle->log_ctx) {
  82                 talloc_free(handle);
  83                 return NULL;
  84         }
  85
  86         /*
  87          *      Handle requires a pointer to the SQL inst so the
  88          *      destructor has access to the module configuration.
  89          */
  90         handle->inst = inst;
  91
  92         /*
  93          *      When something frees this handle the destructor set by
  94          *      the driver will be called first, closing any open sockets.
  95          *      Then we call our destructor to trigger an modules.sql.close
  96          *      event, then all the memory is freed.
  97          */
  98         talloc_set_destructor(handle, _mod_conn_free);
  99
 100         rcode = (inst->module->sql_socket_init)(handle, inst->config);
 101         if (rcode != 0) {
 102         fail:
 103                 exec_trigger(NULL, inst->cs, "modules.sql.fail", true);
 104
 105                 /*
 106                  *      Destroy any half opened connections.
 107                  */
 108                 talloc_free(handle);
 109                 return NULL;
 110         }
 111
 112         if (inst->config->connect_query) {
 113                 if (rlm_sql_select_query(inst, NULL, &handle, inst->config->connect_query) != RLM_SQL_OK) goto fail;
 114                 (inst->module->sql_finish_select_query)(handle, inst->config);
 115         }
 116
 117         exec_trigger(NULL, inst->cs, "modules.sql.open", false);
 118         return handle;
 119 }
 120
 121 /*************************************************************************
 122  *
 123  *      Function: sql_fr_pair_list_afrom_str
 124  *
 125  *      Purpose: Read entries from the database and fill VALUE_PAIR structures
 126  *
 127  *************************************************************************/
 128 int sql_fr_pair_list_afrom_str(TALLOC_CTX *ctx, REQUEST *request, VALUE_PAIR **head, rlm_sql_row_t row)
 129 {
 130         VALUE_PAIR *vp;
 131         char const *ptr, *value;
 132         char buf[MAX_STRING_LEN];
 133         char do_xlat = 0;
 134         FR_TOKEN token, operator = T_EOL;
 135
 136         /*
 137          *      Verify the 'Attribute' field
 138          */
 139         if (!row[2] || row[2][0] == '\0') {
 140                 REDEBUG("The 'Attribute' field is empty or NULL, skipping the entire row");
 141                 return -1;
 142         }
 143
 144         /*
 145          *      Verify the 'op' field
 146          */
 147         if (row[4] != NULL && row[4][0] != '\0') {
 148                 ptr = row[4];
 149                 operator = gettoken(&ptr, buf, sizeof(buf), false);
 150                 if ((operator < T_OP_ADD) ||
 151                     (operator > T_OP_CMP_EQ)) {
 152                         REDEBUG("Invalid operator \"%s\" for attribute %s", row[4], row[2]);
 153                         return -1;
 154                 }
 155
 156         } else {
 157                 /*
 158                  *  Complain about empty or invalid 'op' field
 159                  */
 160                 operator = T_OP_CMP_EQ;
 161                 REDEBUG("The 'op' field for attribute '%s = %s' is NULL, or non-existent.", row[2], row[3]);
 162                 REDEBUG("You MUST FIX THIS if you want the configuration to behave as you expect");
 163         }
 164
 165         /*
 166          *      The 'Value' field may be empty or NULL
 167          */
 168         value = row[3];
 169         /*
 170          *      If we have a new-style quoted string, where the
 171          *      *entire* string is quoted, do xlat's.
 172          */
 173         if (row[3] != NULL &&
 174            ((row[3][0] == '\'') || (row[3][0] == '`') || (row[3][0] == '"')) &&
 175            (row[3][0] == row[3][strlen(row[3])-1])) {
 176
 177                 token = gettoken(&value, buf, sizeof(buf), false);
 178                 switch (token) {
 179                 /*
 180                  *      Take the unquoted string.
 181                  */
 182                 case T_SINGLE_QUOTED_STRING:
 183                 case T_DOUBLE_QUOTED_STRING:
 184                         value = buf;
 185                         break;
 186
 187                 /*
 188                  *      Mark the pair to be allocated later.
 189                  */
 190                 case T_BACK_QUOTED_STRING:
 191                         value = NULL;
 192                         do_xlat = 1;
 193                         break;
 194
 195                 /*
 196                  *      Keep the original string.
 197                  */
 198                 default:
 199                         value = row[3];
 200                         break;
 201                 }
 202         }
 203
 204         /*
 205          *      Create the pair
 206          */
 207         vp = fr_pair_make(ctx, NULL, row[2], NULL, operator);
 208         if (!vp) {
 209                 REDEBUG("Failed to create the pair: %s", fr_strerror());
 210                 return -1;
 211         }
 212
 213         if (do_xlat) {
 214                 if (fr_pair_mark_xlat(vp, value) < 0) {
 215                         REDEBUG("Error marking pair for xlat");
 216
 217                         talloc_free(vp);
 218                         return -1;
 219                 }
 220         } else {
 221                 if (fr_pair_value_from_str(vp, value, -1) < 0) {
 222                         REDEBUG("Error parsing value: %s", fr_strerror());
 223
 224                         talloc_free(vp);
 225                         return -1;
 226                 }
 227         }
 228
 229         /*
 230          *      Add the pair into the packet
 231          */
 232         fr_pair_add(head, vp);
 233         return 0;
 234 }
 235
 236 /** Call the driver's sql_fetch_row function
 237  *
 238  * Calls the driver's sql_fetch_row logging any errors. On success, will
 239  * write row data to (*handle)->row.
 240  *
 241  * @param inst Instance of rlm_sql.
 242  * @param request The Current request, may be NULL.
 243  * @param handle Handle to retrieve errors for.
 244  * @return on success RLM_SQL_OK, other sql_rcode_t constants on error.
 245  */
 246 sql_rcode_t rlm_sql_fetch_row(rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t **handle)
 247 {
 248         int ret;
 249
 250         if (!*handle || !(*handle)->conn) return RLM_SQL_ERROR;
 251
 252         /*
 253          *      We can't implement reconnect logic here, because the caller
 254          *      may require the original connection to free up queries or
 255          *      result sets associated with that connection.
 256          */
 257         ret = (inst->module->sql_fetch_row)(*handle, inst->config);
 258         if (ret < 0) {
 259                 MOD_ROPTIONAL(RERROR, ERROR, "Error fetching row");
 260
 261                 rlm_sql_print_error(inst, request, *handle, false);
 262         }
 263
 264         return ret;
 265 }
 266
 267 /** Retrieve any errors from the SQL driver
 268  *
 269  * Retrieves errors from the driver from the last operation and writes them to
 270  * to request/global log, in the ERROR, WARN, INFO and DEBUG categories.
 271  *
 272  * @param inst Instance of rlm_sql.
 273  * @param request Current request, may be NULL.
 274  * @param handle Handle to retrieve errors for.
 275  * @param force_debug Force all errors to be logged as debug messages.
 276  */
 277 void rlm_sql_print_error(rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t *handle, bool force_debug)
 278 {
 279         char const      *driver;
 280         sql_log_entry_t log[20];
 281         size_t          num, i;
 282
 283         num = (inst->module->sql_error)(handle->log_ctx, log, (sizeof(log) / sizeof(*log)), handle, inst->config);
 284         if (num == 0) {
 285                 MOD_ROPTIONAL(RERROR, ERROR, "Unknown error");
 286                 return;
 287         }
 288
 289         driver = inst->config->sql_driver_name;
 290
 291         for (i = 0; i < num; i++) {
 292                 if (force_debug) goto debug;
 293
 294                 switch (log[i].type) {
 295                 case L_ERR:
 296                         MOD_ROPTIONAL(RERROR, ERROR, "%s: %s", driver, log[i].msg);
 297                         break;
 298
 299                 case L_WARN:
 300                         MOD_ROPTIONAL(RWARN, WARN, "%s: %s", driver, log[i].msg);
 301                         break;
 302
 303                 case L_INFO:
 304                         MOD_ROPTIONAL(RINFO, INFO, "%s: %s", driver, log[i].msg);
 305                         break;
 306
 307                 case L_DBG:
 308                 default:
 309                 debug:
 310                         MOD_ROPTIONAL(RDEBUG, DEBUG, "%s: %s", driver, log[i].msg);
 311                         break;
 312                 }
 313         }
 314
 315         talloc_free_children(handle->log_ctx);
 316 }
 317
 318 /** Call the driver's sql_query method, reconnecting if necessary.
 319  *
 320  * @note Caller must call (inst->module->sql_finish_query)(handle, inst->config);
 321  *      after they're done with the result.
 322  *
 323  * @param handle to query the database with. *handle should not be NULL, as this indicates
 324  *      previous reconnection attempt has failed.
 325  * @param request Current request.
 326  * @param inst rlm_sql instance data.
 327  * @param query to execute. Should not be zero length.
 328  * @return RLM_SQL_OK on success, RLM_SQL_RECONNECT if a new handle is required
 329  *      (also sets *handle = NULL), RLM_SQL_QUERY_INVALID/RLM_SQL_ERROR on invalid query or
 330  *      connection error, RLM_SQL_ALT_QUERY on constraints violation.
 331  */
 332 sql_rcode_t rlm_sql_query(rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t **handle, char const *query)
 333 {
 334         int ret = RLM_SQL_ERROR;
 335         int i, count;
 336
 337         /* Caller should check they have a valid handle */
 338         rad_assert(*handle);
 339
 340         /* There's no query to run, return an error */
 341         if (query[0] == '\0') {
 342                 if (request) REDEBUG("Zero length query");
 343                 return RLM_SQL_QUERY_INVALID;
 344         }
 345
 346         /*
 347          *  inst->pool may be NULL is this function is called by mod_conn_create.
 348          */
 349         count = inst->pool ? fr_connection_pool_get_num(inst->pool) : 0;
 350
 351         /*
 352          *  Here we try with each of the existing connections, then try to create
 353          *  a new connection, then give up.
 354          */
 355         for (i = 0; i < (count + 1); i++) {
 356                 MOD_ROPTIONAL(RDEBUG2, DEBUG2, "Executing query: %s", query);
 357
 358                 ret = (inst->module->sql_query)(*handle, inst->config, query);
 359                 switch (ret) {
 360                 case RLM_SQL_OK:
 361                         break;
 362
 363                 /*
 364                  *      Run through all available sockets until we exhaust all existing
 365                  *      sockets in the pool and fail to establish a *new* connection.
 366                  */
 367                 case RLM_SQL_RECONNECT:
 368                         *handle = fr_connection_reconnect(inst->pool, *handle);
 369                         /* Reconnection failed */
 370                         if (!*handle) return RLM_SQL_RECONNECT;
 371                         /* Reconnection succeeded, try again with the new handle */
 372                         continue;
 373
 374                 /*
 375                  *      These are bad and should make rlm_sql return invalid
 376                  */
 377                 case RLM_SQL_QUERY_INVALID:
 378                         rlm_sql_print_error(inst, request, *handle, false);
 379                         (inst->module->sql_finish_query)(*handle, inst->config);
 380                         break;
 381
 382                 /*
 383                  *      Server or client errors.
 384                  *
 385                  *      If the driver claims to be able to distinguish between
 386                  *      duplicate row errors and other errors, and we hit a
 387                  *      general error treat it as a failure.
 388                  *
 389                  *      Otherwise rewrite it to RLM_SQL_ALT_QUERY.
 390                  */
 391                 case RLM_SQL_ERROR:
 392                         if (inst->module->flags & RLM_SQL_RCODE_FLAGS_ALT_QUERY) {
 393                                 rlm_sql_print_error(inst, request, *handle, false);
 394                                 (inst->module->sql_finish_query)(*handle, inst->config);
 395                                 break;
 396                         }
 397                         ret = RLM_SQL_ALT_QUERY;
 398                         /* FALL-THROUGH */
 399
 400                 /*
 401                  *      Driver suggested using an alternative query
 402                  */
 403                 case RLM_SQL_ALT_QUERY:
 404                         rlm_sql_print_error(inst, request, *handle, true);
 405                         (inst->module->sql_finish_query)(*handle, inst->config);
 406                         break;
 407
 408                 }
 409
 410                 return ret;
 411         }
 412
 413         MOD_ROPTIONAL(RERROR, ERROR, "Hit reconnection limit");
 414
 415         return RLM_SQL_ERROR;
 416 }
 417
 418 /** Call the driver's sql_select_query method, reconnecting if necessary.
 419  *
 420  * @note Caller must call (inst->module->sql_finish_select_query)(handle, inst->config);
 421  *      after they're done with the result.
 422  *
 423  * @param inst rlm_sql instance data.
 424  * @param request Current request.
 425  * @param handle to query the database with. *handle should not be NULL, as this indicates
 426  *        previous reconnection attempt has failed.
 427  * @param query to execute. Should not be zero length.
 428  * @return RLM_SQL_OK on success, RLM_SQL_RECONNECT if a new handle is required (also sets *handle = NULL),
 429  *         RLM_SQL_QUERY_INVALID/RLM_SQL_ERROR on invalid query or connection error.
 430  */
 431 sql_rcode_t rlm_sql_select_query(rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t **handle,  char const *query)
 432 {
 433         int ret = RLM_SQL_ERROR;
 434         int i, count;
 435
 436         /* Caller should check they have a valid handle */
 437         rad_assert(*handle);
 438
 439         /* There's no query to run, return an error */
 440         if (query[0] == '\0') {
 441                 if (request) REDEBUG("Zero length query");
 442
 443                 return RLM_SQL_QUERY_INVALID;
 444         }
 445
 446         /*
 447          *  inst->pool may be NULL is this function is called by mod_conn_create.
 448          */
 449         count = inst->pool ? fr_connection_pool_get_num(inst->pool) : 0;
 450
 451         /*
 452          *  For sanity, for when no connections are viable, and we can't make a new one
 453          */
 454         for (i = 0; i < (count + 1); i++) {
 455                 MOD_ROPTIONAL(RDEBUG2, DEBUG2, "Executing select query: %s", query);
 456
 457                 ret = (inst->module->sql_select_query)(*handle, inst->config, query);
 458                 switch (ret) {
 459                 case RLM_SQL_OK:
 460                         break;
 461
 462                 /*
 463                  *      Run through all available sockets until we exhaust all existing
 464                  *      sockets in the pool and fail to establish a *new* connection.
 465                  */
 466                 case RLM_SQL_RECONNECT:
 467                         *handle = fr_connection_reconnect(inst->pool, *handle);
 468                         /* Reconnection failed */
 469                         if (!*handle) return RLM_SQL_RECONNECT;
 470                         /* Reconnection succeeded, try again with the new handle */
 471                         continue;
 472
 473                 case RLM_SQL_QUERY_INVALID:
 474                 case RLM_SQL_ERROR:
 475                 default:
 476                         rlm_sql_print_error(inst, request, *handle, false);
 477                         (inst->module->sql_finish_select_query)(*handle, inst->config);
 478                         break;
 479                 }
 480
 481                 return ret;
 482         }
 483
 484         MOD_ROPTIONAL(RERROR, ERROR, "Hit reconnection limit");
 485
 486         return RLM_SQL_ERROR;
 487 }
 488
 489
 490 /*************************************************************************
 491  *
 492  *      Function: sql_getvpdata
 493  *
 494  *      Purpose: Get any group check or reply pairs
 495  *
 496  *************************************************************************/
 497 int sql_getvpdata(TALLOC_CTX *ctx, rlm_sql_t *inst, REQUEST *request, rlm_sql_handle_t **handle,
 498                   VALUE_PAIR **pair, char const *query)
 499 {
 500         rlm_sql_row_t   row;
 501         int             rows = 0;
 502         sql_rcode_t     rcode;
 503
 504         rad_assert(request);
 505
 506         rcode = rlm_sql_select_query(inst, request, handle, query);
 507         if (rcode != RLM_SQL_OK) return -1; /* error handled by rlm_sql_select_query */
 508
 509         while (rlm_sql_fetch_row(inst, request, handle) == 0) {
 510                 row = (*handle)->row;
 511                 if (!row) break;
 512                 if (sql_fr_pair_list_afrom_str(ctx, request, pair, row) != 0) {
 513                         REDEBUG("Error parsing user data from database result");
 514
 515                         (inst->module->sql_finish_select_query)(*handle, inst->config);
 516
 517                         return -1;
 518                 }
 519                 rows++;
 520         }
 521         (inst->module->sql_finish_select_query)(*handle, inst->config);
 522
 523         return rows;
 524 }
 525
 526 /*
 527  *      Log the query to a file.
 528  */
 529 void rlm_sql_query_log(rlm_sql_t *inst, REQUEST *request,
 530                        sql_acct_section_t *section, char const *query)
 531 {
 532         int fd;
 533         char const *filename = NULL;
 534         char *expanded = NULL;
 535         size_t len;
 536         bool failed = false;    /* Write the log message outside of the critical region */
 537
 538         if (section) {
 539                 filename = section->logfile;
 540         } else {
 541                 filename = inst->config->logfile;
 542         }
 543
 544         if (!filename) {
 545                 return;
 546         }
 547
 548         if (radius_axlat(&expanded, request, filename, NULL, NULL) < 0) {
 549                 return;
 550         }
 551
 552         fd = exfile_open(inst->ef, filename, 0640, true);
 553         if (fd < 0) {
 554                 ERROR("rlm_sql (%s): Couldn't open logfile '%s': %s", inst->name,
 555                       expanded, fr_syserror(errno));
 556
 557                 talloc_free(expanded);
 558                 return;
 559         }
 560
 561         len = strlen(query);
 562         if ((write(fd, query, len) < 0) || (write(fd, ";\n", 2) < 0)) {
 563                 failed = true;
 564         }
 565
 566         if (failed) {
 567                 ERROR("rlm_sql (%s): Failed writing to logfile '%s': %s", inst->name, expanded,
 568                       fr_syserror(errno));
 569         }
 570
 571         talloc_free(expanded);
 572         exfile_close(inst->ef, fd);
 573 }