static int mcache_init(void) {
const char *version;
memcache_pool = make_sub_pool(permanent_pool);
pr_pool_tag(memcache_pool, MOD_MEMCACHE_VERSION);
memcache_server_lists = make_array(memcache_pool, 2,
sizeof(memcached_server_st **));
memcache_init();
pr_event_register(&memcache_module, "core.restart", mcache_restart_ev, NULL);
version = memcached_lib_version();
if (strcmp(version, LIBMEMCACHED_VERSION_STRING) != 0) {
pr_log_pri(PR_LOG_INFO, MOD_MEMCACHE_VERSION
": compiled using libmemcached-%s headers, but linked to "
"libmemcached-%s library", LIBMEMCACHED_VERSION_STRING, version);
} else {
pr_log_debug(DEBUG2, MOD_MEMCACHE_VERSION ": using libmemcached-%s",
version);
}
return 0;
}
/** Create a new rlm_cache_memcached instance
*
* @param conf memcached specific conf section.
* @param inst main rlm_cache instance.
* @return 0 on success, -1 on failure.
*/
static int mod_instantiate(CONF_SECTION *conf, rlm_cache_t *inst)
{
rlm_cache_memcached_t *driver;
memcached_return_t ret;
char buffer[256];
static bool version_done;
buffer[0] = '\0';
/*
* Get version info from the libmemcached API.
*/
if (!version_done) {
version_done = true;
INFO("rlm_cache_memcached: libmemcached version: %s", memcached_lib_version());
}
driver = talloc_zero(inst, rlm_cache_memcached_t);
talloc_set_destructor(driver, _mod_detach);
if (cf_section_parse(conf, driver, driver_config) < 0) return -1;
ret = libmemcached_check_configuration(driver->options, talloc_array_length(driver->options) -1,
buffer, sizeof(buffer));
if (ret != MEMCACHED_SUCCESS) {
ERROR("rlm_cache_memcached: Failed validating options string: %s", buffer);
return -1;
}
inst->driver = driver;
snprintf(buffer, sizeof(buffer), "rlm_cache (%s)", inst->name);
driver->pool = fr_connection_pool_module_init(conf, inst, mod_conn_create, NULL, buffer);
if (!driver->pool) return -1;
if (inst->max_entries > 0) WARN("rlm_cache_memcached: max_entries is not supported by this driver");
return 0;
}
/*!
* \brief Module initialization function
* \return 0 on success, -1 on failure
*/
static int mod_init(void) {
char *server, *port;
unsigned int len = 0;
memcached_return rc;
struct memcached_server_st *svt;
if ((port = strchr(mcd_srv_str, ':')) != NULL) {
port = port + 1;
len = strlen(mcd_srv_str) - strlen(port) - 1;
} else {
LM_DBG("no port definition, using default port\n");
port = "11211";
len = strlen(mcd_srv_str) ;
}
server = pkg_malloc(len+1);
if (server == NULL) {
PKG_MEM_ERROR;
return -1;
}
strncpy(server, mcd_srv_str, len);
server[len] = '\0';
memcached_h = memcached_create(NULL);
if (memcached_h == NULL) {
LM_ERR("could not create memcached structure\n");
pkg_free(server);
return -1;
}
LM_DBG("allocated new server handle at %p", memcached_h);
if (mcd_memory == 1) {
LM_INFO("Use internal kamailio memory manager for memcached client library\n");
#if LIBMEMCACHED_VERSION_HEX >= 0x00038000
rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_fn)mcd_malloc,
(memcached_free_fn)mcd_free, (memcached_realloc_fn)mcd_realloc,
(memcached_calloc_fn)mcd_calloc, NULL);
#else
rc = memcached_set_memory_allocators(memcached_h, (memcached_malloc_function)mcd_malloc_compat,
(memcached_free_function)mcd_free_compat, (memcached_realloc_function)mcd_realloc_compat,
(memcached_calloc_function)mcd_calloc_compat);
#endif
if (rc == MEMCACHED_SUCCESS) {
LM_DBG("memory manager callbacks set\n");
} else {
LM_ERR("memory manager callbacks not set, returned %s.\n", memcached_strerror(memcached_h, rc));
pkg_free(server);
return -1;
}
} else {
LM_INFO("Use system memory manager for memcached client library\n");
}
svt = memcached_server_list_append(servers, server, atoi(port), &rc);
if(svt==NULL) {
LM_ERR("failed to append server\n");
if(servers) {
memcached_server_list_free(servers);
servers = NULL;
}
pkg_free(server);
return -1;
}
servers = svt;
if (memcached_behavior_set(memcached_h, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, mcd_timeout) != MEMCACHED_SUCCESS) {
LM_ERR("could not set server connection timeout\n");
pkg_free(server);
return -1;
}
rc = memcached_server_push(memcached_h, servers);
if (rc == MEMCACHED_SUCCESS) {
LM_DBG("added server list to structure\n");
} else {
LM_ERR("attempt to add server list to structure returned %s.\n", memcached_strerror(memcached_h, rc));
pkg_free(server);
return -1;
}
pkg_free(server);
/** \todo FIXME logic to handle connection errors on startup
memcached_server_cursor(memcached_h, (const memcached_server_fn*) &mcd_check_connection, NULL, 1);
*/
LM_INFO("libmemcached version is %s\n", memcached_lib_version());
return 0;
}
/**
* Get the library version string.
* @return std::string containing a copy of the library version string.
*/
const std::string libVersion() const
{
const char *ver= memcached_lib_version();
const std::string version(ver);
return version;
}
