static memcached_return server_add(memcached_st *ptr, const char *hostname,
unsigned int port,
uint32_t weight,
memcached_connection type)
{
memcached_server_st *new_host_list;
if ( (ptr->flags & MEM_USE_UDP && type != MEMCACHED_CONNECTION_UDP)
|| ( (type == MEMCACHED_CONNECTION_UDP) && !(ptr->flags & MEM_USE_UDP) ) )
return MEMCACHED_INVALID_HOST_PROTOCOL;
new_host_list= ptr->call_realloc(ptr, ptr->hosts,
sizeof(memcached_server_st) * (ptr->number_of_hosts+1));
if (new_host_list == NULL)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
ptr->hosts= new_host_list;
/* TODO: Check return type */
(void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], hostname, port, weight, type);
ptr->number_of_hosts++;
ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
return run_distribution(ptr);
}
static memcached_return_t server_add(memcached_st *ptr, const char *hostname,
in_port_t port,
uint32_t weight,
memcached_connection_t type)
{
memcached_server_st *new_host_list;
memcached_server_write_instance_st instance;
if ( (ptr->flags.use_udp && type != MEMCACHED_CONNECTION_UDP)
|| ( (type == MEMCACHED_CONNECTION_UDP) && (! ptr->flags.use_udp) ) )
return MEMCACHED_INVALID_HOST_PROTOCOL;
new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr),
sizeof(memcached_server_st) * (ptr->number_of_hosts + 1));
if (new_host_list == NULL)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
memcached_server_list_set(ptr, new_host_list);
/* TODO: Check return type */
instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
(void)memcached_server_create_with(ptr, instance, hostname, port, weight, type);
ptr->number_of_hosts++;
instance= memcached_server_instance_fetch(ptr, 0);
memcached_servers_set_count(instance, memcached_server_count(ptr));
return run_distribution(ptr);
}
memcached_return_t memcached_server_push(memcached_st *ptr, const memcached_server_list_st list)
{
uint32_t count;
memcached_server_st *new_host_list;
uint32_t x;
if (! list)
return MEMCACHED_SUCCESS;
count= memcached_server_list_count(list);
new_host_list= libmemcached_realloc(ptr, memcached_server_list(ptr),
sizeof(memcached_server_st) * (count + memcached_server_count(ptr)));
if (! new_host_list)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
memcached_server_list_set(ptr, new_host_list);
for (x= 0; x < count; x++)
{
memcached_server_write_instance_st instance;
if ((ptr->flags.use_udp && list[x].type != MEMCACHED_CONNECTION_UDP)
|| ((list[x].type == MEMCACHED_CONNECTION_UDP)
&& ! (ptr->flags.use_udp)) )
return MEMCACHED_INVALID_HOST_PROTOCOL;
WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
instance= memcached_server_instance_fetch(ptr, memcached_server_count(ptr));
/* TODO check return type */
(void)memcached_server_create_with(ptr, instance, list[x].hostname,
list[x].port, list[x].weight, list[x].type);
ptr->number_of_hosts++;
}
/* Provides backwards compatibility with server list. */
{
memcached_server_write_instance_st instance;
instance= memcached_server_instance_fetch(ptr, 0);
instance->number_of_hosts= memcached_server_count(ptr);
}
return run_distribution(ptr);
}
memcached_server_list_st
memcached_server_list_append_with_weight(memcached_server_list_st ptr,
const char *hostname, in_port_t port,
uint32_t weight,
memcached_return_t *error)
{
uint32_t count;
memcached_server_list_st new_host_list;
if (hostname == NULL || error == NULL)
return NULL;
if (! port)
port= MEMCACHED_DEFAULT_PORT;
/* Increment count for hosts */
count= 1;
if (ptr != NULL)
{
count+= memcached_server_list_count(ptr);
}
new_host_list= (memcached_server_write_instance_st)realloc(ptr, sizeof(memcached_server_st) * count);
if (!new_host_list)
{
*error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
return NULL;
}
/* TODO: Check return type */
memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP);
/* Backwards compatibility hack */
memcached_servers_set_count(new_host_list, count);
*error= MEMCACHED_SUCCESS;
return new_host_list;
}
memcached_server_st *memcached_server_list_append_with_weight(memcached_server_st *ptr,
const char *hostname, unsigned int port,
uint32_t weight,
memcached_return *error)
{
unsigned int count;
memcached_server_st *new_host_list;
if (hostname == NULL || error == NULL)
return NULL;
if (!port)
port= MEMCACHED_DEFAULT_PORT;
/* Increment count for hosts */
count= 1;
if (ptr != NULL)
{
count+= ptr[0].count;
}
new_host_list= (memcached_server_st *)realloc(ptr, sizeof(memcached_server_st) * count);
if (!new_host_list)
{
*error= MEMCACHED_MEMORY_ALLOCATION_FAILURE;
return NULL;
}
/* TODO: Check return type */
memcached_server_create_with(NULL, &new_host_list[count-1], hostname, port, weight, MEMCACHED_CONNECTION_TCP);
/* Backwards compatibility hack */
new_host_list[0].count= (uint16_t) count;
*error= MEMCACHED_SUCCESS;
return new_host_list;
}
memcached_return memcached_server_push(memcached_st *ptr, memcached_server_st *list)
{
unsigned int x;
uint16_t count;
memcached_server_st *new_host_list;
if (!list)
return MEMCACHED_SUCCESS;
count= list[0].count;
new_host_list= ptr->call_realloc(ptr, ptr->hosts,
sizeof(memcached_server_st) * (count + ptr->number_of_hosts));
if (!new_host_list)
return MEMCACHED_MEMORY_ALLOCATION_FAILURE;
ptr->hosts= new_host_list;
for (x= 0; x < count; x++)
{
if ((ptr->flags & MEM_USE_UDP && list[x].type != MEMCACHED_CONNECTION_UDP)
|| ((list[x].type == MEMCACHED_CONNECTION_UDP)
&& ! (ptr->flags & MEM_USE_UDP)) )
return MEMCACHED_INVALID_HOST_PROTOCOL;
WATCHPOINT_ASSERT(list[x].hostname[0] != 0);
memcached_server_create(ptr, &ptr->hosts[ptr->number_of_hosts]);
/* TODO check return type */
(void)memcached_server_create_with(ptr, &ptr->hosts[ptr->number_of_hosts], list[x].hostname,
list[x].port, list[x].weight, list[x].type);
ptr->number_of_hosts++;
}
ptr->hosts[0].count= (uint16_t) ptr->number_of_hosts;
return run_distribution(ptr);
}
