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