#include "asterisk.h"
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "asterisk/file.h"
#include "asterisk/logger.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/options.h"
#include "asterisk/res_odbc.h"
#include "asterisk/utils.h"
Go to the source code of this file.
Data Structures | |
struct | config_odbc_obj |
struct | custom_prepare_struct |
Functions | |
static void | __reg_module (void) |
static void | __unreg_module (void) |
static struct ast_config * | config_odbc (const char *database, const char *table, const char *file, struct ast_config *cfg, int withcomments) |
static SQLHSTMT | config_odbc_prepare (struct odbc_obj *obj, void *data) |
static SQLHSTMT | custom_prepare (struct odbc_obj *obj, void *data) |
static int | load_module (void) |
static struct ast_config * | realtime_multi_odbc (const char *database, const char *table, va_list ap) |
static struct ast_variable * | realtime_odbc (const char *database, const char *table, va_list ap) |
static int | unload_module (void) |
static int | update_odbc (const char *database, const char *table, const char *keyfield, const char *lookup, va_list ap) |
Variables | |
static struct ast_module_info | __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT | AST_MODFLAG_BUILDSUM, .description = "ODBC Configuration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "361d7bb937402d51e4658efb5b4d76e4" , .load = load_module, .unload = unload_module, } |
static const struct ast_module_info * | ast_module_info = &__mod_info |
static struct ast_config_engine | odbc_engine |
Anthony Minessale II <anthmct@yahoo.com>
Definition in file res_config_odbc.c.
static void __reg_module | ( | void | ) | [static] |
Definition at line 564 of file res_config_odbc.c.
static void __unreg_module | ( | void | ) | [static] |
Definition at line 564 of file res_config_odbc.c.
static struct ast_config* config_odbc | ( | const char * | database, | |
const char * | table, | |||
const char * | file, | |||
struct ast_config * | cfg, | |||
int | withcomments | |||
) | [static] |
Definition at line 453 of file res_config_odbc.c.
References ast_build_string(), ast_category_append(), ast_category_new(), ast_config_get_current_category(), ast_config_internal_load(), ast_log(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), ast_variable_append(), ast_variable_new(), config_odbc_prepare(), last, LOG_NOTICE, and LOG_WARNING.
00454 { 00455 struct ast_variable *new_v; 00456 struct ast_category *cur_cat; 00457 int res = 0; 00458 struct odbc_obj *obj; 00459 char sqlbuf[1024] = ""; 00460 char *sql = sqlbuf; 00461 size_t sqlleft = sizeof(sqlbuf); 00462 unsigned int last_cat_metric = 0; 00463 SQLSMALLINT rowcount = 0; 00464 SQLHSTMT stmt; 00465 char last[128] = ""; 00466 struct config_odbc_obj q; 00467 00468 memset(&q, 0, sizeof(q)); 00469 00470 if (!file || !strcmp (file, "res_config_odbc.conf")) 00471 return NULL; /* cant configure myself with myself ! */ 00472 00473 obj = ast_odbc_request_obj(database, 0); 00474 if (!obj) 00475 return NULL; 00476 00477 ast_build_string(&sql, &sqlleft, "SELECT cat_metric, category, var_name, var_val FROM %s ", table); 00478 ast_build_string(&sql, &sqlleft, "WHERE filename='%s' AND commented=0 ", file); 00479 ast_build_string(&sql, &sqlleft, "ORDER BY cat_metric DESC, var_metric ASC, category, var_name "); 00480 q.sql = sqlbuf; 00481 00482 stmt = ast_odbc_prepare_and_execute(obj, config_odbc_prepare, &q); 00483 00484 if (!stmt) { 00485 ast_log(LOG_WARNING, "SQL select error!\n[%s]\n\n", sql); 00486 ast_odbc_release_obj(obj); 00487 return NULL; 00488 } 00489 00490 res = SQLNumResultCols(stmt, &rowcount); 00491 00492 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00493 ast_log(LOG_WARNING, "SQL NumResultCols error!\n[%s]\n\n", sql); 00494 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00495 ast_odbc_release_obj(obj); 00496 return NULL; 00497 } 00498 00499 if (!rowcount) { 00500 ast_log(LOG_NOTICE, "found nothing\n"); 00501 ast_odbc_release_obj(obj); 00502 return cfg; 00503 } 00504 00505 cur_cat = ast_config_get_current_category(cfg); 00506 00507 while ((res = SQLFetch(stmt)) != SQL_NO_DATA) { 00508 if (!strcmp (q.var_name, "#include")) { 00509 if (!ast_config_internal_load(q.var_val, cfg, 0)) { 00510 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00511 ast_odbc_release_obj(obj); 00512 return NULL; 00513 } 00514 continue; 00515 } 00516 if (strcmp(last, q.category) || last_cat_metric != q.cat_metric) { 00517 cur_cat = ast_category_new(q.category); 00518 if (!cur_cat) { 00519 ast_log(LOG_WARNING, "Out of memory!\n"); 00520 break; 00521 } 00522 strcpy(last, q.category); 00523 last_cat_metric = q.cat_metric; 00524 ast_category_append(cfg, cur_cat); 00525 } 00526 00527 new_v = ast_variable_new(q.var_name, q.var_val); 00528 ast_variable_append(cur_cat, new_v); 00529 } 00530 00531 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00532 ast_odbc_release_obj(obj); 00533 return cfg; 00534 }
static SQLHSTMT config_odbc_prepare | ( | struct odbc_obj * | obj, | |
void * | data | |||
) | [static] |
Definition at line 424 of file res_config_odbc.c.
References ast_verbose(), config_odbc_obj::cat_metric, config_odbc_obj::category, odbc_obj::con, config_odbc_obj::err, option_verbose, config_odbc_obj::sql, config_odbc_obj::var_name, config_odbc_obj::var_val, and VERBOSE_PREFIX_4.
Referenced by config_odbc().
00425 { 00426 struct config_odbc_obj *q = data; 00427 SQLHSTMT sth; 00428 int res; 00429 00430 res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &sth); 00431 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00432 if (option_verbose > 3) 00433 ast_verbose( VERBOSE_PREFIX_4 "Failure in AllocStatement %d\n", res); 00434 return NULL; 00435 } 00436 00437 res = SQLPrepare(sth, (unsigned char *)q->sql, SQL_NTS); 00438 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00439 if (option_verbose > 3) 00440 ast_verbose( VERBOSE_PREFIX_4 "Error in PREPARE %d\n", res); 00441 SQLFreeHandle(SQL_HANDLE_STMT, sth); 00442 return NULL; 00443 } 00444 00445 SQLBindCol(sth, 1, SQL_C_ULONG, &q->cat_metric, sizeof(q->cat_metric), &q->err); 00446 SQLBindCol(sth, 2, SQL_C_CHAR, q->category, sizeof(q->category), &q->err); 00447 SQLBindCol(sth, 3, SQL_C_CHAR, q->var_name, sizeof(q->var_name), &q->err); 00448 SQLBindCol(sth, 4, SQL_C_CHAR, q->var_val, sizeof(q->var_val), &q->err); 00449 00450 return sth; 00451 }
static SQLHSTMT custom_prepare | ( | struct odbc_obj * | obj, | |
void * | data | |||
) | [static] |
Definition at line 63 of file res_config_odbc.c.
References custom_prepare_struct::ap, ast_log(), ast_strlen_zero(), odbc_obj::con, custom_prepare_struct::extra, LOG_WARNING, and custom_prepare_struct::sql.
Referenced by realtime_multi_odbc(), realtime_odbc(), and update_odbc().
00064 { 00065 int res, x = 1; 00066 struct custom_prepare_struct *cps = data; 00067 const char *newparam, *newval; 00068 SQLHSTMT stmt; 00069 va_list ap; 00070 00071 va_copy(ap, cps->ap); 00072 00073 res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt); 00074 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00075 ast_log(LOG_WARNING, "SQL Alloc Handle failed!\n"); 00076 return NULL; 00077 } 00078 00079 res = SQLPrepare(stmt, (unsigned char *)cps->sql, SQL_NTS); 00080 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00081 ast_log(LOG_WARNING, "SQL Prepare failed![%s]\n", cps->sql); 00082 SQLFreeHandle (SQL_HANDLE_STMT, stmt); 00083 return NULL; 00084 } 00085 00086 while ((newparam = va_arg(ap, const char *))) { 00087 newval = va_arg(ap, const char *); 00088 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(newval), 0, (void *)newval, 0, NULL); 00089 } 00090 va_end(ap); 00091 00092 if (!ast_strlen_zero(cps->extra)) 00093 SQLBindParameter(stmt, x++, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(cps->extra), 0, (void *)cps->extra, 0, NULL); 00094 return stmt; 00095 }
static int load_module | ( | void | ) | [static] |
Definition at line 553 of file res_config_odbc.c.
References ast_config_engine_register(), ast_verbose(), odbc_engine, and option_verbose.
00554 { 00555 ast_config_engine_register(&odbc_engine); 00556 if (option_verbose) 00557 ast_verbose("res_config_odbc loaded.\n"); 00558 return 0; 00559 }
static struct ast_config* realtime_multi_odbc | ( | const char * | database, | |
const char * | table, | |||
va_list | ap | |||
) | [static] |
Definition at line 223 of file res_config_odbc.c.
References custom_prepare_struct::ap, ast_category_append(), ast_category_destroy(), ast_category_new(), ast_category_rename(), ast_config_new(), ast_log(), ast_odbc_backslash_is_escape(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), ast_strdupa, ast_strip(), ast_strlen_zero(), ast_variable_append(), ast_variable_new(), custom_prepare(), LOG_WARNING, custom_prepare_struct::sql, and var.
00224 { 00225 struct odbc_obj *obj; 00226 SQLHSTMT stmt; 00227 char sql[1024]; 00228 char coltitle[256]; 00229 char rowdata[2048]; 00230 const char *initfield=NULL; 00231 char *op; 00232 const char *newparam, *newval; 00233 char *stringp; 00234 char *chunk; 00235 SQLSMALLINT collen; 00236 int res; 00237 int x; 00238 struct ast_variable *var=NULL; 00239 struct ast_config *cfg=NULL; 00240 struct ast_category *cat=NULL; 00241 struct ast_realloca ra; 00242 SQLULEN colsize; 00243 SQLSMALLINT colcount=0; 00244 SQLSMALLINT datatype; 00245 SQLSMALLINT decimaldigits; 00246 SQLSMALLINT nullable; 00247 SQLLEN indicator; 00248 struct custom_prepare_struct cps = { .sql = sql }; 00249 va_list aq; 00250 00251 va_copy(cps.ap, ap); 00252 va_copy(aq, ap); 00253 00254 if (!table) 00255 return NULL; 00256 memset(&ra, 0, sizeof(ra)); 00257 00258 obj = ast_odbc_request_obj(database, 0); 00259 if (!obj) 00260 return NULL; 00261 00262 newparam = va_arg(aq, const char *); 00263 if (!newparam) { 00264 ast_odbc_release_obj(obj); 00265 return NULL; 00266 } 00267 initfield = ast_strdupa(newparam); 00268 if ((op = strchr(initfield, ' '))) 00269 *op = '\0'; 00270 newval = va_arg(aq, const char *); 00271 op = !strchr(newparam, ' ') ? " =" : ""; 00272 snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?%s", table, newparam, op, 00273 strcasestr(newparam, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\'" : ""); 00274 while((newparam = va_arg(aq, const char *))) { 00275 op = !strchr(newparam, ' ') ? " =" : ""; 00276 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?%s", newparam, op, 00277 strcasestr(newparam, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\'" : ""); 00278 newval = va_arg(aq, const char *); 00279 } 00280 if (initfield) 00281 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " ORDER BY %s", initfield); 00282 va_end(aq); 00283 00284 stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps); 00285 00286 if (!stmt) { 00287 ast_odbc_release_obj(obj); 00288 return NULL; 00289 } 00290 00291 res = SQLNumResultCols(stmt, &colcount); 00292 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00293 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql); 00294 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00295 ast_odbc_release_obj(obj); 00296 return NULL; 00297 } 00298 00299 cfg = ast_config_new(); 00300 if (!cfg) { 00301 ast_log(LOG_WARNING, "Out of memory!\n"); 00302 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00303 ast_odbc_release_obj(obj); 00304 return NULL; 00305 } 00306 00307 while ((res=SQLFetch(stmt)) != SQL_NO_DATA) { 00308 var = NULL; 00309 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00310 ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql); 00311 continue; 00312 } 00313 cat = ast_category_new(""); 00314 if (!cat) { 00315 ast_log(LOG_WARNING, "Out of memory!\n"); 00316 continue; 00317 } 00318 for (x=0;x<colcount;x++) { 00319 rowdata[0] = '\0'; 00320 collen = sizeof(coltitle); 00321 res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen, 00322 &datatype, &colsize, &decimaldigits, &nullable); 00323 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00324 ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql); 00325 ast_category_destroy(cat); 00326 continue; 00327 } 00328 00329 indicator = 0; 00330 res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator); 00331 if (indicator == SQL_NULL_DATA) 00332 continue; 00333 00334 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00335 ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql); 00336 ast_category_destroy(cat); 00337 continue; 00338 } 00339 stringp = rowdata; 00340 while(stringp) { 00341 chunk = strsep(&stringp, ";"); 00342 if (!ast_strlen_zero(ast_strip(chunk))) { 00343 if (initfield && !strcmp(initfield, coltitle)) 00344 ast_category_rename(cat, chunk); 00345 var = ast_variable_new(coltitle, chunk); 00346 ast_variable_append(cat, var); 00347 } 00348 } 00349 } 00350 ast_category_append(cfg, cat); 00351 } 00352 00353 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00354 ast_odbc_release_obj(obj); 00355 return cfg; 00356 }
static struct ast_variable* realtime_odbc | ( | const char * | database, | |
const char * | table, | |||
va_list | ap | |||
) | [static] |
Definition at line 97 of file res_config_odbc.c.
References custom_prepare_struct::ap, ast_log(), ast_odbc_backslash_is_escape(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), ast_strip(), ast_strlen_zero(), ast_variable_new(), ast_variables_destroy(), custom_prepare(), LOG_ERROR, LOG_WARNING, custom_prepare_struct::sql, and var.
00098 { 00099 struct odbc_obj *obj; 00100 SQLHSTMT stmt; 00101 char sql[1024]; 00102 char coltitle[256]; 00103 char rowdata[2048]; 00104 char *op; 00105 const char *newparam, *newval; 00106 char *stringp; 00107 char *chunk; 00108 SQLSMALLINT collen; 00109 int res; 00110 int x; 00111 struct ast_variable *var=NULL, *prev=NULL; 00112 SQLULEN colsize; 00113 SQLSMALLINT colcount=0; 00114 SQLSMALLINT datatype; 00115 SQLSMALLINT decimaldigits; 00116 SQLSMALLINT nullable; 00117 SQLLEN indicator; 00118 va_list aq; 00119 struct custom_prepare_struct cps = { .sql = sql }; 00120 00121 va_copy(cps.ap, ap); 00122 va_copy(aq, ap); 00123 00124 if (!table) 00125 return NULL; 00126 00127 obj = ast_odbc_request_obj(database, 0); 00128 00129 if (!obj) { 00130 ast_log(LOG_ERROR, "No database handle available with the name of '%s' (check res_odbc.conf)\n", database); 00131 return NULL; 00132 } 00133 00134 newparam = va_arg(aq, const char *); 00135 if (!newparam) { 00136 ast_odbc_release_obj(obj); 00137 return NULL; 00138 } 00139 newval = va_arg(aq, const char *); 00140 op = !strchr(newparam, ' ') ? " =" : ""; 00141 snprintf(sql, sizeof(sql), "SELECT * FROM %s WHERE %s%s ?%s", table, newparam, op, 00142 strcasestr(newparam, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\'" : ""); 00143 while((newparam = va_arg(aq, const char *))) { 00144 op = !strchr(newparam, ' ') ? " =" : ""; 00145 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " AND %s%s ?%s", newparam, op, 00146 strcasestr(newparam, "LIKE") && !ast_odbc_backslash_is_escape(obj) ? " ESCAPE '\\'" : ""); 00147 newval = va_arg(aq, const char *); 00148 } 00149 va_end(aq); 00150 00151 stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps); 00152 00153 if (!stmt) { 00154 ast_odbc_release_obj(obj); 00155 return NULL; 00156 } 00157 00158 res = SQLNumResultCols(stmt, &colcount); 00159 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00160 ast_log(LOG_WARNING, "SQL Column Count error!\n[%s]\n\n", sql); 00161 SQLFreeHandle (SQL_HANDLE_STMT, stmt); 00162 ast_odbc_release_obj(obj); 00163 return NULL; 00164 } 00165 00166 res = SQLFetch(stmt); 00167 if (res == SQL_NO_DATA) { 00168 SQLFreeHandle (SQL_HANDLE_STMT, stmt); 00169 ast_odbc_release_obj(obj); 00170 return NULL; 00171 } 00172 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00173 ast_log(LOG_WARNING, "SQL Fetch error!\n[%s]\n\n", sql); 00174 SQLFreeHandle (SQL_HANDLE_STMT, stmt); 00175 ast_odbc_release_obj(obj); 00176 return NULL; 00177 } 00178 for (x = 0; x < colcount; x++) { 00179 rowdata[0] = '\0'; 00180 collen = sizeof(coltitle); 00181 res = SQLDescribeCol(stmt, x + 1, (unsigned char *)coltitle, sizeof(coltitle), &collen, 00182 &datatype, &colsize, &decimaldigits, &nullable); 00183 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00184 ast_log(LOG_WARNING, "SQL Describe Column error!\n[%s]\n\n", sql); 00185 if (var) 00186 ast_variables_destroy(var); 00187 ast_odbc_release_obj(obj); 00188 return NULL; 00189 } 00190 00191 indicator = 0; 00192 res = SQLGetData(stmt, x + 1, SQL_CHAR, rowdata, sizeof(rowdata), &indicator); 00193 if (indicator == SQL_NULL_DATA) 00194 continue; 00195 00196 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00197 ast_log(LOG_WARNING, "SQL Get Data error!\n[%s]\n\n", sql); 00198 if (var) 00199 ast_variables_destroy(var); 00200 ast_odbc_release_obj(obj); 00201 return NULL; 00202 } 00203 stringp = rowdata; 00204 while(stringp) { 00205 chunk = strsep(&stringp, ";"); 00206 if (!ast_strlen_zero(ast_strip(chunk))) { 00207 if (prev) { 00208 prev->next = ast_variable_new(coltitle, chunk); 00209 if (prev->next) 00210 prev = prev->next; 00211 } else 00212 prev = var = ast_variable_new(coltitle, chunk); 00213 } 00214 } 00215 } 00216 00217 00218 SQLFreeHandle(SQL_HANDLE_STMT, stmt); 00219 ast_odbc_release_obj(obj); 00220 return var; 00221 }
static int unload_module | ( | void | ) | [static] |
Definition at line 544 of file res_config_odbc.c.
References ast_config_engine_deregister(), ast_module_user_hangup_all, ast_verbose(), odbc_engine, and option_verbose.
00545 { 00546 ast_module_user_hangup_all(); 00547 ast_config_engine_deregister(&odbc_engine); 00548 if (option_verbose) 00549 ast_verbose("res_config_odbc unloaded.\n"); 00550 return 0; 00551 }
static int update_odbc | ( | const char * | database, | |
const char * | table, | |||
const char * | keyfield, | |||
const char * | lookup, | |||
va_list | ap | |||
) | [static] |
Definition at line 358 of file res_config_odbc.c.
References custom_prepare_struct::ap, ast_log(), ast_odbc_prepare_and_execute(), ast_odbc_release_obj(), ast_odbc_request_obj(), custom_prepare(), LOG_WARNING, and custom_prepare_struct::sql.
00359 { 00360 struct odbc_obj *obj; 00361 SQLHSTMT stmt; 00362 char sql[256]; 00363 SQLLEN rowcount=0; 00364 const char *newparam, *newval; 00365 int res; 00366 va_list aq; 00367 struct custom_prepare_struct cps = { .sql = sql, .extra = lookup }; 00368 00369 va_copy(cps.ap, ap); 00370 va_copy(aq, ap); 00371 00372 if (!table) 00373 return -1; 00374 00375 obj = ast_odbc_request_obj(database, 0); 00376 if (!obj) 00377 return -1; 00378 00379 newparam = va_arg(aq, const char *); 00380 if (!newparam) { 00381 ast_odbc_release_obj(obj); 00382 return -1; 00383 } 00384 newval = va_arg(aq, const char *); 00385 snprintf(sql, sizeof(sql), "UPDATE %s SET %s=?", table, newparam); 00386 while((newparam = va_arg(aq, const char *))) { 00387 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), ", %s=?", newparam); 00388 newval = va_arg(aq, const char *); 00389 } 00390 va_end(aq); 00391 snprintf(sql + strlen(sql), sizeof(sql) - strlen(sql), " WHERE %s=?", keyfield); 00392 00393 stmt = ast_odbc_prepare_and_execute(obj, custom_prepare, &cps); 00394 00395 if (!stmt) { 00396 ast_odbc_release_obj(obj); 00397 return -1; 00398 } 00399 00400 res = SQLRowCount(stmt, &rowcount); 00401 SQLFreeHandle (SQL_HANDLE_STMT, stmt); 00402 ast_odbc_release_obj(obj); 00403 00404 if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { 00405 ast_log(LOG_WARNING, "SQL Row Count error!\n[%s]\n\n", sql); 00406 return -1; 00407 } 00408 00409 if (rowcount >= 0) 00410 return (int)rowcount; 00411 00412 return -1; 00413 }
struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT | AST_MODFLAG_BUILDSUM, .description = "ODBC Configuration" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "361d7bb937402d51e4658efb5b4d76e4" , .load = load_module, .unload = unload_module, } [static] |
Definition at line 564 of file res_config_odbc.c.
const struct ast_module_info* ast_module_info = &__mod_info [static] |
Definition at line 564 of file res_config_odbc.c.
struct ast_config_engine odbc_engine [static] |