res/res_config_odbc.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2005, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * Copyright (C) 2004 - 2005 Anthony Minessale II <anthmct@yahoo.com>
   9  *
  10  * See http://www.asterisk.org for more information about
  11  * the Asterisk project. Please do not directly contact
  12  * any of the maintainers of this project for assistance;
  13  * the project provides a web site, mailing lists and IRC
  14  * channels for your use.
  15  *
  16  * This program is free software, distributed under the terms of
  17  * the GNU General Public License Version 2. See the LICENSE file
  18  * at the top of the source tree.
  19  */
  20
  21 /*! \file
  22  *
  23  * \brief odbc+odbc plugin for portable configuration engine
  24  *
  25  * \author Mark Spencer <markster@digium.com>
  26  * \author Anthony Minessale II <anthmct@yahoo.com>
  27  *
  28  * \arg http://www.unixodbc.org
  29  */
  30
  31 /*** MODULEINFO
  32         <depend>unixodbc</depend>
  33         <depend>res_odbc</depend>
  34  ***/
  35
  36 #include "asterisk.h"
  37
  38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  39
  40 #include <stdio.h>
  41 #include <stdlib.h>
  42 #include <unistd.h>
  43 #include <string.h>
  44
  45 #include "asterisk/file.h"
  46 #include "asterisk/logger.h"
  47 #include "asterisk/channel.h"
  48 #include "asterisk/pbx.h"
  49 #include "asterisk/config.h"
  50 #include "asterisk/module.h"
  51 #include "asterisk/lock.h"
  52 #include "asterisk/options.h"
  53 #include "asterisk/res_odbc.h"
  54 #include "asterisk/utils.h"
  55
  56 static struct ast_variable *realtime_odbc(const char *database, const char *table, va_list ap)
  57 {
  58         struct odbc_obj *obj;
  59         SQLHSTMT stmt;
  60         char sql[1024];
  61         char coltitle[256];
  62         char rowdata[2048];
  63         char *op;
  64         const char *newparam, *newval;
  65         char *stringp;
  66         char *chunk;
  67         SQLSMALLINT collen;
  68         int res;
  69         int x;
  70         struct ast_variable *var=NULL, *prev=NULL;
  71         SQLULEN colsize;
  72         SQLSMALLINT colcount=0;
  73         SQLSMALLINT datatype;
  74         SQLSMALLINT decimaldigits;
  75         SQLSMALLINT nullable;
  76         SQLLEN indicator;
  77         va_list aq;
  78
  79         va_copy(aq, ap);
  80
  81
  82         if (!table)
  83                 return NULL;
  84
  85         obj = ast_odbc_request_obj(database, 0);
  86         if (!obj)
  87                 return NULL;
  88
  89         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
  90         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
  91                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
  92                 ast_odbc_release_obj(obj);
  93                 return NULL;
  94         }
  95
  96         newparam = va_arg(aq, const char *);
  97         if (!newparam)  {
  98                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
  99                 ast_odbc_release_obj(obj);
 100                 return NULL;
 101         }
 102         newval = va_arg(aq, const char *);
 103         if (!strchr(newparam, ' ')) op = " ="; else op = "";
 104         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?", table, newparam, op);
 105         while((newparam = va_arg(aq, const char *))) {
 106                 if (!strchr(newparam, ' ')) op = " ="; else op = "";
 107                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?", newparam, op);
 108                 newval = va_arg(aq, const char *);
 109         }
 110         va_end(aq);
 111         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
 112         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 113                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
 114                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 115                 ast_odbc_release_obj(obj);
 116                 return NULL;
 117         }
 118
 119         /* Now bind the parameters */
 120         x = 1;
 121
 122         while((newparam = va_arg(ap, const char *))) {
 123                 newval = va_arg(ap, const char *);
 124                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
 125         }
 126
 127         res = ast_odbc_smart_execute(obj, stmt);
 128
 129         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 130                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
 131                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 132                 ast_odbc_release_obj(obj);
 133                 return NULL;
 134         }
 135
 136         res = SQLNumResultCols(stmt, &colcount);
 137         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 138                 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
 139                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 140                 ast_odbc_release_obj(obj);
 141                 return NULL;
 142         }
 143
 144         res = SQLFetch(stmt);
 145         if (res == SQL_NO_DATA) {
 146                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 147                 ast_odbc_release_obj(obj);
 148                 return NULL;
 149         }
 150         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 151                 ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
 152                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 153                 ast_odbc_release_obj(obj);
 154                 return NULL;
 155         }
 156         for (x = 0; x < colcount; x++) {
 157                 rowdata[0] = '\0';
 158                 collen = sizeof(coltitle);
 159                 res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen,
 160                                         &datatype, &colsize, &decimaldigits, &nullable);
 161                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 162                         ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
 163                         if (var)
 164                                 ast_variables_destroy(var);
 165                         ast_odbc_release_obj(obj);
 166                         return NULL;
 167                 }
 168
 169                 indicator = 0;
 170                 res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator);
 171                 if (indicator == SQL_NULL_DATA)
 172                         rowdata[0] = '\0';
 173                 else if (ast_strlen_zero(rowdata)) {
 174                         /* Because we encode the empty string for a NULL, we will encode
 175                          * actual empty strings as a string containing a single whitespace. */
 176                         ast_copy_string(rowdata, " ", sizeof(rowdata));
 177                 }
 178
 179                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 180                         ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
 181                         if (var)
 182                                 ast_variables_destroy(var);
 183                         ast_odbc_release_obj(obj);
 184                         return NULL;
 185                 }
 186                 stringp = rowdata;
 187                 while(stringp) {
 188                         chunk = strsep(&stringp, ";");
 189                         if (prev) {
 190                                 prev->next = ast_variable_new(coltitle, chunk);
 191                                 if (prev->next)
 192                                         prev = prev->next;
 193                         } else
 194                                 prev = var = ast_variable_new(coltitle, chunk);
 195                 }
 196         }
 197
 198
 199         SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 200         ast_odbc_release_obj(obj);
 201         return var;
 202 }
 203
 204 static struct ast_config *realtime_multi_odbc(const char *database, const char *table, va_list ap)
 205 {
 206         struct odbc_obj *obj;
 207         SQLHSTMT stmt;
 208         char sql[1024];
 209         char coltitle[256];
 210         char rowdata[2048];
 211         const char *initfield=NULL;
 212         char *op;
 213         const char *newparam, *newval;
 214         char *stringp;
 215         char *chunk;
 216         SQLSMALLINT collen;
 217         int res;
 218         int x;
 219         struct ast_variable *var=NULL;
 220         struct ast_config *cfg=NULL;
 221         struct ast_category *cat=NULL;
 222         struct ast_realloca ra;
 223         SQLULEN colsize;
 224         SQLSMALLINT colcount=0;
 225         SQLSMALLINT datatype;
 226         SQLSMALLINT decimaldigits;
 227         SQLSMALLINT nullable;
 228         SQLLEN indicator;
 229
 230         va_list aq;
 231         va_copy(aq, ap);
 232
 233
 234         if (!table)
 235                 return NULL;
 236         memset(&ra, 0, sizeof(ra));
 237
 238         obj = ast_odbc_request_obj(database, 0);
 239         if (!obj)
 240                 return NULL;
 241
 242         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
 243         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 244                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
 245                 ast_odbc_release_obj(obj);
 246                 return NULL;
 247         }
 248
 249         newparam = va_arg(aq, const char *);
 250         if (!newparam)  {
 251                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 252                 ast_odbc_release_obj(obj);
 253                 return NULL;
 254         }
 255         initfield = ast_strdupa(newparam);
 256         if ((op = strchr(initfield, ' ')))
 257                 *op = '\0';
 258         newval = va_arg(aq, const char *);
 259         if (!strchr(newparam, ' ')) op = " ="; else op = "";
 260         snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?", table, newparam, op);
 261         while((newparam = va_arg(aq, const char *))) {
 262                 if (!strchr(newparam, ' ')) op = " ="; else op = "";
 263                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?", newparam, op);
 264                 newval = va_arg(aq, const char *);
 265         }
 266         if (initfield)
 267                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " ORDER BY %s", initfield);
 268         va_end(aq);
 269         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
 270         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 271                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
 272                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 273                 ast_odbc_release_obj(obj);
 274                 return NULL;
 275         }
 276
 277         /* Now bind the parameters */
 278         x = 1;
 279
 280         while((newparam = va_arg(ap, const char *))) {
 281                 newval = va_arg(ap, const char *);
 282                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
 283         }
 284
 285         res = ast_odbc_smart_execute(obj, stmt);
 286
 287         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 288                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
 289                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 290                 ast_odbc_release_obj(obj);
 291                 return NULL;
 292         }
 293
 294         res = SQLNumResultCols(stmt, &colcount);
 295         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 296                 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql);
 297                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 298                 ast_odbc_release_obj(obj);
 299                 return NULL;
 300         }
 301
 302         cfg = ast_config_new();
 303         if (!cfg) {
 304                 ast_log(LOG_WARNING, "Out of memory!\n");
 305                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 306                 ast_odbc_release_obj(obj);
 307                 return NULL;
 308         }
 309
 310         while ((res=SQLFetch(stmt)) != SQL_NO_DATA) {
 311                 var = NULL;
 312                 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 313                         ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql);
 314                         continue;
 315                 }
 316                 cat = ast_category_new("");
 317                 if (!cat) {
 318                         ast_log(LOG_WARNING, "Out of memory!\n");
 319                         continue;
 320                 }
 321                 for (x=0;x<colcount;x++) {
 322                         rowdata[0] = '\0';
 323                         collen = sizeof(coltitle);
 324                         res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen,
 325                                                 &datatype, &colsize, &decimaldigits, &nullable);
 326                         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 327                                 ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql);
 328                                 ast_category_destroy(cat);
 329                                 continue;
 330                         }
 331
 332                         indicator = 0;
 333                         res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator);
 334                         if (indicator == SQL_NULL_DATA)
 335                                 continue;
 336
 337                         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 338                                 ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql);
 339                                 ast_category_destroy(cat);
 340                                 continue;
 341                         }
 342                         stringp = rowdata;
 343                         while(stringp) {
 344                                 chunk = strsep(&stringp, ";");
 345                                 if (!ast_strlen_zero(ast_strip(chunk))) {
 346                                         if (initfield && !strcmp(initfield, coltitle))
 347                                                 ast_category_rename(cat, chunk);
 348                                         var = ast_variable_new(coltitle, chunk);
 349                                         ast_variable_append(cat, var);
 350                                 }
 351                         }
 352                 }
 353                 ast_category_append(cfg, cat);
 354         }
 355
 356         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 357         ast_odbc_release_obj(obj);
 358         return cfg;
 359 }
 360
 361 static int update_odbc(const char *database, const char *table, const char *keyfield, const char *lookup, va_list ap)
 362 {
 363         struct odbc_obj *obj;
 364         SQLHSTMT stmt;
 365         char sql[256];
 366         SQLLEN rowcount=0;
 367         const char *newparam, *newval;
 368         int res;
 369         int x;
 370         va_list aq;
 371
 372         va_copy(aq, ap);
 373
 374         if (!table)
 375                 return -1;
 376
 377         obj = ast_odbc_request_obj(database, 0);
 378         if (!obj)
 379                 return -1;
 380
 381         res = SQLAllocHandle (SQL_HANDLE_STMT, obj->con, &stmt);
 382         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 383                 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n");
 384                 ast_odbc_release_obj(obj);
 385                 return -1;
 386         }
 387
 388         newparam = va_arg(aq, const char *);
 389         if (!newparam)  {
 390                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 391                 ast_odbc_release_obj(obj);
 392                 return -1;
 393         }
 394         newval = va_arg(aq, const char *);
 395         snprintf(sql, sizeof(sql), "UPDATE %s SET %s=?", table, newparam);
 396         while((newparam = va_arg(aq, const char *))) {
 397                 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), ", %s=?", newparam);
 398                 newval = va_arg(aq, const char *);
 399         }
 400         va_end(aq);
 401         snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " WHERE %s=?", keyfield);
 402
 403         res = SQLPrepare(stmt, (unsigned char *)sql, SQL_NTS);
 404         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 405                 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", sql);
 406                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 407                 ast_odbc_release_obj(obj);
 408                 return -1;
 409         }
 410
 411         /* Now bind the parameters */
 412         x = 1;
 413
 414         while((newparam = va_arg(ap, const char *))) {
 415                 newval = va_arg(ap, const char *);
 416                 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL);
 417         }
 418
 419         SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(lookup), 0, (void *)lookup, 0, NULL);
 420
 421         res = ast_odbc_smart_execute(obj, stmt);
 422
 423         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 424                 ast_log(LOG_WARNING, "SQL Execute error!\n[%s]\n\n", sql);
 425                 SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 426                 ast_odbc_release_obj(obj);
 427                 return -1;
 428         }
 429
 430         res = SQLRowCount(stmt, &rowcount);
 431         SQLFreeHandle (SQL_HANDLE_STMT, stmt);
 432         ast_odbc_release_obj(obj);
 433
 434         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 435                 ast_log(LOG_WARNING, "SQL Row Count error!\n[%s]\n\n", sql);
 436                 return -1;
 437         }
 438
 439         if (rowcount >= 0)
 440                 return (int)rowcount;
 441
 442         return -1;
 443 }
 444
 445 struct config_odbc_obj {
 446         char *sql;
 447         unsigned long cat_metric;
 448         char category[128];
 449         char var_name[128];
 450         char var_val[1024]; /* changed from 128 to 1024 via bug 8251 */
 451         SQLLEN err;
 452 };
 453
 454 static SQLHSTMT config_odbc_prepare(struct odbc_obj *obj, void *data)
 455 {
 456         struct config_odbc_obj *q = data;
 457         SQLHSTMT sth;
 458         int res;
 459
 460         res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &sth);
 461         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 462                 if (option_verbose > 3)
 463                         ast_verbose( VERBOSE_PREFIX_4 "Failure in AllocStatement %d\n", res);
 464                 return NULL;
 465         }
 466
 467         res = SQLPrepare(sth, (unsigned char *)q->sql, SQL_NTS);
 468         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 469                 if (option_verbose > 3)
 470                         ast_verbose( VERBOSE_PREFIX_4 "Error in PREPARE %d\n", res);
 471                 SQLFreeHandle(SQL_HANDLE_STMT, sth);
 472                 return NULL;
 473         }
 474
 475         SQLBindCol(sth, 1, SQL_C_ULONG, &q->cat_metric, sizeof(q->cat_metric), &q->err);
 476         SQLBindCol(sth, 2, SQL_C_CHAR, q->category, sizeof(q->category), &q->err);
 477         SQLBindCol(sth, 3, SQL_C_CHAR, q->var_name, sizeof(q->var_name), &q->err);
 478         SQLBindCol(sth, 4, SQL_C_CHAR, q->var_val, sizeof(q->var_val), &q->err);
 479
 480         return sth;
 481 }
 482
 483 static struct ast_config *config_odbc(const char *database, const char *table, const char *file, struct ast_config *cfg, int withcomments)
 484 {
 485         struct ast_variable *new_v;
 486         struct ast_category *cur_cat;
 487         int res = 0;
 488         struct odbc_obj *obj;
 489         char sqlbuf[1024] = "";
 490         char *sql = sqlbuf;
 491         size_t sqlleft = sizeof(sqlbuf);
 492         unsigned int last_cat_metric = 0;
 493         SQLSMALLINT rowcount = 0;
 494         SQLHSTMT stmt;
 495         char last[128] = "";
 496         struct config_odbc_obj q;
 497
 498         memset(&q, 0, sizeof(q));
 499
 500         if (!file || !strcmp (file, "res_config_odbc.conf"))
 501                 return NULL;            /* cant configure myself with myself ! */
 502
 503         obj = ast_odbc_request_obj(database, 0);
 504         if (!obj)
 505                 return NULL;
 506
 507         ast_build_string(&sql, &sqlleft, "SELECT cat_metric, category, var_name, var_val FROM %s ", table);
 508         ast_build_string(&sql, &sqlleft, "WHERE filename='%s' AND commented=0 ", file);
 509         ast_build_string(&sql, &sqlleft, "ORDER BY cat_metric DESC, var_metric ASC, category, var_name ");
 510         q.sql = sqlbuf;
 511
 512         stmt = ast_odbc_prepare_and_execute(obj, config_odbc_prepare, &q);
 513
 514         if (!stmt) {
 515                 ast_log(LOG_WARNING, "SQL select error!\n[%s]\n\n", sql);
 516                 ast_odbc_release_obj(obj);
 517                 return NULL;
 518         }
 519
 520         res = SQLNumResultCols(stmt, &rowcount);
 521
 522         if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
 523                 ast_log(LOG_WARNING, "SQL NumResultCols error!\n[%s]\n\n", sql);
 524                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 525                 ast_odbc_release_obj(obj);
 526                 return NULL;
 527         }
 528
 529         if (!rowcount) {
 530                 ast_log(LOG_NOTICE, "found nothing\n");
 531                 ast_odbc_release_obj(obj);
 532                 return cfg;
 533         }
 534
 535         cur_cat = ast_config_get_current_category(cfg);
 536
 537         while ((res = SQLFetch(stmt)) != SQL_NO_DATA) {
 538                 if (!strcmp (q.var_name, "#include")) {
 539                         if (!ast_config_internal_load(q.var_val, cfg, 0)) {
 540                                 SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 541                                 ast_odbc_release_obj(obj);
 542                                 return NULL;
 543                         }
 544                         continue;
 545                 }
 546                 if (strcmp(last, q.category) || last_cat_metric != q.cat_metric) {
 547                         cur_cat = ast_category_new(q.category);
 548                         if (!cur_cat) {
 549                                 ast_log(LOG_WARNING, "Out of memory!\n");
 550                                 break;
 551                         }
 552                         strcpy(last, q.category);
 553                         last_cat_metric = q.cat_metric;
 554                         ast_category_append(cfg, cur_cat);
 555                 }
 556
 557                 new_v = ast_variable_new(q.var_name, q.var_val);
 558                 ast_variable_append(cur_cat, new_v);
 559         }
 560
 561         SQLFreeHandle(SQL_HANDLE_STMT, stmt);
 562         ast_odbc_release_obj(obj);
 563         return cfg;
 564 }
 565
 566 static struct ast_config_engine odbc_engine = {
 567         .name = "odbc",
 568         .load_func = config_odbc,
 569         .realtime_func = realtime_odbc,
 570         .realtime_multi_func = realtime_multi_odbc,
 571         .update_func = update_odbc
 572 };
 573
 574 static int unload_module (void)
 575 {
 576         ast_module_user_hangup_all();
 577         ast_config_engine_deregister(&odbc_engine);
 578         if (option_verbose)
 579                 ast_verbose("res_config_odbc unloaded.\n");
 580         return 0;
 581 }
 582
 583 static int load_module (void)
 584 {
 585         ast_config_engine_register(&odbc_engine);
 586         if (option_verbose)
 587                 ast_verbose("res_config_odbc loaded.\n");
 588         return 0;
 589 }
 590
 591 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Realtime ODBC configuration",
 592                 .load = load_module,
 593                 .unload = unload_module,
 594                 );