Merged revisions 62842 via svnmerge from
[asterisk/asterisk.git] / 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, "ODBC Configuration",
592                 .load = load_module,
593                 .unload = unload_module,
594                 );