static memcached_return io_wait(memcached_server_st *ptr,
memc_read_or_write read_or_write)
{
- struct pollfd fds[1]= {
- [0].fd= ptr->fd,
- [0].events = POLLIN
+ struct pollfd fds= {
+ .fd= ptr->fd,
+ .events = POLLIN
};
- short flags= 0;
int error;
unlikely (read_or_write == MEM_WRITE) /* write */
- fds[0].events= POLLOUT;
+ fds.events= POLLOUT;
/*
** We are going to block on write, but at least on Solaris we might block
if ((ptr->root->flags & MEM_NO_BLOCK) == 0)
timeout= -1;
- error= poll(fds, 1, timeout);
+ error= poll(&fds, 1, timeout);
if (error == 1)
return MEMCACHED_SUCCESS;
&ptr->root->result);
if (error == MEMCACHED_SUCCESS)
{
- for (int x= 0; x < cb.number_of_callback; x++)
+ for (unsigned int x= 0; x < cb.number_of_callback; x++)
{
error= (*cb.callback[x])(ptr->root, &ptr->root->result, cb.context);
if (error != MEMCACHED_SUCCESS)
int max_keys= binary ? 20480 : 1;
- char **keys= calloc(max_keys, sizeof(char*));
- size_t *key_length=calloc(max_keys, sizeof(size_t));
+ char **keys= calloc((size_t)max_keys, sizeof(char*));
+ size_t *key_length=calloc((size_t)max_keys, sizeof(size_t));
/* First add all of the items.. */
char blob[1024] = {0};
for (int x= 0; x < max_keys; ++x)
{
char k[251];
- key_length[x]= snprintf(k, sizeof(k), "0200%u", x);
+ key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%u", x);
keys[x]= strdup(k);
assert(keys[x] != NULL);
rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
memcached_execute_function callbacks[1]= { [0]= &callback_counter };
rc= memcached_mget_execute(memc, NULL, 0,
(const char**)keys, key_length,
- max_keys, callbacks, &counter, 1);
+ (size_t)max_keys, callbacks, &counter, 1);
if (binary)
{
assert(rc == MEMCACHED_END);
/* Verify that we got all of the items */
- assert(counter == max_keys);
+ assert(counter == (unsigned int)max_keys);
}
else
{