X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fprotocol%2Fprotocol_handler.c;h=fcab1419f7c100083a232b0c405cb0ccf65da806;hb=609d07c5a051c301ce6595747c2f64d3819554f5;hp=adba9ad7f73bfa748d7299d6adfbbc98079fc592;hpb=34418e51585216006d5b241fc9104dc4b88d1be0;p=m6w6%2Flibmemcached diff --git a/libmemcached/protocol/protocol_handler.c b/libmemcached/protocol/protocol_handler.c index adba9ad7..fcab1419 100644 --- a/libmemcached/protocol/protocol_handler.c +++ b/libmemcached/protocol/protocol_handler.c @@ -3,7 +3,6 @@ #include #include -#include #include #include #include @@ -29,7 +28,7 @@ * @return the number of bytes transferred of -1 upon error */ static ssize_t default_recv(const void *cookie, - int sock, + memcached_socket_t sock, void *buf, size_t nbytes) { @@ -49,7 +48,7 @@ static ssize_t default_recv(const void *cookie, * @return the number of bytes transferred of -1 upon error */ static ssize_t default_send(const void *cookie, - int fd, + memcached_socket_t fd, const void *buf, size_t nbytes) { @@ -79,13 +78,13 @@ static bool drain_output(struct memcached_protocol_client_st *client) if (len == -1) { - if (errno == EWOULDBLOCK) + if (get_socket_errno() == EWOULDBLOCK) { return true; } - else if (errno != EINTR) + else if (get_socket_errno() != EINTR) { - client->error= errno; + client->error= get_socket_errno(); return false; } } @@ -124,13 +123,13 @@ static struct chunk_st *allocate_output_chunk(struct memcached_protocol_client_s return NULL; } - ret->offset = ret->nbytes = 0; - ret->next = NULL; - ret->size = CHUNK_BUFFERSIZE; + ret->offset= ret->nbytes= 0; + ret->next= NULL; + ret->size= CHUNK_BUFFERSIZE; ret->data= (void*)(ret + 1); if (client->output == NULL) { - client->output = client->output_tail = ret; + client->output= client->output_tail= ret; } else { @@ -159,7 +158,7 @@ static protocol_binary_response_status spool_output(struct memcached_protocol_cl return PROTOCOL_BINARY_RESPONSE_SUCCESS; } - size_t offset = 0; + size_t offset= 0; struct chunk_st *chunk= client->output; while (offset < length) @@ -172,10 +171,10 @@ static protocol_binary_response_status spool_output(struct memcached_protocol_cl } } - size_t bulk = length - offset; + size_t bulk= length - offset; if (bulk > chunk->size - chunk->nbytes) { - bulk = chunk->size - chunk->nbytes; + bulk= chunk->size - chunk->nbytes; } memcpy(chunk->data + chunk->nbytes, data, bulk); @@ -194,7 +193,7 @@ static protocol_binary_response_status spool_output(struct memcached_protocol_cl * so the implementors needs to provide an implementation of that interface * */ -static enum MEMCACHED_PROTOCOL_EVENT determine_protocol(struct memcached_protocol_client_st *client, ssize_t *length, void **endptr) +static memcached_protocol_event_t determine_protocol(struct memcached_protocol_client_st *client, ssize_t *length, void **endptr) { if (*client->root->input_buffer == (uint8_t)PROTOCOL_BINARY_REQ) { @@ -220,7 +219,7 @@ static enum MEMCACHED_PROTOCOL_EVENT determine_protocol(struct memcached_protoco const char *err= "CLIENT_ERROR: Unsupported protocol\r\n"; client->root->spool(client, err, strlen(err)); client->root->drain(client); - return ERROR_EVENT; /* Unsupported protocol */ + return MEMCACHED_PROTOCOL_ERROR_EVENT; /* Unsupported protocol */ } return client->work(client, length, endptr); @@ -250,10 +249,10 @@ struct memcached_protocol_st *memcached_protocol_create_instance(void) return NULL; } - ret->buffer_cache = cache_create("protocol_handler", + ret->buffer_cache= cache_create("protocol_handler", CHUNK_BUFFERSIZE + sizeof(struct chunk_st), 0, NULL, NULL); - if (ret->buffer_cache == NULL) + if (ret->buffer_cache == NULL) { free(ret->input_buffer); free(ret); @@ -270,7 +269,7 @@ void memcached_protocol_destroy_instance(struct memcached_protocol_st *instance) free(instance); } -struct memcached_protocol_client_st *memcached_protocol_create_client(struct memcached_protocol_st *instance, int sock) +struct memcached_protocol_client_st *memcached_protocol_create_client(struct memcached_protocol_st *instance, memcached_socket_t sock) { struct memcached_protocol_client_st *ret= calloc(1, sizeof(*ret)); if (ret != NULL) @@ -288,7 +287,7 @@ void memcached_protocol_client_destroy(struct memcached_protocol_client_st *clie free(client); } -enum MEMCACHED_PROTOCOL_EVENT memcached_protocol_client_work(struct memcached_protocol_client_st *client) +memcached_protocol_event_t memcached_protocol_client_work(struct memcached_protocol_client_st *client) { /* Try to send data and read from the socket */ bool more_data= true; @@ -314,9 +313,10 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_protocol_client_work(struct memcached_pr } void *endptr; - if (client->work(client, &len, &endptr) == ERROR_EVENT) + memcached_protocol_event_t events= client->work(client, &len, &endptr); + if (events == MEMCACHED_PROTOCOL_ERROR_EVENT) { - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } if (len > 0) @@ -327,7 +327,7 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_protocol_client_work(struct memcached_pr if (client->input_buffer == NULL) { client->error= ENOMEM; - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } memcpy(client->input_buffer, endptr, (size_t)len); client->input_buffer_offset= (size_t)len; @@ -338,24 +338,28 @@ enum MEMCACHED_PROTOCOL_EVENT memcached_protocol_client_work(struct memcached_pr { /* Connection closed */ drain_output(client); - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } else { - if (errno != EWOULDBLOCK) + if (get_socket_errno() != EWOULDBLOCK) { - client->error= errno; + client->error= get_socket_errno(); /* mark this client as terminated! */ - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } - more_data = false; + more_data= false; } } while (more_data); if (!drain_output(client)) { - return ERROR_EVENT; + return MEMCACHED_PROTOCOL_ERROR_EVENT; } - return (client->output) ? READ_WRITE_EVENT : READ_EVENT; + memcached_protocol_event_t ret= MEMCACHED_PROTOCOL_READ_EVENT; + if (client->output) + ret|= MEMCACHED_PROTOCOL_READ_EVENT; + + return ret; }