/*
* Copyright (C) 2008 Search Solution Corporation. All rights reserved by Search Solution.
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of the <ORGANIZATION> nor the names of its contributors
* may be used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
*
*/
/*
* cci_common.h -
*/
#ifndef _CCI_COMMON_H_
#define _CCI_COMMON_H_
#ifdef __cplusplus
extern "C"
{
#endif
#ident "$Id$"
/************************************************************************
* IMPORTED SYSTEM HEADER FILES *
************************************************************************/
#include <assert.h>
#include <errno.h>
#if defined(WINDOWS)
#include <sys/timeb.h>
#endif
/************************************************************************
* OTHER IMPORTED HEADER FILES *
************************************************************************/
#include "system.h"
#include "cas_cci.h"
#include "porting.h"
/************************************************************************
* PUBLIC DEFINITIONS *
************************************************************************/
#if defined(WINDOWS)
#define __func__ __FUNCTION__
#define gettid() GetCurrentThreadId()
#elif defined(AIX)
#define gettid() pthread_self()
#elif defined(MAC_OS)
#define gettid() getpid()
#else
#define gettid() syscall(__NR_gettid)
#endif
#define API_SLOG(con) \
do { \
if ((con)->log_trace_api) \
CCI_LOGF_DEBUG ((con)->logger, "[%04d][API][S][%s]", (con)->id, __func__); \
} while (false)
#define API_ELOG(con, err) \
do { \
if ((con)->log_trace_api) \
CCI_LOGF_DEBUG ((con)->logger, "[%04d][API][E][%s] ERROR[%d]", (con)->id, __func__, (err)); \
} while (false)
#define strlen(s1) ((int) strlen(s1))
#define CAST_STRLEN (int)
#if defined(WINDOWS)
#define MUTEX_INIT(MUTEX) \
do { \
MUTEX = CreateMutex(NULL, FALSE, NULL); \
} while (0)
#define MUTEX_LOCK(MUTEX) WaitForSingleObject(MUTEX, INFINITE)
#define MUTEX_UNLOCK(MUTEX) ReleaseMutex(MUTEX)
#define THREAD_RETURN(VALUE)
#else
#define MUTEX_INIT(MUTEX) pthread_mutex_init(&(MUTEX), NULL)
#define MUTEX_LOCK(MUTEX) pthread_mutex_lock(&(MUTEX))
#define MUTEX_UNLOCK(MUTEX) pthread_mutex_unlock(&(MUTEX))
#define THREAD_RETURN(VALUE) return (VALUE)
#endif
#if defined(WINDOWS)
#define T_MUTEX HANDLE
#define T_THREAD uintptr_t
#define THREAD_FUNC void
#else
#define T_MUTEX pthread_mutex_t
#define T_THREAD pthread_t
#define THREAD_FUNC void*
#endif
#ifdef AIX
#define MALLOC(SIZE) cci_malloc(((SIZE) == 0) ? 1 : SIZE)
#else
#define MALLOC(SIZE) cci_malloc(SIZE)
#endif
#define CALLOC(NUM, SIZE) cci_calloc(NUM, SIZE)
#define REALLOC(PTR, SIZE) \
((PTR == NULL) ? cci_malloc(SIZE) : cci_realloc(PTR, SIZE))
#define FREE(PTR) cci_free(PTR)
#define FREE_MEM(PTR) \
do { \
if (PTR) { \
FREE(PTR); \
(PTR) = 0; \
} \
} while (0)
#define ALLOC_COPY(PTR, STR) \
do { \
if ((STR) == NULL) \
(PTR) = NULL; \
else { \
(PTR) = (char *) MALLOC(strlen((char*) (STR)) + 1); \
if (PTR) { \
strcpy((char*) (PTR), (const char*) (STR)); \
} \
} \
} while (0)
#if defined(WINDOWS)
#define CLOSE_SOCKET(X) \
do { \
struct linger linger_buf; \
linger_buf.l_onoff = 1; \
linger_buf.l_linger = 0; \
setsockopt(X, SOL_SOCKET, SO_LINGER, (char *) &linger_buf, sizeof(linger_buf)); \
closesocket(X); \
} while (0)
#else
#define CLOSE_SOCKET(X) \
do { \
struct linger linger_buf; \
linger_buf.l_onoff = 1; \
linger_buf.l_linger = 0; \
setsockopt(X, SOL_SOCKET, SO_LINGER, (char *) &linger_buf, sizeof(linger_buf)); \
close(X); \
} while (0)
#endif
#define ALLOC_N_COPY(PTR, STR, SIZE, TYPE) \
do { \
if ((SIZE) == 0) \
PTR = NULL; \
else { \
PTR = (TYPE) MALLOC((SIZE) + 1); \
if (PTR) { \
strncpy(PTR, STR, SIZE); \
PTR[SIZE] = '\0'; \
} \
} \
} while (0)
#if defined(WINDOWS)
#define SLEEP_MILISEC(SEC, MSEC) Sleep((SEC) * 1000 + (MSEC))
#else
#define SLEEP_MILISEC(sec, msec) \
do { \
struct timeval sleep_time_val; \
sleep_time_val.tv_sec = sec; \
sleep_time_val.tv_usec = (msec) * 1000; \
select(0, 0, 0, 0, &sleep_time_val); \
} while(0)
#endif
#define SET_START_TIME_FOR_QUERY(CON_HANDLE, REQ_HANDLE) \
do { \
if (CON_HANDLE) { \
int time_to_check = 0; \
if (REQ_HANDLE) { \
time_to_check = ((T_REQ_HANDLE *)(REQ_HANDLE))->query_timeout;\
} \
else { \
time_to_check = (CON_HANDLE)->query_timeout; \
} \
gettimeofday(&((CON_HANDLE)->start_time), NULL); \
if (time_to_check > 0) { \
(CON_HANDLE)->current_timeout = (time_to_check); \
} \
} \
} while (0)
#define SET_START_TIME_FOR_LOGIN(CON_HANDLE) \
do { \
if (CON_HANDLE) { \
gettimeofday(&((CON_HANDLE)->start_time), NULL); \
if ((CON_HANDLE)->login_timeout > 0) { \
(CON_HANDLE)->current_timeout = (CON_HANDLE)->login_timeout;\
} \
} \
} while (0)
#define TIMEOUT_IS_SET(CON_HANDLE) \
((CON_HANDLE) && ((CON_HANDLE)->current_timeout > 0) && \
((CON_HANDLE)->start_time.tv_sec != 0 || (CON_HANDLE)->start_time.tv_usec != 0))
#define RESET_START_TIME(CON_HANDLE) \
do {\
if (CON_HANDLE) {\
(CON_HANDLE)->start_time.tv_sec = 0;\
(CON_HANDLE)->start_time.tv_usec = 0;\
(CON_HANDLE)->current_timeout = 0; \
}\
} while (0)
#if defined(WINDOWS)
typedef unsigned long in_addr_t;
#endif
#define MAX_NUMERIC_PRECISION 38
/************************************************************************
* PUBLIC TYPE DEFINITIONS *
************************************************************************/
typedef struct
{
char *key;
char *value;
} T_CCI_PROPERTIES_PAIR;
struct PROPERTIES_T
{
int capacity;
int size;
T_CCI_PROPERTIES_PAIR *pair;
};
struct DATASOURCE_T
{
int is_init;
void *mutex;
void *cond;
char *user;
char *pass;
char *url;
int max_pool_size;
int pool_size;
int max_wait;
bool pool_prepared_statement;
int max_open_prepared_statement;
int default_autocommit;
T_CCI_TRAN_ISOLATION default_isolation;
int default_lock_timeout;
int login_timeout;
int num_idle;
int *con_handles; /* realloc by pool_size */
};
typedef unsigned int (*HASH_FUNC) (void *key, unsigned int ht_size);
typedef int (*CMP_FUNC) (void *key1, void *key2);
typedef int (*REM_FUNC) (void *key, void *data, void *args);
typedef int (*PRINT_FUNC) (FILE * fp, void *key, void *data, void *args);
/* Hash Table Entry - linked list */
typedef struct hentry HENTRY;
typedef struct hentry *HENTRY_PTR;
struct hentry
{
HENTRY_PTR act_next; /* Next active entry on hash table */
HENTRY_PTR act_prev; /* Previous active entry on hash table */
HENTRY_PTR next; /* Next hash table entry for colisions */
void *key; /* Key associated with entry */
void *data; /* Data associated with key entry */
};
/* Memory Hash Table */
typedef struct mht_table MHT_TABLE;
struct mht_table
{
HASH_FUNC hash_func;
CMP_FUNC cmp_func;
const char *name;
HENTRY_PTR *table; /* The hash table (entries) */
HENTRY_PTR act_head; /* Head of active double link list
* entries. Used to perform quick
* mappings of hash table.
*/
HENTRY_PTR act_tail; /* Tail of active double link list
* entries. Used to perform quick
* mappings of hash table.
*/
HENTRY_PTR prealloc_entries; /* Free entries allocated for
* locality reasons
*/
unsigned int size; /* Better if prime number */
unsigned int rehash_at; /* Rehash at this num of entries */
unsigned int nentries; /* Actual number of entries */
unsigned int nprealloc_entries; /* Number of preallocated entries
* for future insertions
*/
unsigned int ncollisions; /* Number of collisions in HT */
};
/************************************************************************
* PUBLIC FUNCTION PROTOTYPES *
************************************************************************/
extern int get_elapsed_time (struct timeval *start_time);
extern unsigned int mht_5strhash (void *key, unsigned int ht_size);
extern int mht_strcasecmpeq (void *key1, void *key2);
extern MHT_TABLE *mht_create (char *name, int est_size, HASH_FUNC hash_func,
CMP_FUNC cmp_func);
extern void mht_destroy (MHT_TABLE * ht, bool free_key, bool free_data);
extern void *mht_rem (MHT_TABLE * ht, void *key, bool free_key,
bool free_data);
extern void *mht_get (MHT_TABLE * ht, void *key);
extern void *mht_put (MHT_TABLE * ht, void *key, void *data);
extern void *mht_put_data (MHT_TABLE * ht, void *key, void *data);
extern int hostname2uchar (char *host, unsigned char *ip_addr);
/************************************************************************
* PUBLIC VARIABLES *
************************************************************************/
extern CCI_MALLOC_FUNCTION cci_malloc;
extern CCI_FREE_FUNCTION cci_free;
extern CCI_REALLOC_FUNCTION cci_realloc;
extern CCI_CALLOC_FUNCTION cci_calloc;
#ifdef __cplusplus
}
#endif
#endif /* _CCI_COMMON_H_ */