kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-11-19 08:11:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Massive code formatting cleanup in res_odbc.c thanks to bkw_

Browse Source 
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@3404 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
James Golovich
2004-07-08 19:58:26 +00:00
parent c5e44cc3cb
commit 8426e454de
1 changed files with 289 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

610
res/res_odbc.c
View File

@@ -9,8 +9,6 @@
* Copyright (C) 2004 Anthony Minessale II <anthmct@yahoo.com> * Copyright (C) 2004 Anthony Minessale II <anthmct@yahoo.com>
*/ */
#include <asterisk/file.h> #include <asterisk/file.h>
#include <asterisk/logger.h> #include <asterisk/logger.h>
#include <asterisk/channel.h> #include <asterisk/channel.h>
@@ -26,405 +24,371 @@
#include <asterisk/res_odbc.h> #include <asterisk/res_odbc.h>
#define MAX_ODBC_HANDLES 25 #define MAX_ODBC_HANDLES 25
struct odbc_list { struct odbc_list
char name[80]; {
odbc_obj *obj; char name[80];
int used; odbc_obj *obj;
int used;
}; };
static struct odbc_list ODBC_REGISTRY[MAX_ODBC_HANDLES]; static struct odbc_list ODBC_REGISTRY[MAX_ODBC_HANDLES];
static void odbc_destroy(void) { static void odbc_destroy(void)
int x=0; {
int x = 0;
for(x=0;x<MAX_ODBC_HANDLES;x++) {
if(ODBC_REGISTRY[x].obj) {
destroy_obdc_obj(&ODBC_REGISTRY[x].obj);
ODBC_REGISTRY[x].obj = NULL;
}
}
for (x = 0; x < MAX_ODBC_HANDLES; x++) {
if (ODBC_REGISTRY[x].obj) {
destroy_obdc_obj(&ODBC_REGISTRY[x].obj);
ODBC_REGISTRY[x].obj = NULL;
}
}
} }
static odbc_obj *odbc_read(struct odbc_list *registry,char *name) { static odbc_obj *odbc_read(struct odbc_list *registry, char *name)
int x=0; {
for(x=0;x<MAX_ODBC_HANDLES;x++) { int x = 0;
if(registry[x].used && !strcmp(registry[x].name,name)) { for (x = 0; x < MAX_ODBC_HANDLES; x++) {
return registry[x].obj; if (registry[x].used && !strcmp(registry[x].name, name)) {
} return registry[x].obj;
} }
return NULL; }
return NULL;
} }
static int odbc_write(struct odbc_list *registry,char *name,odbc_obj *obj) { static int odbc_write(struct odbc_list *registry, char *name, odbc_obj * obj)
int x=0; {
for(x=0;x<MAX_ODBC_HANDLES;x++) { int x = 0;
if(!registry[x].used) { for (x = 0; x < MAX_ODBC_HANDLES; x++) {
strncpy(registry[x].name,name,sizeof(registry[x].name)); if (!registry[x].used) {
registry[x].obj = obj; strncpy(registry[x].name, name, sizeof(registry[x].name));
registry[x].used=1; registry[x].obj = obj;
return 1; registry[x].used = 1;
} return 1;
} }
return 0; }
return 0;
} }
static void odbc_init(void) { static void odbc_init(void)
int x=0; {
for(x=0;x<MAX_ODBC_HANDLES;x++) { int x = 0;
memset(&ODBC_REGISTRY[x],0,sizeof(struct odbc_list)); for (x = 0; x < MAX_ODBC_HANDLES; x++) {
} memset(&ODBC_REGISTRY[x], 0, sizeof(struct odbc_list));
}
} }
static char *tdesc = "ODBC Resource"; static char *tdesc = "ODBC Resource";
/* internal stuff */ /* internal stuff */
static int load_odbc_config(void)
{
static char *cfg = "res_odbc.conf";
struct ast_config *config;
struct ast_variable *v;
char *cat, *dsn, *username, *password;
int enabled;
int connect = 0;
char *env_var;
static int load_odbc_config(void) { odbc_obj *obj;
static char *cfg = "res_odbc.conf";
struct ast_config *config;
struct ast_variable *v;
char *cat,*dsn,*username,*password;
int enabled;
int connect = 0;
char *env_var;
odbc_obj *obj; config = ast_load(cfg);
if (config) {
for (cat = ast_category_browse(config, NULL); cat; cat=ast_category_browse(config, cat)) {
if (!strcmp(cat, "ENV")) {
for (v = ast_variable_browse(config, cat); v; v = v->next) {
env_var = malloc(strlen(v->name) + strlen(v->value) + 2);
sprintf(env_var, "%s=%s", v->name, v->value);
ast_log(LOG_NOTICE, "Adding ENV var: %s=%s\n", v->name, v->value);
putenv(env_var);
free(env_var);
}
config = ast_load(cfg); cat = ast_category_browse(config, cat);
if(config) { }
for(cat = ast_category_browse(config,NULL);cat;cat=ast_category_browse(config,cat)) {
if(!strcmp(cat,"ENV")) { dsn = username = password = NULL;
for(v = ast_variable_browse(config,cat);v;v=v->next) { enabled = 1;
env_var = malloc( strlen(v->name) + strlen(v->value) +2); connect = 0;
sprintf(env_var,"%s=%s",v->name,v->value); for (v = ast_variable_browse(config, cat); v; v = v->next) {
ast_log(LOG_NOTICE,"Adding ENV var: %s=%s\n",v->name,v->value); if (!strcmp(v->name, "enabled"))
putenv(env_var); enabled = ast_true(v->value);
free(env_var); if (!strcmp(v->name, "pre-connect"))
connect = ast_true(v->value);
if (!strcmp(v->name, "dsn"))
dsn = v->value;
if (!strcmp(v->name, "username"))
username = v->value;
if (!strcmp(v->name, "password"))
password = v->value;
}
if (enabled && dsn && username && password) {
obj = new_odbc_obj(cat, dsn, username, password);
if (obj) {
register_odbc_obj(cat, obj);
ast_log(LOG_NOTICE, "registered database handle '%s' dsn->[%s]\n", cat, obj->dsn);
if (connect) {
odbc_obj_connect(obj);
}
} else {
ast_log(LOG_WARNING, "Addition of obj %s failed.\n", cat);
}
}
}
ast_destroy(config);
} }
return 0;
}
cat=ast_category_browse(config,cat); int odbc_dump_fd(int fd, odbc_obj * obj)
} {
ast_cli(fd, "\n\nName: %s\nDSN: %s\nConnected: %s\n\n", obj->name, obj->dsn, obj->up ? "yes" : "no");
return 0;
}
static int odbc_usage(int fd)
{
ast_cli(fd, "\n\nusage odbc <command> <arg1> .. <argn>\n\n");
return 0;
}
dsn = username = password = NULL; static int odbc_command(int fd, int argc, char **argv)
enabled = 1; {
connect = 0; odbc_obj *obj;
for(v = ast_variable_browse(config,cat);v;v=v->next) { int x = 0;
if(!strcmp(v->name,"enabled")) if (!argv[1])
enabled = ast_true(v->value); return odbc_usage(fd);
if(!strcmp(v->name,"pre-connect"))
connect = ast_true(v->value);
if(!strcmp(v->name,"dsn"))
dsn = v->value;
if(!strcmp(v->name,"username"))
username = v->value;
if(!strcmp(v->name,"password"))
password = v->value;
}
if(enabled && dsn && username && password) { ast_cli(fd, "\n\n");
obj = new_odbc_obj(cat,dsn,username,password);
if(obj) {
register_odbc_obj(cat,obj);
ast_log(LOG_NOTICE,"registered database handle '%s' dsn->[%s]\n",cat,obj->dsn);
if(connect) {
odbc_obj_connect(obj);
}
if (!strcmp(argv[1], "connect") || !strcmp(argv[1], "disconnect")) {
if (!argv[2])
return odbc_usage(fd);
obj = odbc_read(ODBC_REGISTRY, argv[2]);
if (obj) {
if (!strcmp(argv[1], "connect"))
odbc_obj_connect(obj);
if (!strcmp(argv[1], "disconnect"))
odbc_obj_disconnect(obj);
}
} else if (!strcmp(argv[1], "show")) {
if (!argv[2] || (argv[2] && !strcmp(argv[2], "all"))) {
for (x = 0; x < MAX_ODBC_HANDLES; x++) {
if (!ODBC_REGISTRY[x].used)
break;
if (ODBC_REGISTRY[x].obj)
odbc_dump_fd(fd, ODBC_REGISTRY[x].obj);
}
} else {
obj = odbc_read(ODBC_REGISTRY, argv[2]);
if (obj)
odbc_dump_fd(fd, obj);
}
} else {
return odbc_usage(fd);
} }
else ast_cli(fd, "\n");
ast_log(LOG_WARNING,"Addition of obj %s failed.\n",cat); return 0;
}
}
ast_destroy(config);
}
return 0;
} }
int odbc_dump_fd(int fd,odbc_obj *obj) {
ast_cli(fd,"\n\nName: %s\nDSN: %s\nConnected: %s\n\n",obj->name,obj->dsn,obj->up ? "yes" : "no");
return 0;
}
static int odbc_usage(int fd) {
ast_cli(fd,"\n\nusage odbc <command> <arg1> .. <argn>\n\n");
return 0;
}
static int odbc_command(int fd, int argc, char **argv) {
odbc_obj *obj;
int x=0;
if(!argv[1])
return odbc_usage(fd);
ast_cli(fd,"\n\n");
if(!strcmp(argv[1],"connect") || !strcmp(argv[1],"disconnect")) {
if(!argv[2])
return odbc_usage(fd);
obj=odbc_read(ODBC_REGISTRY,argv[2]);
if(obj) {
if(!strcmp(argv[1],"connect"))
odbc_obj_connect(obj);
if(!strcmp(argv[1],"disconnect"))
odbc_obj_disconnect(obj);
}
}
else if(!strcmp(argv[1],"show")) {
if(!argv[2] || (argv[2] && !strcmp(argv[2],"all"))) {
for(x=0;x<MAX_ODBC_HANDLES;x++) {
if(!ODBC_REGISTRY[x].used)
break;
if(ODBC_REGISTRY[x].obj)
odbc_dump_fd(fd,ODBC_REGISTRY[x].obj);
}
}
else {
obj=odbc_read(ODBC_REGISTRY,argv[2]);
if(obj)
odbc_dump_fd(fd,obj);
}
}
else
return odbc_usage(fd);
ast_cli(fd,"\n\n");
return 0;
}
static struct ast_cli_entry odbc_command_struct = { static struct ast_cli_entry odbc_command_struct = {
{ "odbc", NULL }, odbc_command, {"odbc", NULL}, odbc_command,
"Execute ODBC Command","obdc <command> <arg1> .. <argn>", NULL }; "Execute ODBC Command", "obdc <command> <arg1> .. <argn>", NULL
};
/* api calls */ /* api calls */
int register_odbc_obj(char *name,odbc_obj *obj) { int register_odbc_obj(char *name, odbc_obj * obj)
if(obj != NULL) {
return odbc_write(ODBC_REGISTRY,name,obj); if (obj != NULL)
return odbc_write(ODBC_REGISTRY, name, obj);
return 0; return 0;
} }
odbc_obj *fetch_odbc_obj(char *name) { odbc_obj *fetch_odbc_obj(char *name)
return (odbc_obj *) odbc_read(ODBC_REGISTRY,name); {
return (odbc_obj *) odbc_read(ODBC_REGISTRY, name);
} }
odbc_obj *new_odbc_obj(char *name, char *dsn, char *username, char *password)
{
static odbc_obj *new;
odbc_obj *new_odbc_obj(char *name,char *dsn,char *username, char *password) { new = malloc(sizeof(odbc_obj));
static odbc_obj *new; memset(new, 0, sizeof(odbc_obj));
new->env = SQL_NULL_HANDLE;
new=malloc(sizeof(odbc_obj)); new->name = malloc(strlen(name) + 1);
memset(new,0,sizeof(odbc_obj)); if (new->name == NULL)
new->env = SQL_NULL_HANDLE; return NULL;
new->name = malloc(strlen(name)+1); new->dsn = malloc(strlen(dsn) + 1);
if(new->name == NULL) if (new->dsn == NULL)
return NULL; return NULL;
new->dsn = malloc(strlen(dsn)+1); new->username = malloc(strlen(username) + 1);
if(new->dsn == NULL) if (new->username == NULL)
return NULL; return NULL;
new->username = malloc(strlen(username)+1); new->password = malloc(strlen(password) + 1);
if(new->username == NULL) if (new->password == NULL)
return NULL; return NULL;
new->password = malloc(strlen(password)+1); strcpy(new->name, name);
if(new->password == NULL) strcpy(new->dsn, dsn);
return NULL; strcpy(new->username, username);
strcpy(new->password, password);
strcpy(new->name,name); new->up = 0;
strcpy(new->dsn,dsn); ast_mutex_init(&new->lock);
strcpy(new->username,username); return new;
strcpy(new->password,password);
new->up=0;
ast_mutex_init(&new->lock);
return new;
} }
void destroy_obdc_obj(odbc_obj **obj) { void destroy_obdc_obj(odbc_obj ** obj)
{
odbc_obj_disconnect(*obj);
odbc_obj_disconnect(*obj); ast_mutex_lock(&(*obj)->lock);
SQLFreeHandle(SQL_HANDLE_STMT, (*obj)->stmt);
SQLFreeHandle(SQL_HANDLE_DBC, (*obj)->con);
SQLFreeHandle(SQL_HANDLE_ENV, (*obj)->env);
ast_mutex_lock(&(*obj)->lock); free((*obj)->name);
SQLFreeHandle(SQL_HANDLE_STMT, (*obj)->stmt); free((*obj)->dsn);
SQLFreeHandle(SQL_HANDLE_DBC,(*obj)->con); free((*obj)->username);
SQLFreeHandle(SQL_HANDLE_ENV,(*obj)->env); free((*obj)->password);
ast_mutex_unlock(&(*obj)->lock);
free((*obj)->name); free(*obj);
free((*obj)->dsn);
free((*obj)->username);
free((*obj)->password);
ast_mutex_unlock(&(*obj)->lock);
free(*obj);
} }
odbc_status odbc_obj_disconnect(odbc_obj *obj) { odbc_status odbc_obj_disconnect(odbc_obj * obj)
int res; {
ast_mutex_lock(&obj->lock); int res;
ast_mutex_lock(&obj->lock);
if(obj->up) if (obj->up) {
res = SQLDisconnect(obj->con); res = SQLDisconnect(obj->con);
else } else {
res = -1; res = -1;
}
if(res == ODBC_SUCCESS) { if (res == ODBC_SUCCESS) {
ast_log(LOG_WARNING, "res_odbc: disconnected %d from %s [%s]\n",res,obj->name,obj->dsn); ast_log(LOG_WARNING, "res_odbc: disconnected %d from %s [%s]\n", res, obj->name, obj->dsn);
obj->up=0; obj->up = 0;
} } else {
else ast_log(LOG_WARNING, "res_odbc: %s [%s] already disconnected\n",
ast_log(LOG_WARNING, "res_odbc: %s [%s] already disconnected\n",obj->name,obj->dsn); obj->name, obj->dsn);
}
ast_mutex_unlock(&obj->lock); ast_mutex_unlock(&obj->lock);
return ODBC_SUCCESS; return ODBC_SUCCESS;
} }
odbc_status odbc_obj_connect(odbc_obj * obj)
{
int res;
long int err;
short int mlen;
char msg[200], stat[10];
odbc_status odbc_obj_connect(odbc_obj *obj) { ast_mutex_lock(&obj->lock);
int res;
long int err;
short int mlen;
char msg[200], stat[10];
ast_mutex_lock(&obj->lock); if (obj->env == SQL_NULL_HANDLE) {
res = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &obj->env);
if(obj->env == SQL_NULL_HANDLE) { if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
if (option_verbose > 3)
ast_log(LOG_WARNING, "res_odbc: Error AllocHandle\n");
ast_mutex_unlock(&obj->lock);
return ODBC_FAIL;
}
res = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &obj->env); res = SQLSetEnvAttr(obj->env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0);
if((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
if(option_verbose > 3) if (option_verbose > 3)
ast_log(LOG_WARNING, "res_odbc: Error AllocHandle\n"); ast_log(LOG_WARNING, "res_odbc: Error SetEnv\n");
ast_mutex_unlock(&obj->lock); SQLFreeHandle(SQL_HANDLE_ENV, obj->env);
return ODBC_FAIL; ast_mutex_unlock(&obj->lock);
} return ODBC_FAIL;
}
res = SQLSetEnvAttr(obj->env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); res = SQLAllocHandle(SQL_HANDLE_DBC, obj->env, &obj->con);
if((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
if(option_verbose > 3)
ast_log(LOG_WARNING, "res_odbc: Error SetEnv\n");
SQLFreeHandle(SQL_HANDLE_ENV, obj->env);
ast_mutex_unlock(&obj->lock);
return ODBC_FAIL;
}
res = SQLAllocHandle(SQL_HANDLE_DBC, obj->env, &obj->con); if (option_verbose > 3)
ast_log(LOG_WARNING, "res_odbc: Error AllocHDB %d\n", res);
SQLFreeHandle(SQL_HANDLE_ENV, obj->env);
if((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) { ast_mutex_unlock(&obj->lock);
return ODBC_FAIL;
}
SQLSetConnectAttr(obj->con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *) 10, 0);
}
if(option_verbose > 3) res = SQLConnect(obj->con,
ast_log(LOG_WARNING, "res_odbc: Error AllocHDB %d\n", res); (SQLCHAR *) obj->dsn, SQL_NTS,
SQLFreeHandle(SQL_HANDLE_ENV, obj->env); (SQLCHAR *) obj->username, SQL_NTS,
(SQLCHAR *) obj->password, SQL_NTS);
ast_mutex_unlock(&obj->lock); if ((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
return ODBC_FAIL; SQLGetDiagRec(SQL_HANDLE_DBC, obj->con, 1, stat, &err, msg, 100, &mlen);
} SQLFreeHandle(SQL_HANDLE_ENV, obj->env);
SQLSetConnectAttr(obj->con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *)10, 0); if (option_verbose > 3)
} ast_log(LOG_WARNING, "res_odbc: Error SQLConnect=%d errno=%ld %s\n", res, err, msg);
return ODBC_FAIL;
} else {
if (option_verbose > 3)
ast_log(LOG_NOTICE, "res_odbc: Connected to %s [%s]\n", obj->name, obj->dsn);
obj->up = 1;
}
ast_mutex_unlock(&obj->lock);
res = SQLConnect( return ODBC_SUCCESS;
obj->con,
(SQLCHAR*) obj->dsn,SQL_NTS,
(SQLCHAR*) obj->username,SQL_NTS,
(SQLCHAR*) obj->password,SQL_NTS
);
if((res != SQL_SUCCESS) && (res != SQL_SUCCESS_WITH_INFO)) {
SQLGetDiagRec(SQL_HANDLE_DBC, obj->con, 1, stat, &err, msg, 100, &mlen);
SQLFreeHandle(SQL_HANDLE_ENV, obj->env);
if(option_verbose > 3)
ast_log(LOG_WARNING,"res_odbc: Error SQLConnect=%d errno=%ld %s\n", res,err,msg);
return ODBC_FAIL;
}
else {
if(option_verbose > 3)
ast_log(LOG_NOTICE, "res_odbc: Connected to %s [%s]\n",obj->name,obj->dsn);
obj->up=1;
}
ast_mutex_unlock(&obj->lock);
return ODBC_SUCCESS;
} }
STANDARD_LOCAL_USER; STANDARD_LOCAL_USER;
LOCAL_USER_DECL; LOCAL_USER_DECL;
int unload_module(void)
int unload_module(void) { {
STANDARD_HANGUP_LOCALUSERS; STANDARD_HANGUP_LOCALUSERS;
odbc_destroy();
odbc_destroy(); ast_cli_unregister(&odbc_command_struct);
ast_cli_unregister(&odbc_command_struct); ast_log(LOG_NOTICE, "res_odbc unloaded.\n");
ast_log(LOG_NOTICE,"res_odbc unloaded.\n"); return 0;
return 0;
} }
int load_module(void) { int load_module(void)
odbc_init(); {
load_odbc_config(); odbc_init();
ast_cli_register(&odbc_command_struct); load_odbc_config();
ast_log(LOG_NOTICE,"res_odbc loaded.\n"); ast_cli_register(&odbc_command_struct);
return 0; ast_log(LOG_NOTICE, "res_odbc loaded.\n");
return 0;
} }
char *description(void) { char *description(void)
return tdesc; {
return tdesc;
} }
int usecount(void) { int usecount(void)
int res; {
STANDARD_USECOUNT(res); int res;
return res; STANDARD_USECOUNT(res);
return res;
} }
char *key() { char *key()
return ASTERISK_GPL_KEY; {
return ASTERISK_GPL_KEY;
} }