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