void na_event_queue_destroy(na_event_queue_t *q)
{
pthread_mutex_destroy(&q->lock);
pthread_cond_destroy(&q->cond);
NA_FREE(q->queue);
NA_FREE(q);
}
/************************************************************************
* name: odbc_free_record
* arguments:
* returns/side-effects:
* description:
* NOTE:
************************************************************************/
PUBLIC RETCODE
odbc_free_record (ODBC_RECORD * record)
{
ODBC_RECORD *r, *prev;
if (record == NULL)
{
goto error;
}
NA_FREE (record->base_column_name);
NA_FREE (record->base_table_name);
NA_FREE (record->catalog_name);
NA_FREE (record->literal_prefix);
NA_FREE (record->literal_suffix);
NA_FREE (record->local_type_name);
NA_FREE (record->name);
NA_FREE (record->schema_name);
NA_FREE (record->table_name);
NA_FREE (record->type_name);
// remove link from descriptor
if (record->desc != NULL)
{
for (r = record->desc->records, prev = NULL; r != NULL && r != record;
r = r->next)
{
prev = r;
}
if (r == record)
{
if (prev != NULL)
prev->next = record->next;
else
record->desc->records = record->next;
}
}
UT_FREE (record);
return ODBC_SUCCESS;
error:
return ODBC_ERROR;
}
int main (int argc, char *argv[])
{
pthread_t th[NA_ENV_MAX];
na_env_t *env[NA_ENV_MAX];
mpool_t *env_pool;
int c;
int env_cnt = 0;
bool is_daemon = false;
struct json_object *conf_obj = NULL;
struct json_object *environments_obj = NULL;
while (-1 != (c = getopt(argc, argv,
"f:" /* configuration file with JSON */
"t:" /* check configuration file */
"d" /* go to background */
"v" /* show version and information */
"h" /* show help */
)))
{
switch (c) {
case 'd':
is_daemon = true;
break;
case 'f':
ConfFile = optarg;
conf_obj = na_get_conf(optarg);
environments_obj = na_get_environments(conf_obj, &env_cnt);
break;
case 't':
conf_obj = na_get_conf(optarg);
environments_obj = na_get_environments(conf_obj, &env_cnt);
printf("JSON configuration is OK\n");
return 0;
break;
case 'v':
na_version();
return 0;
break;
case 'h':
na_usage();
return 0;
break;
default:
break;
}
}
if (is_daemon && daemon(0, 0) == -1) {
NA_DIE_WITH_ERROR(NA_ERROR_FAILED_DAEMONIZE);
}
if (env_cnt > NA_ENV_MAX) {
NA_DIE_WITH_ERROR(NA_ERROR_TOO_MANY_ENVIRONMENTS);
}
StartTimestamp = time(NULL);
na_setup_signals();
na_memproto_bm_skip_init();
env_pool = mpool_create(0);
if (env_cnt == 0) {
env_cnt = 1;
env[0] = na_env_add(&env_pool);
na_env_setup_default(env[0], 0);
} else {
for (int i=0;i<env_cnt;++i) {
env[i] = na_env_add(&env_pool);
na_env_setup_default(env[i], i);
na_conf_env_init(environments_obj, env[i], i, false);
}
}
json_object_put(conf_obj);
for (int i=0;i<env_cnt;++i) {
env[i]->current_conn = 0;
env[i]->is_refused_active = false;
env[i]->is_refused_accept = false;
env[i]->is_worker_busy = calloc(sizeof(bool), env[i]->worker_max);
for (int j=0;j<env[i]->worker_max;++j) {
env[i]->is_worker_busy[j] = false;
}
env[i]->error_count = 0;
env[i]->current_conn_max = 0;
pthread_mutex_init(&env[i]->lock_connpool, NULL);
pthread_mutex_init(&env[i]->lock_current_conn, NULL);
pthread_mutex_init(&env[i]->lock_tid, NULL);
pthread_mutex_init(&env[i]->lock_loop, NULL);
pthread_mutex_init(&env[i]->lock_error_count, NULL);
pthread_rwlock_init(&env[i]->lock_refused, NULL);
pthread_rwlock_init(&env[i]->lock_request_bufsize_max, NULL);
pthread_rwlock_init(&env[i]->lock_response_bufsize_max, NULL);
pthread_rwlock_init(&LockReconf, NULL);
env[i]->lock_worker_busy = calloc(sizeof(pthread_rwlock_t), env[i]->worker_max);
for (int j=0;j<env[i]->worker_max;++j) {
pthread_rwlock_init(&env[i]->lock_worker_busy[j], NULL);
}
na_connpool_create(&env[i]->connpool_active, env[i]->connpool_max);
if (env[i]->is_use_backup) {
na_connpool_create(&env[i]->connpool_backup, env[i]->connpool_max);
}
}
for (int i=0;i<env_cnt;++i) {
pthread_create(&th[i], NULL, na_event_loop, env[i]);
}
// monitoring signal
while (true) {
if (SigExit == 1) {
break;
}
if (SigReconf == 1) {
conf_obj = na_get_conf(ConfFile);
environments_obj = na_get_environments(conf_obj, &env_cnt);
pthread_rwlock_wrlock(&LockReconf);
for (int i=0;i<env_cnt;++i) {
na_conf_env_init(environments_obj, env[i], i, true);
}
pthread_rwlock_unlock(&LockReconf);
json_object_put(conf_obj);
SigReconf = 0;
}
// XXX we should sleep forever and only wake upon a signal
sleep(1);
}
for (int i=0;i<env_cnt;++i) {
na_connpool_destroy(&env[i]->connpool_active);
if (env[i]->is_use_backup) {
na_connpool_destroy(&env[i]->connpool_backup);
}
pthread_mutex_destroy(&env[i]->lock_connpool);
pthread_mutex_destroy(&env[i]->lock_current_conn);
pthread_mutex_destroy(&env[i]->lock_tid);
pthread_mutex_destroy(&env[i]->lock_error_count);
pthread_rwlock_destroy(&env[i]->lock_refused);
pthread_rwlock_destroy(&env[i]->lock_request_bufsize_max);
pthread_rwlock_destroy(&env[i]->lock_response_bufsize_max);
pthread_rwlock_destroy(&LockReconf);
for (int j=0;j<env[i]->worker_max;++j) {
pthread_rwlock_destroy(&env[i]->lock_worker_busy[j]);
}
NA_FREE(env[i]->is_worker_busy);
NA_FREE(env[i]->lock_worker_busy);
pthread_detach(th[i]);
}
mpool_destroy(env_pool);
return 0;
}
void na_connpool_destroy (na_connpool_t *connpool)
{
NA_FREE(connpool->fd_pool);
NA_FREE(connpool->mark);
}
