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, data->sql_inst)) {
 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, data->sql_inst)) {
 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
 543         /*
 544          * If there is a Framed-IP-Address attribute in the reply do nothing
 545          */
 546         if (pairfind(request->reply->vps, PW_FRAMED_IP_ADDRESS, 0, TAG_ANY) != NULL) {
 547                 /* We already have a Framed-IP-Address */
 548                 radius_xlat(logstr, sizeof(logstr), data->log_exists,
 549                             request, NULL, NULL);
 550                 RDEBUG("Framed-IP-Address already exists");
 551
 552                 return do_logging(logstr, RLM_MODULE_NOOP);
 553         }
 554
 555         if (pairfind(request->config_items, PW_POOL_NAME, 0, TAG_ANY) == NULL) {
 556                 RDEBUG("No Pool-Name defined.");
 557                 radius_xlat(logstr, sizeof(logstr), data->log_nopool,
 558                             request, NULL, NULL);
 559
 560                 return do_logging(logstr, RLM_MODULE_NOOP);
 561         }
 562
 563         sqlsocket = data->sql_inst->sql_get_socket(data->sql_inst);
 564         if (sqlsocket == NULL) {
 565                 RDEBUG("cannot allocate sql connection");
 566                 return RLM_MODULE_FAIL;
 567         }
 568
 569         if (data->sql_inst->sql_set_user(data->sql_inst, request, NULL) < 0) {
 570                 return RLM_MODULE_FAIL;
 571         }
 572
 573         /*
 574          * BEGIN
 575          */
 576         sqlippool_command(data->allocate_begin, sqlsocket, data, request,
 577                           (char *) NULL, 0);
 578
 579         /*
 580          * CLEAR
 581          */
 582         sqlippool_command(data->allocate_clear, sqlsocket, data, request,
 583                           (char *) NULL, 0);
 584
 585         /*
 586          * FIND
 587          */
 588         allocation_len = sqlippool_query1(allocation, sizeof(allocation),
 589                                           data->allocate_find, sqlsocket,
 590                                           data, request, (char *) NULL, 0);
 591
 592         /*
 593          *      Nothing found...
 594          */
 595         if (allocation_len == 0) {
 596                 /*
 597                  * COMMIT
 598                  */
 599                 sqlippool_command(data->allocate_commit, sqlsocket, instance,
 600                                   request, (char *) NULL, 0);
 601
 602                 /*
 603                  * Should we perform pool-check ?
 604                  */
 605                 if (data->pool_check && *data->pool_check) {
 606
 607                         /*
 608                          * Ok, so the allocate-find query found nothing ...
 609                          * Let's check if the pool exists at all
 610                          */
 611                         allocation_len = sqlippool_query1(allocation, sizeof(allocation),
 612                                                  data->pool_check, sqlsocket, data, request,
 613                                                 (char *) NULL, 0);
 614
 615                         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 616
 617                         if (allocation_len) {
 618
 619                                 /*
 620                                  *      Pool exists after all... So,
 621                                  *      the failure to allocate the IP
 622                                  *      address was most likely due to
 623                                  *      the depletion of the pool. In
 624                                  *      that case, we should return
 625                                  *      NOTFOUND
 626                                  */
 627                                 RDEBUG("pool appears to be full");
 628                                 radius_xlat(logstr, sizeof(logstr), data->log_failed, request, NULL, NULL);
 629                                 return do_logging(logstr, RLM_MODULE_NOTFOUND);
 630
 631                         }
 632
 633                         /*
 634                          *      Pool doesn't exist in the table. It
 635                          *      may be handled by some other instance of
 636                          *      sqlippool, so we should just ignore this
 637                          *      allocation failure and return NOOP
 638                          */
 639                         RDEBUG("IP address could not be allocated as no pool exists with that name.");
 640                         return RLM_MODULE_NOOP;
 641
 642                 }
 643
 644                 data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 645
 646                 RDEBUG("IP address could not be allocated.");
 647                 radius_xlat(logstr, sizeof(logstr), data->log_failed,
 648                             request, NULL, NULL);
 649
 650                 return do_logging(logstr, RLM_MODULE_NOOP);
 651         }
 652
 653
 654         /*
 655          *  FIXME: Make it work with the ipv6 addresses
 656          */
 657         if ((ip_hton(allocation, AF_INET, &ipaddr) < 0) ||
 658             ((ip_allocation = ipaddr.ipaddr.ip4addr.s_addr) == INADDR_NONE)) {
 659                 /*
 660                  * COMMIT
 661                  */
 662                 sqlippool_command(data->allocate_commit, sqlsocket, instance,
 663                                   request, (char *) NULL, 0);
 664
 665                 RDEBUG("Invalid IP number [%s] returned from database query.", allocation);
 666                 data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 667                 radius_xlat(logstr, sizeof(logstr), data->log_failed,
 668                             request, NULL, NULL);
 669
 670                 return do_logging(logstr, RLM_MODULE_NOOP);
 671         }
 672
 673         /*
 674          * UPDATE
 675          */
 676         sqlippool_command(data->allocate_update, sqlsocket, data, request,
 677                           allocation, allocation_len);
 678
 679         RDEBUG("Allocated IP %s [%08x]", allocation, ip_allocation);
 680
 681         vp = radius_paircreate(request, &request->reply->vps,
 682                                PW_FRAMED_IP_ADDRESS, 0, PW_TYPE_IPADDR);
 683         vp->vp_ipaddr = ip_allocation;
 684
 685         /*
 686          * COMMIT
 687          */
 688         sqlippool_command(data->allocate_commit, sqlsocket, data, request,
 689                           (char *) NULL, 0);
 690
 691         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 692         radius_xlat(logstr, sizeof(logstr), data->log_success, request, NULL, NULL);
 693
 694         return do_logging(logstr, RLM_MODULE_OK);
 695 }
 696
 697 static int sqlippool_accounting_start(SQLSOCK * sqlsocket,
 698                                       rlm_sqlippool_t *data, REQUEST *request)
 699 {
 700         /*
 701          * BEGIN
 702          */
 703         sqlippool_command(data->start_begin, sqlsocket, data, request,
 704                           (char *) NULL, 0);
 705
 706         /*
 707          * UPDATE
 708          */
 709         sqlippool_command(data->start_update, sqlsocket, data, request,
 710                           (char *) NULL, 0);
 711
 712         /*
 713          * COMMIT
 714          */
 715         sqlippool_command(data->start_commit, sqlsocket, data, request,
 716                           (char *) NULL, 0);
 717
 718         return RLM_MODULE_OK;
 719 }
 720
 721 static int sqlippool_accounting_alive(SQLSOCK * sqlsocket,
 722                                       rlm_sqlippool_t *data, REQUEST *request)
 723 {
 724         /*
 725          * BEGIN
 726          */
 727         sqlippool_command(data->alive_begin, sqlsocket, data, request,
 728                           (char *) NULL, 0);
 729
 730         /*
 731          * UPDATE
 732          */
 733         sqlippool_command(data->alive_update, sqlsocket, data, request,
 734                           (char *) NULL, 0);
 735
 736         /*
 737          * COMMIT
 738          */
 739         sqlippool_command(data->alive_commit, sqlsocket, data, request,
 740                           (char *) NULL, 0);
 741
 742         return RLM_MODULE_OK;
 743 }
 744
 745 static int sqlippool_accounting_stop(SQLSOCK * sqlsocket,
 746                                       rlm_sqlippool_t *data, REQUEST *request)
 747 {
 748         char    logstr[MAX_STRING_LEN];
 749
 750         /*
 751          * BEGIN
 752          */
 753         sqlippool_command(data->stop_begin, sqlsocket, data, request,
 754                           (char *) NULL, 0);
 755
 756         /*
 757          * CLEAR
 758          */
 759         sqlippool_command(data->stop_clear, sqlsocket, data, request,
 760                           (char *) NULL, 0);
 761
 762         /*
 763          * COMMIT
 764          */
 765         sqlippool_command(data->stop_commit, sqlsocket, data, request,
 766                           (char *) NULL, 0);
 767
 768         radius_xlat(logstr, sizeof(logstr), data->log_clear, request, NULL, NULL);
 769
 770         return do_logging(logstr, RLM_MODULE_OK);
 771 }
 772
 773 static int sqlippool_accounting_on(SQLSOCK * sqlsocket,
 774                                       rlm_sqlippool_t *data, REQUEST *request)
 775 {
 776         /*
 777          * BEGIN
 778          */
 779         sqlippool_command(data->on_begin, sqlsocket, data, request,
 780                           (char *) NULL, 0);
 781
 782         /*
 783          * CLEAR
 784          */
 785         sqlippool_command(data->on_clear, sqlsocket, data, request,
 786                           (char *) NULL, 0);
 787
 788         /*
 789          * COMMIT
 790          */
 791         sqlippool_command(data->on_commit, sqlsocket, data, request,
 792                           (char *) NULL, 0);
 793
 794         return RLM_MODULE_OK;
 795 }
 796
 797 static int sqlippool_accounting_off(SQLSOCK * sqlsocket,
 798                                       rlm_sqlippool_t *data, REQUEST *request)
 799 {
 800         /*
 801          * BEGIN
 802          */
 803         sqlippool_command(data->off_begin, sqlsocket, data, request,
 804                           (char *) NULL, 0);
 805
 806         /*
 807          * CLEAR
 808          */
 809         sqlippool_command(data->off_clear, sqlsocket, data, request,
 810                           (char *) NULL, 0);
 811
 812         /*
 813          * COMMIT
 814          */
 815         sqlippool_command(data->off_commit, sqlsocket, data, request,
 816                           (char *) NULL, 0);
 817
 818         return RLM_MODULE_OK;
 819 }
 820
 821 /*
 822  *      Check for an Accounting-Stop
 823  *      If we find one and we have allocated an IP to this nas/port
 824  *      combination, then deallocate it.
 825  */
 826 static int sqlippool_accounting(void * instance, REQUEST * request)
 827 {
 828         int rcode;
 829         VALUE_PAIR * vp;
 830         int acct_status_type;
 831         rlm_sqlippool_t * data = (rlm_sqlippool_t *) instance;
 832         SQLSOCK * sqlsocket;
 833
 834         vp = pairfind(request->packet->vps, PW_ACCT_STATUS_TYPE, 0, TAG_ANY);
 835         if (!vp) {
 836                 RDEBUG("Could not find account status type in packet.");
 837                 return RLM_MODULE_NOOP;
 838         }
 839         acct_status_type = vp->vp_integer;
 840
 841         switch (acct_status_type) {
 842         case PW_STATUS_START:
 843         case PW_STATUS_ALIVE:
 844         case PW_STATUS_STOP:
 845         case PW_STATUS_ACCOUNTING_ON:
 846         case PW_STATUS_ACCOUNTING_OFF:
 847                 break;          /* continue through to the next section */
 848
 849         default:
 850                 /* We don't care about any other accounting packet */
 851                 return RLM_MODULE_NOOP;
 852         }
 853
 854         sqlsocket = data->sql_inst->sql_get_socket(data->sql_inst);
 855         if (sqlsocket == NULL) {
 856                 RDEBUG("cannot allocate sql connection");
 857                 return RLM_MODULE_NOOP;
 858         }
 859
 860         if (data->sql_inst->sql_set_user(data->sql_inst, request, NULL) < 0) {
 861                 return RLM_MODULE_FAIL;
 862         }
 863
 864         switch (acct_status_type) {
 865         case PW_STATUS_START:
 866                 rcode = sqlippool_accounting_start(sqlsocket, data, request);
 867                 break;
 868
 869         case PW_STATUS_ALIVE:
 870                 rcode = sqlippool_accounting_alive(sqlsocket, data, request);
 871                 break;
 872
 873         case PW_STATUS_STOP:
 874                 rcode = sqlippool_accounting_stop(sqlsocket, data, request);
 875                 break;
 876
 877         case PW_STATUS_ACCOUNTING_ON:
 878                 rcode = sqlippool_accounting_on(sqlsocket, data, request);
 879                 break;
 880
 881         case PW_STATUS_ACCOUNTING_OFF:
 882                 rcode = sqlippool_accounting_off(sqlsocket, data, request);
 883                 break;
 884
 885         default:
 886                 /* We don't care about any other accounting packet */
 887                 return RLM_MODULE_NOOP;
 888         }
 889
 890         data->sql_inst->sql_release_socket(data->sql_inst, sqlsocket);
 891
 892         return rcode;
 893 }
 894
 895 /*
 896  *      The module name should be the only globally exported symbol.
 897  *      That is, everything else should be 'static'.
 898  *
 899  *      If the module needs to temporarily modify it's instantiation
 900  *      data, the type should be changed to RLM_TYPE_THREAD_UNSAFE.
 901  *      The server will then take care of ensuring that the module
 902  *      is single-threaded.
 903  */
 904 module_t rlm_sqlippool = {
 905         RLM_MODULE_INIT,
 906         "SQL IP Pool",
 907         RLM_TYPE_THREAD_SAFE,           /* type */
 908         sqlippool_instantiate,          /* instantiation */
 909         sqlippool_detach,               /* detach */
 910         {
 911                 NULL,                   /* authentication */
 912                 NULL,                   /* authorization */
 913                 NULL,                   /* preaccounting */
 914                 sqlippool_accounting,   /* accounting */
 915                 NULL,                   /* checksimul */
 916                 NULL,                   /* pre-proxy */
 917                 NULL,                   /* post-proxy */
 918                 sqlippool_postauth      /* post-auth */
 919         },
 920 };