issue #5650
[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  *      http://www.unixodbc.org
26  */
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <unistd.h>
31 #include <string.h>
32
33 #include "asterisk.h"
34
35 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
36
37 #include "asterisk/file.h"
38 #include "asterisk/logger.h"
39 #include "asterisk/channel.h"
40 #include "asterisk/pbx.h"
41 #include "asterisk/config.h"
42 #include "asterisk/module.h"
43 #include "asterisk/lock.h"
44 #include "asterisk/options.h"
45 #include "asterisk/res_odbc.h"
46 #include "asterisk/utils.h"
47
48 static char *tdesc = "ODBC Configuration";
49 STANDARD_LOCAL_USER;
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, 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, 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, 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, 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, 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 int unload_module (void)
510 {
511         ast_config_engine_deregister(&odbc_engine);
512         if (option_verbose)
513                 ast_verbose("res_config_odbc unloaded.\n");
514         STANDARD_HANGUP_LOCALUSERS;
515         return 0;
516 }
517
518 int load_module (void)
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 char *description (void)
527 {
528         return tdesc;
529 }
530
531 int usecount (void)
532 {
533         /* never unload a config module */
534         return 1;
535 }
536
537 char *key ()
538 {
539         return ASTERISK_GPL_KEY;
540 }