src/modules/rlm_sqlippool/rlm_sqlippool.c

   1 /*
   2  *  rlm_sqlippool.c     rlm_sqlippool - FreeRADIUS SQL IP Pool 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 2002  Globe.Net Communications Limited
  21  * Copyright 2006  The FreeRADIUS server project
  22  * Copyright 2006  Suntel Communications
  23  */
  24
  25 #include <freeradius-devel/ident.h>
  26 RCSID("$Id$")
  27
  28 #include <freeradius-devel/radiusd.h>
  29
  30 #include <ctype.h>
  31
  32 #include <rlm_sql.h>
  33
  34 /*
  35  *      Define a structure for our module configuration.
  36  */
  37 typedef struct rlm_sqlippool_t {
  38         char *sql_instance_name;
  39
  40         int lease_duration;
  41
  42         SQL_INST *sql_inst;
  43
  44         char *pool_name;
  45
  46         /* We ended up removing the init
  47            queries so that its up to user
  48            to create the db structure and put the required
  49            information in there
  50         */
  51                                 /* Allocation sequence */
  52         char *allocate_begin;   /* SQL query to begin */
  53         char *allocate_clear;   /* SQL query to clear an IP */
  54         char *allocate_find;    /* SQL query to find an unused IP */
  55         char *allocate_update;  /* SQL query to mark an IP as used */
  56         char *allocate_commit;  /* SQL query to commit */
  57         char *allocate_rollback; /* SQL query to rollback */
  58
  59         char *pool_check;       /* Query to check for the existence of the pool */
  60
  61                                 /* Start sequence */
  62         char *start_begin;      /* SQL query to begin */
  63         char *start_update;     /* SQL query to update an IP entry */
  64         char *start_commit;     /* SQL query to commit */
  65         char *start_rollback;   /* SQL query to rollback */
  66
  67                                 /* Alive sequence */
  68         char *alive_begin;      /* SQL query to begin */
  69         char *alive_update;     /* SQL query to update an IP entry */
  70         char *alive_commit;     /* SQL query to commit */
  71         char *alive_rollback;   /* SQL query to rollback */
  72
  73                                 /* Stop sequence */
  74         char *stop_begin;       /* SQL query to begin */
  75         char *stop_clear;       /* SQL query to clear an IP */
  76         char *stop_commit;      /* SQL query to commit */
  77         char *stop_rollback;    /* SQL query to rollback */
  78
  79                                 /* On sequence */
  80         char *on_begin;         /* SQL query to begin */
  81         char *on_clear;         /* SQL query to clear an entire NAS */
  82         char *on_commit;        /* SQL query to commit */
  83         char *on_rollback;      /* SQL query to rollback */
  84
  85                                 /* Off sequence */
  86         char *off_begin;        /* SQL query to begin */
  87         char *off_clear;        /* SQL query to clear an entire NAS */
  88         char *off_commit;       /* SQL query to commit */
  89         char *off_rollback;     /* SQL query to rollback */
  90
  91                                 /* Logging Section */
  92         char *log_exists;       /* There was an ip address already assigned */
  93         char *log_success;      /* We successfully allocated ip address from pool */
  94         char *log_clear;        /* We successfully deallocated ip address from pool */
  95         char *log_failed;       /* Failed to allocate ip from the pool */
  96         char *log_nopool;       /* There was no Framed-IP-Address but also no Pool-Name */
  97
  98                                 /* Reserved to handle 255.255.255.254 Requests */
  99         char *defaultpool;      /* Default Pool-Name if there is none in the check items */
 100
 101 } rlm_sqlippool_t;
 102
 103 /*
 104  *      A mapping of configuration file names to internal variables.
 105  *
 106  *      Note that the string is dynamically allocated, so it MUST
 107  *      be freed.  When the configuration file parse re-reads the string,
 108  *      it free's the old one, and strdup's the new one, placing the pointer
 109  *      to the strdup'd string into 'config.string'.  This gets around
 110  *      buffer over-flows.
 111  */
 112 static CONF_PARSER module_config[] = {
 113   {"sql-instance-name",PW_TYPE_STRING_PTR,
 114    offsetof(rlm_sqlippool_t,sql_instance_name), NULL, "sql"},
 115
 116   { "lease-duration", PW_TYPE_INTEGER,
 117     offsetof(rlm_sqlippool_t,lease_duration), NULL, "86400"},
 118
 119   { "pool-name"     , PW_TYPE_STRING_PTR,
 120     offsetof(rlm_sqlippool_t, pool_name), NULL, ""},
 121
 122   { "allocate-begin", PW_TYPE_STRING_PTR,
 123     offsetof(rlm_sqlippool_t,allocate_begin), NULL, "START TRANSACTION" },
 124   { "allocate-clear", PW_TYPE_STRING_PTR,
 125     offsetof(rlm_sqlippool_t,allocate_clear), NULL, "" },
 126   { "allocate-find", PW_TYPE_STRING_PTR,
 127     offsetof(rlm_sqlippool_t,allocate_find), NULL, "" },
 128   { "allocate-update", PW_TYPE_STRING_PTR,
 129     offsetof(rlm_sqlippool_t,allocate_update), NULL, "" },
 130   { "allocate-commit", PW_TYPE_STRING_PTR,
 131     offsetof(rlm_sqlippool_t,allocate_commit), NULL, "COMMIT" },
 132   { "allocate-rollback", PW_TYPE_STRING_PTR,
 133     offsetof(rlm_sqlippool_t,allocate_rollback), NULL, "ROLLBACK" },
 134
 135   { "pool-check", PW_TYPE_STRING_PTR,
 136     offsetof(rlm_sqlippool_t,pool_check), NULL, "" },
 137
 138   { "start-begin", PW_TYPE_STRING_PTR,
 139     offsetof(rlm_sqlippool_t,start_begin), NULL, "START TRANSACTION" },
 140   { "start-update", PW_TYPE_STRING_PTR,
 141     offsetof(rlm_sqlippool_t,start_update), NULL, "" },
 142   { "start-commit", PW_TYPE_STRING_PTR,
 143     offsetof(rlm_sqlippool_t,start_commit), NULL, "COMMIT" },
 144   { "start-rollback", PW_TYPE_STRING_PTR,
 145     offsetof(rlm_sqlippool_t,start_rollback), NULL, "ROLLBACK" },
 146
 147   { "alive-begin", PW_TYPE_STRING_PTR,
 148     offsetof(rlm_sqlippool_t,alive_begin), NULL, "START TRANSACTION" },
 149   { "alive-update", PW_TYPE_STRING_PTR,
 150     offsetof(rlm_sqlippool_t,alive_update), NULL, "" },
 151   { "alive-commit", PW_TYPE_STRING_PTR,
 152     offsetof(rlm_sqlippool_t,alive_commit), NULL, "COMMIT" },
 153   { "alive-rollback", PW_TYPE_STRING_PTR,
 154     offsetof(rlm_sqlippool_t,alive_rollback), NULL, "ROLLBACK" },
 155
 156   { "stop-begin", PW_TYPE_STRING_PTR,
 157     offsetof(rlm_sqlippool_t,stop_begin), NULL, "START TRANSACTION" },
 158   { "stop-clear", PW_TYPE_STRING_PTR,
 159     offsetof(rlm_sqlippool_t,stop_clear), NULL, "" },
 160   { "stop-commit", PW_TYPE_STRING_PTR,
 161     offsetof(rlm_sqlippool_t,stop_commit), NULL, "COMMIT" },
 162   { "stop-rollback", PW_TYPE_STRING_PTR,
 163     offsetof(rlm_sqlippool_t,stop_rollback), NULL, "ROLLBACK" },
 164
 165   { "on-begin", PW_TYPE_STRING_PTR,
 166     offsetof(rlm_sqlippool_t,on_begin), NULL, "START TRANSACTION" },
 167   { "on-clear", PW_TYPE_STRING_PTR,
 168     offsetof(rlm_sqlippool_t,on_clear), NULL, "" },
 169   { "on-commit", PW_TYPE_STRING_PTR,
 170     offsetof(rlm_sqlippool_t,on_commit), NULL, "COMMIT" },
 171   { "on-rollback", PW_TYPE_STRING_PTR,
 172     offsetof(rlm_sqlippool_t,on_rollback), NULL, "ROLLBACK" },
 173
 174   { "off-begin", PW_TYPE_STRING_PTR,
 175     offsetof(rlm_sqlippool_t,off_begin), NULL, "START TRANSACTION" },
 176   { "off-clear", PW_TYPE_STRING_PTR,
 177     offsetof(rlm_sqlippool_t,off_clear), NULL, "" },
 178   { "off-commit", PW_TYPE_STRING_PTR,
 179     offsetof(rlm_sqlippool_t,off_commit), NULL, "COMMIT" },
 180   { "off-rollback", PW_TYPE_STRING_PTR,
 181     offsetof(rlm_sqlippool_t,off_rollback), NULL, "ROLLBACK" },
 182
 183   { "sqlippool_log_exists", PW_TYPE_STRING_PTR,
 184     offsetof(rlm_sqlippool_t, log_exists), NULL, "" },
 185   { "sqlippool_log_success", PW_TYPE_STRING_PTR,
 186     offsetof(rlm_sqlippool_t, log_success), NULL, "" },
 187   { "sqlippool_log_clear", PW_TYPE_STRING_PTR,
 188     offsetof(rlm_sqlippool_t, log_clear), NULL, "" },
 189   { "sqlippool_log_failed", PW_TYPE_STRING_PTR,
 190     offsetof(rlm_sqlippool_t, log_failed), NULL, "" },
 191   { "sqlippool_log_nopool", PW_TYPE_STRING_PTR,
 192     offsetof(rlm_sqlippool_t, log_nopool), NULL, "" },
 193
 194   { "defaultpool", PW_TYPE_STRING_PTR,
 195     offsetof(rlm_sqlippool_t, defaultpool), NULL, "main_pool" },
 196
 197   { NULL, -1, 0, NULL, NULL }
 198 };
 199
 200 /*
 201  *      Replace %<whatever> in a string.
 202  *
 203  *      %P      pool_name
 204  *      %I      param
 205  *      %J      lease_duration
 206  *
 207  */
 208 static int sqlippool_expand(char * out, int outlen, const char * fmt,
 209                             rlm_sqlippool_t *data, char * param, int param_len)
 210 {
 211         char *q;
 212         const char *p;
 213         char tmp[40]; /* For temporary storing of integers */
 214
 215         q = out;
 216         for (p = fmt; *p ; p++) {
 217                 int freespace;
 218                 int c;
 219
 220                 /* Calculate freespace in output */
 221                 freespace = outlen - (q - out);
 222                 if (freespace <= 1)
 223                         break;
 224
 225                 c = *p;
 226                 if (c != '%' && c != '$' && c != '\\') {
 227                         *q++ = *p;
 228                         continue;
 229                 }
 230
 231                 if (*++p == '\0')
 232                         break;
 233
 234                 if (c == '\\') {
 235                         switch(*p) {
 236                         case '\\':
 237                                 *q++ = '\\';
 238                                 break;
 239                         case 't':
 240                                 *q++ = '\t';
 241                                 break;
 242                         case 'n':
 243                                 *q++ = '\n';
 244                                 break;
 245                         default:
 246                                 *q++ = c;
 247                                 *q++ = *p;
 248                                 break;
 249                         }
 250                 }
 251                 else if (c == '%') {
 252                         switch(*p) {
 253                         case '%':
 254                                 *q++ = *p;
 255                                 break;
 256                         case 'P': /* pool name */
 257                                 strlcpy(q, data->pool_name, freespace);
 258                                 q += strlen(q);
 259                                 break;
 260                         case 'I': /* IP address */
 261                                 if (param && param_len > 0) {
 262                                         if (param_len > freespace) {
 263                                                 strlcpy(q, param, freespace);
 264                                                 q += strlen(q);
 265                                         }
 266                                         else {
 267                                                 memcpy(q, param, param_len);
 268                                                 q += param_len;
 269                                         }
 270                                 }
 271                                 break;
 272                         case 'J': /* lease duration */
 273                                 sprintf(tmp, "%d", data->lease_duration);
 274                                 strlcpy(q, tmp, freespace);
 275                                 q += strlen(q);
 276                                 break;
 277                         default:
 278                                 *q++ = '%';
 279                                 *q++ = *p;
 280                                 break;
 281                         }
 282                 }
 283         }
 284         *q = '\0';
 285
 286 #if 0
 287         DEBUG2("sqlippool_expand: '%s'", out);
 288 #endif
 289
 290         return strlen(out);
 291 }
 292
 293 /*
 294  * Query the database executing a command with no result rows
 295  */
 296 static int sqlippool_command(const char * fmt, SQLSOCK * sqlsocket,
 297                              rlm_sqlippool_t *data, REQUEST * request,
 298                              char * param, int param_len)
 299 {
 300         char expansion[MAX_QUERY_LEN];
 301         char query[MAX_QUERY_LEN];
 302
 303         sqlippool_expand(expansion, sizeof(expansion),
 304                          fmt, data, param, param_len);
 305
 306         /*
 307          * Do an xlat on the provided string
 308          */
 309         if (request) {
 310                 if (!radius_xlat(query, sizeof(query), expansion, request, data->sql_inst->sql_escape_func)) {
 311                         radlog(L_ERR, "sqlippool_command: xlat failed on: '%s'", query);
 312                         return 0;
 313                 }
 314         } else {
 315                 strcpy(query, expansion);
 316         }
 317
 318 #if 0
 319         DEBUG2("sqlippool_command: '%s'", query);
 320 #endif
 321         if (data->sql_inst->sql_query(sqlsocket, data->sql_inst, query)){
 322                 radlog(L_ERR, "sqlippool_command: database query error in: '%s'", query);
 323                 return 0;
 324         }
 325
 326         (data->sql_inst->module->sql_finish_query)(sqlsocket,
 327                                                    data->sql_inst->config);
 328         return 0;
 329 }
 330
 331 /*
 332  * Query the database expecting a single result row
 333  */
 334 static int sqlippool_query1(char * out, int outlen, const char * fmt,
 335                             SQLSOCK * sqlsocket, rlm_sqlippool_t *data,
 336                             REQUEST * request, char * param, int param_len)
 337 {
 338         char expansion[MAX_QUERY_LEN];
 339         char query[MAX_QUERY_LEN];
 340         int rlen, retval = 0;
 341
 342         sqlippool_expand(expansion, sizeof(expansion),
 343                          fmt, data, param, param_len);
 344
 345         /*
 346          * Do an xlat on the provided string
 347          */
 348         if (request) {
 349                 if (!radius_xlat(query, sizeof(query), expansion, request, data->sql_inst->sql_escape_func)) {
 350                         radlog(L_ERR, "sqlippool_command: xlat failed.");
 351                         out[0] = '\0';
 352                         return 0;
 353                 }
 354         }
 355         else {
 356                 strcpy(query, expansion);
 357         }
 358
 359         if (data->sql_inst->sql_select_query(sqlsocket, data->sql_inst, query)){
 360                 radlog(L_ERR, "sqlippool_query1: database query error");
 361                 out[0] = '\0';
 362                 return 0;
 363         }
 364
 365         out[0] = '\0';
 366
 367         if (!data->sql_inst->sql_fetch_row(sqlsocket, data->sql_inst)) {
 368                 if (sqlsocket->row) {
 369                         if (sqlsocket->row[0]) {
 370                                 if ((rlen = strlen(sqlsocket->row[0])) < outlen) {
 371                                         strcpy(out, sqlsocket->row[0]);
 372                                         retval = rlen;
 373                                 } else {
 374                                         RDEBUG("insufficient string space");
 375                                 }
 376                         } else {
 377                                 RDEBUG("row[0] returned NULL");
 378                         }
 379                 } else {
 380                         RDEBUG("SQL query did not return any results");
 381                 }
 382         } else {
 383                 RDEBUG("SQL query did not succeed");
 384         }
 385
 386         (data->sql_inst->module->sql_finish_select_query)(sqlsocket,
 387                                                           data->sql_inst->config);
 388         return retval;
 389 }
 390
 391 static int sqlippool_detach(void *instance)
 392 {
 393         free(instance);
 394         return 0;
 395 }
 396
 397 #define IS_EMPTY(_x) (!_x ||!*_x)
 398
 399 /*
 400  *      Do any per-module initialization that is separate to each
 401  *      configured instance of the module.  e.g. set up connections
 402  *      to external databases, read configuration files, set up
 403  *      dictionary entries, etc.
 404  *
 405  *      If configuration information is given in the config section
 406  *      that must be referenced in later calls, store a handle to it
 407  *      in *instance otherwise put a null pointer there.
 408  */
 409 static int sqlippool_instantiate(CONF_SECTION * conf, void ** instance)
 410 {
 411         module_instance_t *modinst;
 412         rlm_sqlippool_t * data;
 413         const char * pool_name = NULL;
 414
 415         /*
 416          *      Set up a storage area for instance data
 417          */
 418         data = rad_malloc(sizeof(*data));
 419         memset(data, 0, sizeof(*data));
 420
 421         /*
 422          *      If the configuration parameters can't be parsed, then
 423          *      fail.
 424          */
 425         if (cf_section_parse(conf, data, module_config) < 0) {
 426                 free(data);
 427                 return -1;
 428         }
 429
 430         if (IS_EMPTY(data->sql_instance_name)) {
 431                 radlog(L_ERR, "rlm_sqlippool: the 'sql-instance-name' variable must be set.");
 432                 sqlippool_detach(data);
 433                 return -1;
 434         }
 435
 436         /*
 437          *      Check that all the queries are in place
 438          */
 439
 440         if (IS_EMPTY(data->allocate_clear)) {
 441                 radlog(L_ERR, "rlm_sqlippool: the 'allocate-clear' statement must be set.");
 442                 sqlippool_detach(data);
 443                 return -1;
 444         }
 445
 446         if (IS_EMPTY(data->allocate_find)) {
 447                 radlog(L_ERR, "rlm_sqlippool: the 'allocate_find' statement must be set.");
 448                 sqlippool_detach(data);
 449                 return -1;
 450         }
 451
 452         if (IS_EMPTY(data->allocate_update)) {
 453                 radlog(L_ERR, "rlm_sqlippool: the 'allocate_update' statement must be set.");
 454                 sqlippool_detach(data);
 455                 return -1;
 456         }
 457
 458         if (IS_EMPTY(data->start_update)) {
 459                 radlog(L_ERR, "rlm_sqlippool: the 'start-update' statement must be set.");
 460                 sqlippool_detach(data);
 461                 return -1;
 462         }
 463
 464         if (IS_EMPTY(data->alive_update)) {
 465                 radlog(L_ERR, "rlm_sqlippool: the 'alive-update' statement must be set.");
 466                 sqlippool_detach(data);
 467                 return -1;
 468         }
 469
 470         if (IS_EMPTY(data->stop_clear)) {
 471                 radlog(L_ERR, "rlm_sqlippool: the 'stop-clear' statement must be set.");
 472                 sqlippool_detach(data);
 473                 return -1;
 474         }
 475
 476         if (IS_EMPTY(data->on_clear)) {
 477                 radlog(L_ERR, "rlm_sqlippool: the 'on-clear' statement must be set.");
 478                 sqlippool_detach(data);
 479                 return -1;
 480         }
 481
 482         if (IS_EMPTY(data->off_clear)) {
 483                 radlog(L_ERR, "rlm_sqlippool: the 'off-clear' statement must be set.");
 484                 sqlippool_detach(data);
 485                 return -1;
 486         }
 487
 488         pool_name = cf_section_name2(conf);
 489         if (pool_name != NULL)
 490                 data->pool_name = strdup(pool_name);
 491         else
 492                 data->pool_name = strdup("ippool");
 493
 494         modinst = find_module_instance(cf_section_find("modules"),
 495                                        data->sql_instance_name, 1);
 496         if (!modinst) {
 497                 radlog(L_ERR, "sqlippool_instantiate: failed to find sql instance named %s", data->sql_instance_name);
 498                 sqlippool_detach(data);
 499                 return -1;
 500         }
 501
 502         if (strcmp(modinst->entry->name, "rlm_sql") != 0) {
 503                 radlog(L_ERR, "sqlippool_instantiate: Module \"%s\""
 504                        " is not an instance of the rlm_sql module",
 505                        data->sql_instance_name);
 506                 sqlippool_detach(data);
 507                 return -1;
 508         }
 509
 510         data->sql_inst = (SQL_INST *) modinst->insthandle;
 511
 512         *instance = data;
 513         return 0;
 514 }
 515
 516
 517 /*
 518  * if we have something to log, then we log it
 519  * otherwise we return the retcode as soon as possible
 520  */
 521 static int do_logging(char *str, int retcode)
 522 {
 523         if (str && (*str != '\0'))
 524                 radlog(L_INFO,"%s", str);
 525         return retcode;
 526 }
 527
 528
 529 /*
 530  *      Allocate an IP number from the pool.
 531  */
 532 static int sqlippool_postauth(void *instance, REQUEST * request)
 533 {
 534         rlm_sqlippool_t * data = (rlm_sqlippool_t *) instance;
 535         char allocation[MAX_STRING_LEN];
 536         int allocation_len;
 537         uint32_t ip_allocation;
 538         VALUE_PAIR * vp;
 539         SQLSOCK * sqlsocket;
 540         fr_ipaddr_t ipaddr;
 541         char    logstr[MAX_STRING_LEN];
 542         char sqlusername[MAX_STRING_LEN];
 543
 544         /*
 545          * If there is a Framed-IP-Address attribute in the reply do nothing
 546          */
 547         if (pairfind(request->reply->vps, PW_FRAMED_IP_ADDRESS, 0) != NULL) {
 548                 /* We already have a Framed-IP-Address */
 549                 radius_xlat(logstr, sizeof(logstr), data->log_exists,
 550                             request, NULL);
 551                 RDEBUG("Framed-IP-Address already exists");
 552
 553                 return do_logging(logstr, RLM_MODULE_NOOP);
 554         }
 555
 556         if (pairfind(request->config_items, PW_POOL_NAME, 0) == NULL) {
 557                 RDEBUG("No Pool-Name defined.");
 558                 radius_xlat(logstr, sizeof(logstr), data->log_nopool,
 559                             request, NULL);
 560
 561                 return do_logging(logstr, RLM_MODULE_NOOP);
 562         }
 563
 564         sqlsocket = data->sql_inst->sql_get_socket(data->sql_inst);
 565         if (sqlsocket == NULL) {
 566                 RDEBUG("cannot allocate sql connection");
 567                 return RLM_MODULE_FAIL;
 568         }
 569
 570         if (data->sql_inst->sql_set_user(data->sql_inst, request, sqlusername, NULL) < 0) {
 571                 return RLM_MODULE_FAIL;
 572         }
 573
 574         /*
 575          * BEGIN
 576          */
 577         sqlippool_command(data->allocate_begin, sqlsocket, data, request,
 578                           (char *) NULL, 0);
 579
 580         /*
 581          * CLEAR
 582          */
 583         sqlippool_command(data->allocate_clear, sqlsocket, data, request,
 584                           (char *) NULL, 0);
 585
 586         /*
 587          * FIND
 588          */
 589         allocation_len = sqlippool_query1(allocation, sizeof(allocation),
 590                                           data->allocate_find, sqlsocket,
 591                                           data, request, (char *) NULL, 0);
 592
 593         /*
 594          *      Nothing found...
 595          */
 596         if (allocation_len == 0) {
 597                 /*
 598                  * COMMIT
 599                  */
 600                 sqlippool_command(data->allocate_commit, sqlsocket, instance,
 601                                   request, (char *) NULL, 0);
 602
 603                 /*
 604                  * Should we perform pool-check ?
 605                  */
 606                 if (data->pool_check && *data->pool_check) {
 607
 608                         /*
 609                          * Ok, so the allocate-find query found nothing ...
 610                          * Let's check if the pool exists at all
 611                          */
 612                         allocation_len = sqlippool_query1(allocation, sizeof(allocation),
 613                                                  data->pool_check, sqlsocket, data, request,
 614                                                 (char *) NULL, 0);
 615
 616                         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 617
 618                         if (allocation_len) {
 619
 620                                 /*
 621                                  *      Pool exists after all... So,
 622                                  *      the failure to allocate the IP
 623                                  *      address was most likely due to
 624                                  *      the depletion of the pool. In
 625                                  *      that case, we should return
 626                                  *      NOTFOUND
 627                                  */
 628                                 RDEBUG("pool appears to be full");
 629                                 radius_xlat(logstr, sizeof(logstr), data->log_failed, request, NULL);
 630                                 return do_logging(logstr, RLM_MODULE_NOTFOUND);
 631
 632                         }
 633
 634                         /*
 635                          *      Pool doesn't exist in the table. It
 636                          *      may be handled by some other instance of
 637                          *      sqlippool, so we should just ignore this
 638                          *      allocation failure and return NOOP
 639                          */
 640                         RDEBUG("IP address could not be allocated as no pool exists with that name.");
 641                         return RLM_MODULE_NOOP;
 642
 643                 }
 644
 645                 data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 646
 647                 RDEBUG("IP address could not be allocated.");
 648                 radius_xlat(logstr, sizeof(logstr), data->log_failed,
 649                             request, NULL);
 650
 651                 return do_logging(logstr, RLM_MODULE_NOOP);
 652         }
 653
 654
 655         /*
 656          *  FIXME: Make it work with the ipv6 addresses
 657          */
 658         if ((ip_hton(allocation, AF_INET, &ipaddr) < 0) ||
 659             ((ip_allocation = ipaddr.ipaddr.ip4addr.s_addr) == INADDR_NONE)) {
 660                 /*
 661                  * COMMIT
 662                  */
 663                 sqlippool_command(data->allocate_commit, sqlsocket, instance,
 664                                   request, (char *) NULL, 0);
 665
 666                 RDEBUG("Invalid IP number [%s] returned from database query.", allocation);
 667                 data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 668                 radius_xlat(logstr, sizeof(logstr), data->log_failed,
 669                             request, NULL);
 670
 671                 return do_logging(logstr, RLM_MODULE_NOOP);
 672         }
 673
 674         /*
 675          * UPDATE
 676          */
 677         sqlippool_command(data->allocate_update, sqlsocket, data, request,
 678                           allocation, allocation_len);
 679
 680         RDEBUG("Allocated IP %s [%08x]", allocation, ip_allocation);
 681
 682         vp = radius_paircreate(request, &request->reply->vps,
 683                                PW_FRAMED_IP_ADDRESS, 0, PW_TYPE_IPADDR);
 684         vp->vp_ipaddr = ip_allocation;
 685
 686         /*
 687          * COMMIT
 688          */
 689         sqlippool_command(data->allocate_commit, sqlsocket, data, request,
 690                           (char *) NULL, 0);
 691
 692         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 693         radius_xlat(logstr, sizeof(logstr), data->log_success, request, NULL);
 694
 695         return do_logging(logstr, RLM_MODULE_OK);
 696 }
 697
 698 static int sqlippool_accounting_start(SQLSOCK * sqlsocket,
 699                                       rlm_sqlippool_t *data, REQUEST *request)
 700 {
 701         /*
 702          * BEGIN
 703          */
 704         sqlippool_command(data->start_begin, sqlsocket, data, request,
 705                           (char *) NULL, 0);
 706
 707         /*
 708          * UPDATE
 709          */
 710         sqlippool_command(data->start_update, sqlsocket, data, request,
 711                           (char *) NULL, 0);
 712
 713         /*
 714          * COMMIT
 715          */
 716         sqlippool_command(data->start_commit, sqlsocket, data, request,
 717                           (char *) NULL, 0);
 718
 719         return RLM_MODULE_OK;
 720 }
 721
 722 static int sqlippool_accounting_alive(SQLSOCK * sqlsocket,
 723                                       rlm_sqlippool_t *data, REQUEST *request)
 724 {
 725         /*
 726          * BEGIN
 727          */
 728         sqlippool_command(data->alive_begin, sqlsocket, data, request,
 729                           (char *) NULL, 0);
 730
 731         /*
 732          * UPDATE
 733          */
 734         sqlippool_command(data->alive_update, sqlsocket, data, request,
 735                           (char *) NULL, 0);
 736
 737         /*
 738          * COMMIT
 739          */
 740         sqlippool_command(data->alive_commit, sqlsocket, data, request,
 741                           (char *) NULL, 0);
 742
 743         return RLM_MODULE_OK;
 744 }
 745
 746 static int sqlippool_accounting_stop(SQLSOCK * sqlsocket,
 747                                       rlm_sqlippool_t *data, REQUEST *request)
 748 {
 749         char    logstr[MAX_STRING_LEN];
 750
 751         /*
 752          * BEGIN
 753          */
 754         sqlippool_command(data->stop_begin, sqlsocket, data, request,
 755                           (char *) NULL, 0);
 756
 757         /*
 758          * CLEAR
 759          */
 760         sqlippool_command(data->stop_clear, sqlsocket, data, request,
 761                           (char *) NULL, 0);
 762
 763         /*
 764          * COMMIT
 765          */
 766         sqlippool_command(data->stop_commit, sqlsocket, data, request,
 767                           (char *) NULL, 0);
 768
 769         radius_xlat(logstr, sizeof(logstr), data->log_clear, request, NULL);
 770
 771         return do_logging(logstr, RLM_MODULE_OK);
 772 }
 773
 774 static int sqlippool_accounting_on(SQLSOCK * sqlsocket,
 775                                       rlm_sqlippool_t *data, REQUEST *request)
 776 {
 777         /*
 778          * BEGIN
 779          */
 780         sqlippool_command(data->on_begin, sqlsocket, data, request,
 781                           (char *) NULL, 0);
 782
 783         /*
 784          * CLEAR
 785          */
 786         sqlippool_command(data->on_clear, sqlsocket, data, request,
 787                           (char *) NULL, 0);
 788
 789         /*
 790          * COMMIT
 791          */
 792         sqlippool_command(data->on_commit, sqlsocket, data, request,
 793                           (char *) NULL, 0);
 794
 795         return RLM_MODULE_OK;
 796 }
 797
 798 static int sqlippool_accounting_off(SQLSOCK * sqlsocket,
 799                                       rlm_sqlippool_t *data, REQUEST *request)
 800 {
 801         /*
 802          * BEGIN
 803          */
 804         sqlippool_command(data->off_begin, sqlsocket, data, request,
 805                           (char *) NULL, 0);
 806
 807         /*
 808          * CLEAR
 809          */
 810         sqlippool_command(data->off_clear, sqlsocket, data, request,
 811                           (char *) NULL, 0);
 812
 813         /*
 814          * COMMIT
 815          */
 816         sqlippool_command(data->off_commit, sqlsocket, data, request,
 817                           (char *) NULL, 0);
 818
 819         return RLM_MODULE_OK;
 820 }
 821
 822 /*
 823  *      Check for an Accounting-Stop
 824  *      If we find one and we have allocated an IP to this nas/port
 825  *      combination, then deallocate it.
 826  */
 827 static int sqlippool_accounting(void * instance, REQUEST * request)
 828 {
 829         int rcode;
 830         VALUE_PAIR * vp;
 831         int acct_status_type;
 832         rlm_sqlippool_t * data = (rlm_sqlippool_t *) instance;
 833         SQLSOCK * sqlsocket;
 834         char sqlusername[MAX_STRING_LEN];
 835
 836         vp = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0);
 837         if (!vp) {
 838                 RDEBUG("Could not find account status type in packet.");
 839                 return RLM_MODULE_NOOP;
 840         }
 841         acct_status_type = vp->vp_integer;
 842
 843         switch (acct_status_type) {
 844         case PW_STATUS_START:
 845         case PW_STATUS_ALIVE:
 846         case PW_STATUS_STOP:
 847         case PW_STATUS_ACCOUNTING_ON:
 848         case PW_STATUS_ACCOUNTING_OFF:
 849                 break;          /* continue through to the next section */
 850
 851         default:
 852                 /* We don't care about any other accounting packet */
 853                 return RLM_MODULE_NOOP;
 854         }
 855
 856         sqlsocket = data->sql_inst->sql_get_socket(data->sql_inst);
 857         if (sqlsocket == NULL) {
 858                 RDEBUG("cannot allocate sql connection");
 859                 return RLM_MODULE_NOOP;
 860         }
 861
 862         if (data->sql_inst->sql_set_user(data->sql_inst, request, sqlusername, NULL) < 0) {
 863                 return RLM_MODULE_FAIL;
 864         }
 865
 866         switch (acct_status_type) {
 867         case PW_STATUS_START:
 868                 rcode = sqlippool_accounting_start(sqlsocket, data, request);
 869                 break;
 870
 871         case PW_STATUS_ALIVE:
 872                 rcode = sqlippool_accounting_alive(sqlsocket, data, request);
 873                 break;
 874
 875         case PW_STATUS_STOP:
 876                 rcode = sqlippool_accounting_stop(sqlsocket, data, request);
 877                 break;
 878
 879         case PW_STATUS_ACCOUNTING_ON:
 880                 rcode = sqlippool_accounting_on(sqlsocket, data, request);
 881                 break;
 882
 883         case PW_STATUS_ACCOUNTING_OFF:
 884                 rcode = sqlippool_accounting_off(sqlsocket, data, request);
 885                 break;
 886
 887         default:
 888                 /* We don't care about any other accounting packet */
 889                 return RLM_MODULE_NOOP;
 890         }
 891
 892         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 893
 894         return rcode;
 895 }
 896
 897 /*
 898  *      The module name should be the only globally exported symbol.
 899  *      That is, everything else should be 'static'.
 900  *
 901  *      If the module needs to temporarily modify it's instantiation
 902  *      data, the type should be changed to RLM_TYPE_THREAD_UNSAFE.
 903  *      The server will then take care of ensuring that the module
 904  *      is single-threaded.
 905  */
 906 module_t rlm_sqlippool = {
 907         RLM_MODULE_INIT,
 908         "SQL IP Pool",
 909         RLM_TYPE_THREAD_SAFE,           /* type */
 910         sqlippool_instantiate,          /* instantiation */
 911         sqlippool_detach,               /* detach */
 912         {
 913                 NULL,                   /* authentication */
 914                 NULL,                   /* authorization */
 915                 NULL,                   /* preaccounting */
 916                 sqlippool_accounting,   /* accounting */
 917                 NULL,                   /* checksimul */
 918                 NULL,                   /* pre-proxy */
 919                 NULL,                   /* post-proxy */
 920                 sqlippool_postauth      /* post-auth */
 921         },
 922 };