X-Git-Url: https://git.m6w6.name/?a=blobdiff_plain;f=libmemcached%2Fmemcached_server.c;h=2cff36da2eedf007a0c3d163137a2cf169151b77;hb=521e830fe336a17bee6e7376e3bf01a3b35ddc37;hp=c836cfa297f9de48b241d5f1e5d91a7f763e1d64;hpb=44a351afa447e7a6299258550d3ee3b498b42093;p=m6w6%2Flibmemcached diff --git a/libmemcached/memcached_server.c b/libmemcached/memcached_server.c index c836cfa2..2cff36da 100644 --- a/libmemcached/memcached_server.c +++ b/libmemcached/memcached_server.c @@ -1,3 +1,14 @@ +/* LibMemcached + * Copyright (C) 2006-2009 Brian Aker + * All rights reserved. + * + * Use and distribution licensed under the BSD license. See + * the COPYING file in the parent directory for full text. + * + * Summary: String structure used for libmemcached. + * + */ + /* This is a partial implementation for fetching/creating memcached_server_st objects. */ @@ -7,46 +18,69 @@ memcached_server_st *memcached_server_create(memcached_st *memc, memcached_serve { if (ptr == NULL) { - ptr= (memcached_server_st *)malloc(sizeof(memcached_server_st)); + ptr= (memcached_server_st *)calloc(1, sizeof(memcached_server_st)); if (!ptr) return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */ - memset(ptr, 0, sizeof(memcached_server_st)); - ptr->is_allocated= MEMCACHED_ALLOCATED; + ptr->options.is_allocated= true; } else { memset(ptr, 0, sizeof(memcached_server_st)); } - + ptr->root= memc; return ptr; } -void memcached_server_free(memcached_server_st *ptr) +memcached_server_st *memcached_server_create_with(memcached_st *memc, memcached_server_st *host, + const char *hostname, in_port_t port, + uint32_t weight, memcached_connection_t type) { - memcached_return rc; - WATCHPOINT_ASSERT(ptr->is_allocated != MEMCACHED_NOT_ALLOCATED); + host= memcached_server_create(memc, host); + + if (host == NULL) + return NULL; + + strncpy(host->hostname, hostname, MEMCACHED_MAX_HOST_LENGTH - 1); + host->root= memc ? memc : NULL; + host->port= port; + host->weight= weight; + host->fd= -1; + host->type= type; + host->read_ptr= host->read_buffer; + if (memc) + host->next_retry= memc->retry_timeout; + if (type == MEMCACHED_CONNECTION_UDP) + { + host->write_buffer_offset= UDP_DATAGRAM_HEADER_LENGTH; + memcached_io_init_udp_header(host, 0); + } + return host; +} + +void memcached_server_free(memcached_server_st *ptr) +{ memcached_quit_server(ptr, 0); + if (ptr->cached_server_error) + free(ptr->cached_server_error); + if (ptr->address_info) - { freeaddrinfo(ptr->address_info); - ptr->address_info= NULL; - } - if (ptr->is_allocated == MEMCACHED_ALLOCATED) + + if (memcached_is_allocated(ptr)) { - if (ptr->root && ptr->root->call_free) - ptr->root->call_free(ptr->root, ptr); - else - free(ptr); + ptr->root->call_free(ptr->root, ptr); } else - ptr->is_allocated= MEMCACHED_USED; + { + memset(ptr, 0, sizeof(memcached_server_st)); + } } /* @@ -54,36 +88,30 @@ void memcached_server_free(memcached_server_st *ptr) */ memcached_server_st *memcached_server_clone(memcached_server_st *clone, memcached_server_st *ptr) { - memcached_server_st *new_clone; + memcached_server_st *rv= NULL; /* We just do a normal create if ptr is missing */ if (ptr == NULL) return NULL; - if (clone && clone->is_allocated == MEMCACHED_USED) + rv = memcached_server_create_with(ptr->root, clone, + ptr->hostname, ptr->port, ptr->weight, + ptr->type); + if (rv != NULL) { - WATCHPOINT_ASSERT(0); - return NULL; + rv->cached_errno= ptr->cached_errno; + if (ptr->cached_server_error) + rv->cached_server_error= strdup(ptr->cached_server_error); } - - new_clone= memcached_server_create(ptr->root, clone); - - if (new_clone == NULL) - return NULL; - - new_clone->root= ptr->root; - host_reset(new_clone->root, new_clone, - ptr->hostname, ptr->port, ptr->weight, - ptr->type); + return rv; - return new_clone; } -memcached_return memcached_server_cursor(memcached_st *ptr, - memcached_server_function *callback, - void *context, - unsigned int number_of_callbacks) +memcached_return_t memcached_server_cursor(memcached_st *ptr, + memcached_server_fn *callback, + void *context, + uint32_t number_of_callbacks) { unsigned int y; @@ -105,15 +133,14 @@ memcached_return memcached_server_cursor(memcached_st *ptr, return MEMCACHED_SUCCESS; } -memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key, size_t key_length, memcached_return *error) +memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key, size_t key_length, memcached_return_t *error) { uint32_t server_key; - unlikely (key_length == 0) - { - *error= MEMCACHED_NO_KEY_PROVIDED; + *error= memcached_validate_key_length(key_length, + ptr->flags.binary_protocol); + unlikely (*error != MEMCACHED_SUCCESS) return NULL; - } unlikely (ptr->number_of_hosts == 0) { @@ -121,7 +148,7 @@ memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key return NULL; } - if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) + if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) { *error= MEMCACHED_BAD_KEY_PROVIDED; return NULL; @@ -132,3 +159,21 @@ memcached_server_st *memcached_server_by_key(memcached_st *ptr, const char *key return memcached_server_clone(NULL, &ptr->hosts[server_key]); } + +const char *memcached_server_error(memcached_server_st *ptr) +{ + if (ptr) + return ptr->cached_server_error; + else + return NULL; +} + +void memcached_server_error_reset(memcached_server_st *ptr) +{ + ptr->cached_server_error[0]= 0; +} + +memcached_server_st *memcached_server_get_last_disconnect(memcached_st *ptr) +{ + return ptr->last_disconnected_server; +}