Remove "initialization from incompatible pointer type" warnings.
[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  ***/
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);