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