Variant c_Memcache::t_getversion() {
int server_count = memcached_server_count(&m_memcache);
char version[16];
int version_len = 0;
if (memcached_version(&m_memcache) != MEMCACHED_SUCCESS) {
return false;
}
for (int x = 0; x < server_count; x++) {
memcached_server_instance_st instance =
memcached_server_instance_by_position(&m_memcache, x);
if (!instance->major_version) {
continue;
}
version_len = snprintf(version, sizeof(version), "%d.%d.%d",
instance->major_version, instance->minor_version,
instance->micro_version);
return String(version, version_len, CopyString);
}
return false;
}
Variant c_Memcache::t_getversion() {
int server_count = memcached_server_count(&m_memcache);
char version[16];
int version_len = 0;
if (memcached_version(&m_memcache) != MEMCACHED_SUCCESS) {
return false;
}
for (int x = 0; x < server_count; x++) {
LMCD_SERVER_POSITION_INSTANCE_TYPE instance =
memcached_server_instance_by_position(&m_memcache, x);
uint8_t majorVersion = LMCD_SERVER_MAJOR_VERSION(instance);
uint8_t minorVersion = LMCD_SERVER_MINOR_VERSION(instance);
uint8_t microVersion = LMCD_SERVER_MICRO_VERSION(instance);
if (!majorVersion) {
continue;
}
version_len = snprintf(version, sizeof(version),
"%" PRIu8 ".%" PRIu8 ".%" PRIu8,
majorVersion, minorVersion, microVersion);
return String(version, version_len, CopyString);
}
return false;
}
/**
@note This should be testing to see if the server really supports the binary protocol.
*/
static test_return_t pre_binary(memcached_st *memc)
{
memcached_return_t rc= MEMCACHED_FAILURE;
memcached_st *memc_clone;
memcached_server_instance_st instance;
memc_clone= memcached_clone(NULL, memc);
test_true(memc_clone);
// The memcached_version needs to be done on a clone, because the server
// will not toggle protocol on an connection.
memcached_version(memc_clone);
instance= memcached_server_instance_by_position(memc_clone, 0);
if (instance->major_version >= 1 && instance->minor_version > 2)
{
rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
test_true(rc == MEMCACHED_SUCCESS);
test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
}
memcached_free(memc_clone);
return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
}
/** Create a new memcached handle
*
* @param ctx to allocate handle in.
* @param instance data.
*/
static void *mod_conn_create(TALLOC_CTX *ctx, void *instance)
{
rlm_cache_t *inst = instance;
rlm_cache_memcached_t *driver = inst->driver;
rlm_cache_memcached_handle_t *mandle;
memcached_st *sandle;
memcached_return_t ret;
sandle = memcached(driver->options, talloc_array_length(driver->options) -1);
if (!sandle) {
ERROR("rlm_cache_memcached: Failed creating memcached connection");
return NULL;
}
ret = memcached_version(sandle);
if (ret != MEMCACHED_SUCCESS) {
ERROR("rlm_cache_memcached: Failed getting server info: %s: %s", memcached_strerror(sandle, ret),
memcached_last_error_message(sandle));
memcached_free(sandle);
return NULL;
}
mandle = talloc_zero(ctx, rlm_cache_memcached_handle_t);
mandle->handle = sandle;
talloc_set_destructor(mandle, _mod_conn_free);
return mandle;
}
static test_return_t udp_version_test(memcached_st *memc)
{
memcached_return_t rc;
uint16_t *expected_ids = get_udp_request_ids(memc);
rc = memcached_version(memc);
test_true(rc == MEMCACHED_NOT_SUPPORTED);
return post_udp_op_check(memc, expected_ids);
}
/*
** There is a little bit of a hack here, instead of removing
** the servers, I just set num host to 0 and them add then new udp servers
**/
static test_return_t init_udp(memcached_st *memc)
{
memcached_version(memc);
#if 0
memcached_server_instance_st instance=
memcached_server_instance_by_position(memc, 0);
/* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
if (instance->major_version != 1 || instance->minor_version != 2
|| instance->micro_version < 6)
return TEST_SKIPPED;
uint32_t num_hosts= memcached_server_count(memc);
memcached_server_st servers[num_hosts];
memcpy(servers, memcached_server_list(memc), sizeof(memcached_server_st) * num_hosts);
for (uint32_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st set_instance=
memcached_server_instance_by_position(memc, x);
memcached_server_free(((memcached_server_write_instance_st)set_instance));
}
memc->number_of_hosts= 0;
memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
for (uint32_t x= 0; x < num_hosts; x++)
{
memcached_server_instance_st set_instance=
memcached_server_instance_by_position(memc, x);
test_true(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
test_true(set_instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
}
#endif
return TEST_SKIPPED;
}
