From f307354df645d61f872b74102d501068c9443e2e Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Sun, 3 Feb 2013 20:35:06 -0500 Subject: Harmonize WIN32, and update bootstrap --- libmemcached/common.h | 2 +- libmemcached/connect.cc | 8 ++++---- libmemcached/include.am | 4 ++-- libmemcached/poll.cc | 6 +++--- libmemcached/poll.h | 6 +++--- 5 files changed, 13 insertions(+), 13 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/common.h b/libmemcached/common.h index fac6d775..71db19b0 100644 --- a/libmemcached/common.h +++ b/libmemcached/common.h @@ -107,7 +107,7 @@ # include #endif -#if defined(WIN32) || defined(__MINGW32__) +#if defined(_WIN32) # include "libmemcached/windows.hpp" #endif diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 2ec9975c..22e259f4 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -267,7 +267,7 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server) static inline void set_socket_nonblocking(org::libmemcached::Instance* server) { -#ifdef WIN32 +#if defined(_WIN32) u_long arg= 1; if (ioctlsocket(server->fd, FIONBIO, &arg) == SOCKET_ERROR) { @@ -372,7 +372,7 @@ static bool set_socket_options(org::libmemcached::Instance* server) #if defined(_WIN32) #else -#if defined(SO_NOSIGPIPE) +# if defined(SO_NOSIGPIPE) if (SO_NOSIGPIPE) { int set= 1; @@ -388,7 +388,7 @@ static bool set_socket_options(org::libmemcached::Instance* server) #endif } } -#endif // SO_NOSIGPIPE +# endif // SO_NOSIGPIPE #endif // _WIN32 if (server->root->flags.no_block) @@ -461,7 +461,7 @@ static bool set_socket_options(org::libmemcached::Instance* server) static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server) { -#ifndef WIN32 +#ifndef _WIN32 WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET); do { diff --git a/libmemcached/include.am b/libmemcached/include.am index f604731a..9eb1942c 100644 --- a/libmemcached/include.am +++ b/libmemcached/include.am @@ -61,8 +61,8 @@ libmemcached_libmemcached_la_CXXFLAGS= -DBUILDING_LIBMEMCACHED if BUILD_WIN32 libmemcached_libmemcached_la_CFLAGS+= -DBUILDING_HASHKIT libmemcached_libmemcached_la_CXXFLAGS+= -DBUILDING_HASHKIT -libmemcached_libmemcached_la_LIBADD+= -lmingw64 -libmemcached_libmemcached_la_LIBADD+= -lws2_64 +libmemcached_libmemcached_la_LIBADD+= -lmingw32 +libmemcached_libmemcached_la_LIBADD+= -lws2_32 endif libmemcached_libmemcached_la_SOURCES+= libmemcached/instance.cc diff --git a/libmemcached/poll.cc b/libmemcached/poll.cc index abd15d4c..6fdf242c 100644 --- a/libmemcached/poll.cc +++ b/libmemcached/poll.cc @@ -12,7 +12,7 @@ #include "libmemcached/common.h" -#if defined(WIN32) || defined(__MINGW32__) +#if defined(_WIN32) #include "libmemcached/poll.h" #include @@ -31,7 +31,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo) { if (fds[x].events & (POLLIN | POLLOUT)) { -#ifndef WIN32 +#ifndef _WIN32 if (fds[x].fd > maxfd) { maxfd= fds[x].fd; @@ -82,4 +82,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo) return ret; } -#endif // defined(WIN32) || defined(__MINGW32__) +#endif // defined(_WIN32) diff --git a/libmemcached/poll.h b/libmemcached/poll.h index 8445f009..46636c40 100644 --- a/libmemcached/poll.h +++ b/libmemcached/poll.h @@ -12,7 +12,7 @@ #pragma once -#if defined(WIN32) || defined(__MINGW32__) +#if defined(_WIN32) #include @@ -22,7 +22,7 @@ extern "C" { typedef struct pollfd { -#ifdef WIN32 +#if defined(_WIN32) SOCKET fd; #else int fd; @@ -45,4 +45,4 @@ int poll(struct pollfd fds[], nfds_t nfds, int tmo); } #endif -#endif // defined(WIN32) || defined(__MINGW32__) +#endif // defined(_WIN32) -- cgit v1.2.1 From d45f11704fb49ecf50bed77d681cccf171d1befd Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Mon, 4 Feb 2013 02:38:04 -0500 Subject: Adding missing windows file. --- libmemcached/include.am | 1 + libmemcached/windows.hpp | 125 +++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 126 insertions(+) create mode 100644 libmemcached/windows.hpp (limited to 'libmemcached') diff --git a/libmemcached/include.am b/libmemcached/include.am index 9eb1942c..0aabc248 100644 --- a/libmemcached/include.am +++ b/libmemcached/include.am @@ -50,6 +50,7 @@ noinst_HEADERS+= libmemcached/udp.hpp noinst_HEADERS+= libmemcached/version.hpp noinst_HEADERS+= libmemcached/virtual_bucket.h noinst_HEADERS+= libmemcached/watchpoint.h +noinst_HEADERS+= libmemcached/windows.hpp lib_LTLIBRARIES+= libmemcached/libmemcached.la EXTRA_libmemcached_libmemcached_la_DEPENDENCIES= diff --git a/libmemcached/windows.hpp b/libmemcached/windows.hpp new file mode 100644 index 00000000..40564b1d --- /dev/null +++ b/libmemcached/windows.hpp @@ -0,0 +1,125 @@ +/* + * Libmemcached library + * + * Copyright (C) 2012 Data Differential, http://datadifferential.com/ + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * * The names of its contributors may not be used to endorse or + * promote products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ + +#pragma once + +#ifdef __cplusplus +# include +#else +# include +#endif + +#ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +#endif + +#ifndef _WIN32_WINNT +# define _WIN32_WINNT 0x0501 +#endif + +#ifdef __MINGW32__ +# if(_WIN32_WINNT >= 0x0501) +# else +# undef _WIN32_WINNT +# define _WIN32_WINNT 0x0501 +# endif /* _WIN32_WINNT >= 0x0501 */ +#endif /* __MINGW32__ */ + +#if defined(HAVE_WINSOCK2_H) && HAVE_WINSOCK2_H +# include +#endif + +#if defined(HAVE_WS2TCPIP_H) && HAVE_WS2TCPIP_H +# include +#endif + +#if defined(HAVE_IO_H) && HAVE_IO_H +# include +#endif + +struct sockaddr_un +{ + short int sun_family; + char sun_path[108]; +}; + +static inline int translate_windows_error() +{ + int local_errno= WSAGetLastError(); + + switch(local_errno) { + case WSAEINVAL: + local_errno= EINPROGRESS; + break; + case WSAEALREADY: + case WSAEWOULDBLOCK: + local_errno= EAGAIN; + break; + + case WSAECONNREFUSED: + local_errno= ECONNREFUSED; + break; + + case WSAENETUNREACH: + local_errno= ENETUNREACH; + break; + + case WSAETIMEDOUT: + local_errno= ETIMEDOUT; + break; + + case WSAECONNRESET: + local_errno= ECONNRESET; + break; + + case WSAEADDRINUSE: + local_errno= EADDRINUSE; + break; + + case WSAEOPNOTSUPP: + local_errno= EOPNOTSUPP; + break; + + case WSAENOPROTOOPT: + local_errno= ENOPROTOOPT; + break; + + default: + break; + } + + return local_errno; +} -- cgit v1.2.1 From b0e10bd4ddc74e7018d2370283f3ae6316228cc7 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Mon, 11 Feb 2013 03:00:39 -0800 Subject: Increment bison required version. --- libmemcached/csl/parser.yy | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libmemcached') diff --git a/libmemcached/csl/parser.yy b/libmemcached/csl/parser.yy index 6d4ccd55..3ee3940f 100644 --- a/libmemcached/csl/parser.yy +++ b/libmemcached/csl/parser.yy @@ -53,7 +53,7 @@ class Context; %parse-param { class Context *context } %parse-param { yyscan_t *scanner } %pure-parser -%require "2.4" +%require "2.5" %start begin %verbose -- cgit v1.2.1 From a782b52ac1e87fa8e3757c6a5263bf7d01a1160c Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Mon, 11 Feb 2013 04:22:44 -0800 Subject: Fix APPLE identifier. --- libmemcached/do.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'libmemcached') diff --git a/libmemcached/do.cc b/libmemcached/do.cc index c9d8e7e5..73ef06d3 100644 --- a/libmemcached/do.cc +++ b/libmemcached/do.cc @@ -30,7 +30,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance, vector[0].length= UDP_DATAGRAM_HEADER_LENGTH; msg.msg_iov= (struct iovec*)vector; -#if defined(TARGET_OS_OSX) && TARGET_OS_OSX +#ifdef __APPLE__ msg.msg_iovlen= int(count); #else msg.msg_iovlen= count; -- cgit v1.2.1 From 599f5fe51b935465234e8085e549915d9b131fd1 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Tue, 12 Feb 2013 00:44:21 -0500 Subject: Update for new warnings. --- libmemcached/csl/parser.yy | 9 +++++---- libmemcached/response.cc | 2 +- 2 files changed, 6 insertions(+), 5 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/csl/parser.yy b/libmemcached/csl/parser.yy index 3ee3940f..dd9c720b 100644 --- a/libmemcached/csl/parser.yy +++ b/libmemcached/csl/parser.yy @@ -66,13 +66,14 @@ class Context; #include #ifndef __INTEL_COMPILER -#pragma GCC diagnostic ignored "-Wold-style-cast" +# pragma GCC diagnostic ignored "-Wold-style-cast" #endif #ifndef __INTEL_COMPILER -#ifndef __clang__ -#pragma GCC diagnostic ignored "-Wlogical-op" -#endif +# ifndef __clang__ +# pragma GCC diagnostic ignored "-Wlogical-op" +# pragma GCC diagnostic ignored "-Wunsafe-loop-optimizations" +# endif #endif int conf_lex(YYSTYPE* lvalp, void* scanner); diff --git a/libmemcached/response.cc b/libmemcached/response.cc index 96772ff3..85d675bb 100644 --- a/libmemcached/response.cc +++ b/libmemcached/response.cc @@ -663,7 +663,7 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* char touch_buffer[32]; // @todo document this number rc= memcached_safe_read(instance, buffer, sizeof(touch_buffer)); } - return MEMCACHED_SUCCESS; + return memcached_set_error(*instance, rc, MEMCACHED_AT); } case PROTOCOL_BINARY_CMD_NOOP: -- cgit v1.2.1 From 1fa5c40c04223a71dd3e617fc134d75a98da4ece Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Tue, 12 Feb 2013 04:18:24 -0500 Subject: Fix for bug in server for touch --- libmemcached/connect.cc | 27 ++++----------------------- libmemcached/io.cc | 4 ++-- libmemcached/response.cc | 28 +++++++++++++++++++++------- 3 files changed, 27 insertions(+), 32 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 22e259f4..2e2dbf61 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -87,7 +87,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons int local_errno= get_socket_errno(); // We cache in case closesocket() modifies errno switch (local_errno) { -#ifdef TARGET_OS_LINUX +#ifdef __linux__ case ERESTART: #endif case EINTR: @@ -103,22 +103,6 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons default: // This should not happen break; -#if 0 - if (fds[0].revents & POLLERR) - { - int err; - socklen_t len= sizeof(err); - if (getsockopt(server->fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) == 0) - { - if (err == 0) - { - // This should never happen, if it does? Punt. - continue; - } - local_errno= err; - } - } -#endif } assert_msg(server->fd != INVALID_SOCKET, "poll() was passed an invalid file descriptor"); @@ -146,13 +130,9 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons } } - return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("(number_of == 0)")); } -#if 0 - server->revents(fds[0].revents); -#endif - assert (number_of == 1); if (fds[0].revents & POLLERR or @@ -663,7 +643,8 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server) if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS) { - return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*server, MEMCACHED_TIMEOUT, MEMCACHED_AT, + memcached_literal_param("if (timeout_error_occured and server->state < MEMCACHED_SERVER_STATE_IN_PROGRESS)")); } return memcached_set_error(*server, MEMCACHED_CONNECTION_FAILURE, MEMCACHED_AT); /* The last error should be from connect() */ diff --git a/libmemcached/io.cc b/libmemcached/io.cc index f6cc3696..d9a13a71 100644 --- a/libmemcached/io.cc +++ b/libmemcached/io.cc @@ -212,7 +212,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance, if (instance->root->poll_timeout == 0) // Mimic 0 causes timeout behavior (not all platforms do this) { - return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("poll_timeout() was set to zero")); } size_t loop_max= 5; @@ -257,7 +257,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance, if (active_fd == 0) { - return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT); + return memcached_set_error(*instance, MEMCACHED_TIMEOUT, MEMCACHED_AT, memcached_literal_param("No active_fd were found")); } // Only an error should result in this code being called. diff --git a/libmemcached/response.cc b/libmemcached/response.cc index 85d675bb..391c9309 100644 --- a/libmemcached/response.cc +++ b/libmemcached/response.cc @@ -648,6 +648,25 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* } break; + case PROTOCOL_BINARY_CMD_TOUCH: + { + rc= MEMCACHED_SUCCESS; + if (bodylen == 4) // The four byte read is a bug? + { + char touch_buffer[4]; // @todo document this number + rc= memcached_safe_read(instance, touch_buffer, sizeof(touch_buffer)); +#if 0 + fprintf(stderr, "%s:%d %d %d %d %d %.*s(%d)\n", __FILE__, __LINE__, + int(touch_buffer[0]), + int(touch_buffer[1]), + int(touch_buffer[2]), + int(touch_buffer[3]), + int(bodylen), touch_buffer, int(bodylen)); +#endif + } + return memcached_set_error(*instance, rc, MEMCACHED_AT); + } + case PROTOCOL_BINARY_CMD_FLUSH: case PROTOCOL_BINARY_CMD_QUIT: case PROTOCOL_BINARY_CMD_SET: @@ -656,14 +675,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* case PROTOCOL_BINARY_CMD_APPEND: case PROTOCOL_BINARY_CMD_PREPEND: case PROTOCOL_BINARY_CMD_DELETE: - case PROTOCOL_BINARY_CMD_TOUCH: { - if (bodylen != 0) - { - char touch_buffer[32]; // @todo document this number - rc= memcached_safe_read(instance, buffer, sizeof(touch_buffer)); - } - return memcached_set_error(*instance, rc, MEMCACHED_AT); + WATCHPOINT_ASSERT(bodylen == 0); + return MEMCACHED_SUCCESS; } case PROTOCOL_BINARY_CMD_NOOP: -- cgit v1.2.1 From 5adf96bdb66a81becd1623bb453f8169bda67ced Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Fri, 15 Feb 2013 15:54:39 -0500 Subject: Fix for failure/reset issue in failed IO get call. --- libmemcached/get.cc | 33 ++++++++++++++------------------- 1 file changed, 14 insertions(+), 19 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/get.cc b/libmemcached/get.cc index 1de5f76f..387565c5 100644 --- a/libmemcached/get.cc +++ b/libmemcached/get.cc @@ -2,7 +2,7 @@ * * Libmemcached library * - * Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * Copyright (C) 2006-2009 Brian Aker All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -502,17 +502,17 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, request.message.header.request.opcode= PROTOCOL_BINARY_CMD_GETK; } - memcached_return_t vk; - vk= memcached_validate_key_length(key_length[x], - ptr->flags.binary_protocol); - if (vk != MEMCACHED_SUCCESS) { - if (x > 0) + memcached_return_t vk= memcached_validate_key_length(key_length[x], ptr->flags.binary_protocol); + if (vk != MEMCACHED_SUCCESS) { - memcached_io_reset(instance); - } + if (x > 0) + { + memcached_io_reset(instance); + } - return vk; + return vk; + } } request.message.header.request.keylen= htons((uint16_t)(key_length[x] + memcached_array_size(ptr->_namespace))); @@ -558,15 +558,8 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, if (instance->response_count()) { - if (memcached_io_write(instance) == false) - { - memcached_instance_response_reset(instance); - memcached_io_reset(instance); - rc= MEMCACHED_SOME_ERRORS; - } - - if (memcached_io_write(instance, request.bytes, - sizeof(request.bytes), true) == -1) + if ((memcached_io_write(instance) == false) or + (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1)) { memcached_instance_response_reset(instance); memcached_io_reset(instance); @@ -604,9 +597,11 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < number_of_keys; ++x) { if (hash[x] == memcached_server_count(ptr)) + { continue; /* Already successfully sent */ + } - uint32_t server= hash[x] + replica; + uint32_t server= hash[x] +replica; /* In case of randomized reads */ if (randomize_read and ((server + start) <= (hash[x] + ptr->number_of_replicas))) -- cgit v1.2.1 From 3b1b3be9df0318eb52a07cf38ca4eb97eb943e04 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Tue, 19 Feb 2013 03:10:57 -0500 Subject: Fix case where we initialize a packet we will never actually use. --- libmemcached/get.cc | 61 ++++++++++++++++++++++++++--------------------------- libmemcached/io.cc | 2 +- 2 files changed, 31 insertions(+), 32 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/get.cc b/libmemcached/get.cc index 387565c5..0f151e8d 100644 --- a/libmemcached/get.cc +++ b/libmemcached/get.cc @@ -50,13 +50,13 @@ char *memcached_get(memcached_st *ptr, const char *key, flags, error); } -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode); +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + size_t group_key_length, + const char * const *keys, + const size_t *key_length, + size_t number_of_keys, + const bool mget_mode); char *memcached_get_by_key(memcached_st *shell, const char *group_key, size_t group_key_length, @@ -79,9 +79,9 @@ char *memcached_get_by_key(memcached_st *shell, } /* Request the key */ - *error= memcached_mget_by_key_real(ptr, group_key, group_key_length, - (const char * const *)&key, &key_length, - 1, false); + *error= __mget_by_key_real(ptr, group_key, group_key_length, + (const char * const *)&key, &key_length, + 1, false); if (ptr) { assert_msg(ptr->query_id == query_id +1, "Programmer error, the query_id was not incremented."); @@ -186,20 +186,20 @@ memcached_return_t memcached_mget(memcached_st *ptr, } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, - bool is_group_key_set, + const uint32_t master_server_key, + const bool is_group_key_set, + const char * const *keys, + const size_t *key_length, + const size_t number_of_keys, + const bool mget_mode); + +static memcached_return_t __mget_by_key_real(memcached_st *ptr, + const char *group_key, + const size_t group_key_length, const char * const *keys, const size_t *key_length, size_t number_of_keys, - bool mget_mode); - -static memcached_return_t memcached_mget_by_key_real(memcached_st *ptr, - const char *group_key, - size_t group_key_length, - const char * const *keys, - const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const bool mget_mode) { bool failures_occured_in_sending= false; const char *get_command= "get"; @@ -393,8 +393,7 @@ memcached_return_t memcached_mget_by_key(memcached_st *shell, size_t number_of_keys) { Memcached* ptr= memcached2Memcached(shell); - return memcached_mget_by_key_real(ptr, group_key, group_key_length, keys, - key_length, number_of_keys, true); + return __mget_by_key_real(ptr, group_key, group_key_length, keys, key_length, number_of_keys, true); } memcached_return_t memcached_mget_execute(memcached_st *ptr, @@ -449,15 +448,16 @@ memcached_return_t memcached_mget_execute_by_key(memcached_st *shell, rc= memcached_mget_by_key(ptr, group_key, group_key_length, keys, key_length, number_of_keys); ptr->callbacks= original_callbacks; + return rc; } static memcached_return_t simple_binary_mget(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, bool mget_mode) + const size_t number_of_keys, const bool mget_mode) { memcached_return_t rc= MEMCACHED_NOTFOUND; @@ -554,10 +554,10 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < memcached_server_count(ptr); ++x) { org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); - initialize_binary_request(instance, request.message.header); if (instance->response_count()) { + initialize_binary_request(instance, request.message.header); if ((memcached_io_write(instance) == false) or (memcached_io_write(instance, request.bytes, sizeof(request.bytes), true) == -1)) { @@ -569,7 +569,6 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, } } - return rc; } @@ -578,7 +577,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, bool* dead_servers, const char *const *keys, const size_t *key_length, - size_t number_of_keys) + const size_t number_of_keys) { memcached_return_t rc= MEMCACHED_NOTFOUND; uint32_t start= 0; @@ -680,12 +679,12 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, } static memcached_return_t binary_mget_by_key(memcached_st *ptr, - uint32_t master_server_key, + const uint32_t master_server_key, bool is_group_key_set, const char * const *keys, const size_t *key_length, - size_t number_of_keys, - bool mget_mode) + const size_t number_of_keys, + const bool mget_mode) { if (ptr->number_of_replicas == 0) { diff --git a/libmemcached/io.cc b/libmemcached/io.cc index d9a13a71..1cd03769 100644 --- a/libmemcached/io.cc +++ b/libmemcached/io.cc @@ -40,7 +40,7 @@ #include #ifdef HAVE_SYS_SOCKET_H -# include +# include #endif void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header& header) -- cgit v1.2.1 From 9763b8e9b681d1d6713b95e4d7ce6ffeafeafca5 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Sat, 23 Feb 2013 05:17:33 -0500 Subject: Fix for lp:1123153 (poor use of strtol). --- libmemcached/parse.cc | 16 ++++- libmemcached/response.cc | 34 ++++++++--- libmemcached/stats.cc | 153 +++++++++++++++++++++++++++++++++++++++++------ 3 files changed, 176 insertions(+), 27 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/parse.cc b/libmemcached/parse.cc index 3284a4f6..7665b731 100644 --- a/libmemcached/parse.cc +++ b/libmemcached/parse.cc @@ -87,7 +87,13 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings) ptr++; + errno= 0; port= (in_port_t) strtoul(ptr, (char **)NULL, 10); + if (errno != 0) + { + memcached_server_free(servers); + return NULL; + } ptr2= index(ptr, ' '); if (! ptr2) @@ -96,14 +102,22 @@ memcached_server_list_st memcached_servers_parse(const char *server_strings) if (ptr2) { ptr2++; - weight = (uint32_t) strtoul(ptr2, (char **)NULL, 10); + errno= 0; + weight= uint32_t(strtoul(ptr2, (char **)NULL, 10)); + if (errno != 0) + { + memcached_server_free(servers); + return NULL; + } } } servers= memcached_server_list_append_with_weight(servers, buffer, port, weight, &rc); if (isspace(*begin_ptr)) + { begin_ptr++; + } } return servers; diff --git a/libmemcached/response.cc b/libmemcached/response.cc index 391c9309..7503c5a0 100644 --- a/libmemcached/response.cc +++ b/libmemcached/response.cc @@ -90,9 +90,10 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta } for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {}; + errno= 0; result->item_flags= (uint32_t) strtoul(next_ptr, &string_ptr, 10); - if (end_ptr == string_ptr) + if (errno != 0 or end_ptr == string_ptr) { goto read_error; } @@ -105,9 +106,10 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta } for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {}; + errno= 0; value_length= (size_t)strtoull(next_ptr, &string_ptr, 10); - if (end_ptr == string_ptr) + if (errno != 0 or end_ptr == string_ptr) { goto read_error; } @@ -122,10 +124,11 @@ static memcached_return_t textual_value_fetch(org::libmemcached::Instance* insta { string_ptr++; for (next_ptr= string_ptr; isdigit(*string_ptr); string_ptr++) {}; + errno= 0; result->item_cas= strtoull(next_ptr, &string_ptr, 10); } - if (end_ptr < string_ptr) + if (errno != 0 or end_ptr < string_ptr) { goto read_error; } @@ -238,8 +241,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* char *response_ptr= index(buffer, ' '); char *endptr; + errno= 0; long int version= strtol(response_ptr, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version")); @@ -247,8 +251,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance->major_version= uint8_t(version); endptr++; + errno= 0; version= strtol(endptr, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version")); @@ -256,8 +261,9 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance->minor_version= uint8_t(version); endptr++; + errno= 0; version= strtol(endptr, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version")); @@ -442,6 +448,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* case '8': /* INCR/DECR response */ case '9': /* INCR/DECR response */ { + errno= 0; unsigned long long int auto_return_value= strtoull(buffer, (char **)NULL, 10); if (auto_return_value == ULLONG_MAX and errno == ERANGE) @@ -456,6 +463,12 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("Numeric response was out of range")); } + else if (errno != 0) + { + result->numeric_value= UINT64_MAX; + return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, + memcached_literal_param("Numeric response was out of range")); + } result->numeric_value= uint64_t(auto_return_value); @@ -620,8 +633,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* } char *endptr; + errno= 0; long int version= strtol(version_buffer, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX or version == 0) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX or version == 0) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse major version")); @@ -629,8 +643,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance->major_version= uint8_t(version); endptr++; + errno= 0; version= strtol(endptr, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse minor version")); @@ -638,8 +653,9 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance->minor_version= uint8_t(version); endptr++; + errno= 0; version= strtol(endptr, &endptr, 10); - if (version == LONG_MIN or version == LONG_MAX or errno == EINVAL or version > UINT8_MAX) + if (errno != 0 or version == LONG_MIN or version == LONG_MAX or version > UINT8_MAX) { instance->major_version= instance->minor_version= instance->micro_version= UINT8_MAX; return memcached_set_error(*instance, MEMCACHED_UNKNOWN_READ_FAILURE, MEMCACHED_AT, memcached_literal_param("strtol() failed to parse micro version")); diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc index 89d5be52..01a8baf6 100644 --- a/libmemcached/stats.cc +++ b/libmemcached/stats.cc @@ -2,7 +2,7 @@ * * Libmemcached library * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are @@ -91,7 +91,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key } else if (strcmp("pid", key) == 0) { + errno= 0; int64_t temp= strtoll(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } if (temp <= INT32_MAX and ( sizeof(pid_t) == sizeof(int32_t) )) { @@ -109,11 +114,21 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key } else if (not strcmp("uptime", key)) { + errno= 0; memc_stat->uptime= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("time", key)) { + errno= 0; memc_stat->time= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("version", key)) { @@ -122,7 +137,12 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key } else if (not strcmp("pointer_size", key)) { + errno= 0; memc_stat->pointer_size= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("rusage_user", key)) { @@ -130,8 +150,20 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {}; *walk_ptr= 0; walk_ptr++; + + errno= 0; memc_stat->rusage_user_seconds= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } + + errno= 0; memc_stat->rusage_user_microseconds= strtoul(walk_ptr, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("rusage_system", key)) { @@ -139,85 +171,172 @@ static memcached_return_t set_data(memcached_stat_st *memc_stat, const char *key for (walk_ptr= (char*)value; (!ispunct(*walk_ptr)); walk_ptr++) {}; *walk_ptr= 0; walk_ptr++; + + errno= 0; memc_stat->rusage_system_seconds= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } + + errno= 0; memc_stat->rusage_system_microseconds= strtoul(walk_ptr, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("curr_items", key)) { + errno= 0; memc_stat->curr_items= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("total_items", key)) { + errno= 0; memc_stat->total_items= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("bytes_read", key)) { + errno= 0; memc_stat->bytes_read= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("bytes_written", key)) { + errno= 0; memc_stat->bytes_written= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("bytes", key)) { + errno= 0; memc_stat->bytes= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("curr_connections", key)) { + errno= 0; memc_stat->curr_connections= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("total_connections", key)) { + errno= 0; memc_stat->total_connections= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("connection_structures", key)) { + errno= 0; memc_stat->connection_structures= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("cmd_get", key)) { + errno= 0; memc_stat->cmd_get= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("cmd_set", key)) { + errno= 0; memc_stat->cmd_set= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("get_hits", key)) { + errno= 0; memc_stat->get_hits= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("get_misses", key)) { + errno= 0; memc_stat->get_misses= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("evictions", key)) { + errno= 0; memc_stat->evictions= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("limit_maxbytes", key)) { + errno= 0; memc_stat->limit_maxbytes= strtoull(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } else if (not strcmp("threads", key)) { + errno= 0; memc_stat->threads= strtoul(value, (char **)NULL, 10); + if (errno != 0) + { + return MEMCACHED_FAILURE; + } } - else if (not (strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */ - strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */ - strcmp("incr_misses", key) == 0 or - strcmp("incr_hits", key) == 0 or - strcmp("decr_misses", key) == 0 or - strcmp("decr_hits", key) == 0 or - strcmp("cas_misses", key) == 0 or - strcmp("cas_hits", key) == 0 or - strcmp("cas_badval", key) == 0 or - strcmp("cmd_flush", key) == 0 or - strcmp("accepting_conns", key) == 0 or - strcmp("listen_disabled_num", key) == 0 or - strcmp("conn_yields", key) == 0 or - strcmp("auth_cmds", key) == 0 or - strcmp("auth_errors", key) == 0 or - strcmp("reclaimed", key) == 0)) + else if ((strcmp("delete_misses", key) == 0 or /* New stats in the 1.3 beta */ + strcmp("delete_hits", key) == 0 or /* Just swallow them for now.. */ + strcmp("incr_misses", key) == 0 or + strcmp("incr_hits", key) == 0 or + strcmp("decr_misses", key) == 0 or + strcmp("decr_hits", key) == 0 or + strcmp("cas_misses", key) == 0 or + strcmp("cas_hits", key) == 0 or + strcmp("cas_badval", key) == 0 or + strcmp("cmd_flush", key) == 0 or + strcmp("accepting_conns", key) == 0 or + strcmp("listen_disabled_num", key) == 0 or + strcmp("conn_yields", key) == 0 or + strcmp("auth_cmds", key) == 0 or + strcmp("auth_errors", key) == 0 or + strcmp("reclaimed", key) == 0) == 0) { WATCHPOINT_STRING(key); /* return MEMCACHED_UNKNOWN_STAT_KEY; */ -- cgit v1.2.1 From d9db3f534bc38ea22e83e5529ff93aea4150ab19 Mon Sep 17 00:00:00 2001 From: Brian Aker Date: Sun, 31 Mar 2013 16:24:29 -0700 Subject: Remove exposed C++ namespace. --- libmemcached/auto.cc | 10 +++---- libmemcached/behavior.cc | 4 +-- libmemcached/common.h | 8 ++--- libmemcached/connect.cc | 18 ++++++------ libmemcached/connect.hpp | 2 +- libmemcached/delete.cc | 8 ++--- libmemcached/do.cc | 4 +-- libmemcached/do.hpp | 4 +-- libmemcached/dump.cc | 4 +-- libmemcached/error.cc | 34 +++++++++++----------- libmemcached/error.hpp | 20 ++++++------- libmemcached/exist.cc | 6 ++-- libmemcached/fetch.cc | 2 +- libmemcached/flush.cc | 6 ++-- libmemcached/flush_buffers.cc | 2 +- libmemcached/get.cc | 12 ++++---- libmemcached/hosts.cc | 22 +++++++------- libmemcached/instance.cc | 66 +++++++++++++++++++----------------------- libmemcached/instance.hpp | 24 ++++++--------- libmemcached/io.cc | 46 ++++++++++++++--------------- libmemcached/io.hpp | 22 +++++++------- libmemcached/memcached.cc | 16 +++++----- libmemcached/purge.cc | 2 +- libmemcached/quit.cc | 8 ++--- libmemcached/quit.hpp | 2 +- libmemcached/response.cc | 14 ++++----- libmemcached/response.h | 6 ++-- libmemcached/sasl.cc | 4 +-- libmemcached/sasl.hpp | 2 +- libmemcached/server.cc | 14 ++++----- libmemcached/server.hpp | 6 ++-- libmemcached/server_instance.h | 3 +- libmemcached/server_list.cc | 4 +-- libmemcached/server_list.hpp | 6 ++-- libmemcached/stats.cc | 10 +++---- libmemcached/storage.cc | 8 ++--- libmemcached/touch.cc | 6 ++-- libmemcached/udp.cc | 4 +-- libmemcached/udp.hpp | 4 +-- libmemcached/verbosity.cc | 4 +-- libmemcached/version.cc | 14 ++++----- libmemcached/version.hpp | 2 +- 42 files changed, 225 insertions(+), 238 deletions(-) (limited to 'libmemcached') diff --git a/libmemcached/auto.cc b/libmemcached/auto.cc index 85e2ae09..685528f2 100644 --- a/libmemcached/auto.cc +++ b/libmemcached/auto.cc @@ -37,7 +37,7 @@ #include -static void auto_response(org::libmemcached::Instance* instance, const bool reply, memcached_return_t& rc, uint64_t* value) +static void auto_response(memcached_instance_st* instance, const bool reply, memcached_return_t& rc, uint64_t* value) { // If the message was successfully sent, then get the response, otherwise // fail. @@ -63,7 +63,7 @@ static void auto_response(org::libmemcached::Instance* instance, const bool repl } } -static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance, +static memcached_return_t text_incr_decr(memcached_instance_st* instance, const bool is_incr, const char *key, size_t key_length, const uint64_t offset, @@ -97,7 +97,7 @@ static memcached_return_t text_incr_decr(org::libmemcached::Instance* instance, return memcached_vdo(instance, vector, 7, true); } -static memcached_return_t binary_incr_decr(org::libmemcached::Instance* instance, +static memcached_return_t binary_incr_decr(memcached_instance_st* instance, protocol_binary_command cmd, const char *key, const size_t key_length, const uint64_t offset, @@ -180,7 +180,7 @@ static memcached_return_t increment_decrement_by_key(const protocol_binary_comma } uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + memcached_instance_st* instance= memcached_instance_fetch(memc, server_key); bool reply= memcached_is_replying(instance->root); @@ -239,7 +239,7 @@ static memcached_return_t increment_decrement_with_initial_by_key(const protocol } uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + memcached_instance_st* instance= memcached_instance_fetch(memc, server_key); bool reply= memcached_is_replying(instance->root); diff --git a/libmemcached/behavior.cc b/libmemcached/behavior.cc index 7a8b9853..2675e236 100644 --- a/libmemcached/behavior.cc +++ b/libmemcached/behavior.cc @@ -413,7 +413,7 @@ uint64_t memcached_behavior_get(memcached_st *shell, return (uint64_t) ptr->send_size; } - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0); + memcached_instance_st* instance= memcached_instance_fetch(ptr, 0); if (instance) // If we have an instance we test, otherwise we just set and pray { @@ -447,7 +447,7 @@ uint64_t memcached_behavior_get(memcached_st *shell, if (ptr->recv_size != -1) // If value is -1 then we are using the default return (uint64_t) ptr->recv_size; - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, 0); + memcached_instance_st* instance= memcached_instance_fetch(ptr, 0); /** @note REFACTOR diff --git a/libmemcached/common.h b/libmemcached/common.h index 71db19b0..897b0969 100644 --- a/libmemcached/common.h +++ b/libmemcached/common.h @@ -123,7 +123,7 @@ typedef struct memcached_st Memcached; #endif #ifdef __cplusplus -org::libmemcached::Instance* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key); +memcached_instance_st* memcached_instance_fetch(memcached_st *ptr, uint32_t server_key); #endif /* These are private not to be installed headers */ @@ -198,7 +198,7 @@ extern "C" { memcached_return_t run_distribution(memcached_st *ptr); #ifdef __cplusplus -static inline void memcached_server_response_increment(org::libmemcached::Instance* instance) +static inline void memcached_server_response_increment(memcached_instance_st* instance) { instance->events(POLLIN); instance->cursor_active_++; @@ -217,6 +217,6 @@ static inline void memcached_server_response_increment(org::libmemcached::Instan #endif #ifdef __cplusplus -bool memcached_purge(org::libmemcached::Instance*); -org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key); +bool memcached_purge(memcached_instance_st*); +memcached_instance_st* memcached_instance_by_position(const memcached_st *ptr, uint32_t server_key); #endif diff --git a/libmemcached/connect.cc b/libmemcached/connect.cc index 2e2dbf61..cb88c13b 100644 --- a/libmemcached/connect.cc +++ b/libmemcached/connect.cc @@ -64,7 +64,7 @@ # define TCP_KEEPIDLE 0 #endif -static memcached_return_t connect_poll(org::libmemcached::Instance* server, const int connection_error) +static memcached_return_t connect_poll(memcached_instance_st* server, const int connection_error) { struct pollfd fds[1]; fds[0].fd= server->fd; @@ -181,7 +181,7 @@ static memcached_return_t connect_poll(org::libmemcached::Instance* server, cons return memcached_set_errno(*server, connection_error, MEMCACHED_AT, memcached_literal_param("connect_poll() was exhausted")); } -static memcached_return_t set_hostinfo(org::libmemcached::Instance* server) +static memcached_return_t set_hostinfo(memcached_instance_st* server) { assert(server->type != MEMCACHED_CONNECTION_UNIX_SOCKET); server->clear_addrinfo(); @@ -245,7 +245,7 @@ static memcached_return_t set_hostinfo(org::libmemcached::Instance* server) return MEMCACHED_SUCCESS; } -static inline void set_socket_nonblocking(org::libmemcached::Instance* server) +static inline void set_socket_nonblocking(memcached_instance_st* server) { #if defined(_WIN32) u_long arg= 1; @@ -285,7 +285,7 @@ static inline void set_socket_nonblocking(org::libmemcached::Instance* server) #endif } -static bool set_socket_options(org::libmemcached::Instance* server) +static bool set_socket_options(memcached_instance_st* server) { assert_msg(server->fd != INVALID_SOCKET, "invalid socket was passed to set_socket_options()"); @@ -439,7 +439,7 @@ static bool set_socket_options(org::libmemcached::Instance* server) return true; } -static memcached_return_t unix_socket_connect(org::libmemcached::Instance* server) +static memcached_return_t unix_socket_connect(memcached_instance_st* server) { #ifndef _WIN32 WATCHPOINT_ASSERT(server->fd == INVALID_SOCKET); @@ -505,7 +505,7 @@ static memcached_return_t unix_socket_connect(org::libmemcached::Instance* serve #endif } -static memcached_return_t network_connect(org::libmemcached::Instance* server) +static memcached_return_t network_connect(memcached_instance_st* server) { bool timeout_error_occured= false; @@ -657,7 +657,7 @@ static memcached_return_t network_connect(org::libmemcached::Instance* server) Based on time/failure count fail the connect without trying. This prevents waiting in a state where we get caught spending cycles just waiting. */ -static memcached_return_t backoff_handling(org::libmemcached::Instance* server, bool& in_timeout) +static memcached_return_t backoff_handling(memcached_instance_st* server, bool& in_timeout) { struct timeval curr_time; bool _gettime_success= (gettimeofday(&curr_time, NULL) == 0); @@ -724,7 +724,7 @@ static memcached_return_t backoff_handling(org::libmemcached::Instance* server, return MEMCACHED_SUCCESS; } -static memcached_return_t _memcached_connect(org::libmemcached::Instance* server, const bool set_last_disconnected) +static memcached_return_t _memcached_connect(memcached_instance_st* server, const bool set_last_disconnected) { assert(server); if (server->fd != INVALID_SOCKET) @@ -811,7 +811,7 @@ static memcached_return_t _memcached_connect(org::libmemcached::Instance* server return rc; } -memcached_return_t memcached_connect(org::libmemcached::Instance* server) +memcached_return_t memcached_connect(memcached_instance_st* server) { return _memcached_connect(server, true); } diff --git a/libmemcached/connect.hpp b/libmemcached/connect.hpp index de1c8df5..d1dafe5e 100644 --- a/libmemcached/connect.hpp +++ b/libmemcached/connect.hpp @@ -37,4 +37,4 @@ #pragma once -memcached_return_t memcached_connect(org::libmemcached::Instance*); +memcached_return_t memcached_connect(memcached_instance_st*); diff --git a/libmemcached/delete.cc b/libmemcached/delete.cc index 67957f45..55a8b4ca 100644 --- a/libmemcached/delete.cc +++ b/libmemcached/delete.cc @@ -44,7 +44,7 @@ memcached_return_t memcached_delete(memcached_st *shell, const char *key, size_t return memcached_delete_by_key(shell, key, key_length, key, key_length, expiration); } -static inline memcached_return_t ascii_delete(org::libmemcached::Instance* instance, +static inline memcached_return_t ascii_delete(memcached_instance_st* instance, uint32_t , const char *key, const size_t key_length, @@ -65,7 +65,7 @@ static inline memcached_return_t ascii_delete(org::libmemcached::Instance* insta return memcached_vdo(instance, vector, 6, is_buffering ? false : true); } -static inline memcached_return_t binary_delete(org::libmemcached::Instance* instance, +static inline memcached_return_t binary_delete(memcached_instance_st* instance, uint32_t server_key, const char *key, const size_t key_length, @@ -118,7 +118,7 @@ static inline memcached_return_t binary_delete(org::libmemcached::Instance* inst server_key= 0; } - org::libmemcached::Instance* replica= memcached_instance_fetch(instance->root, server_key); + memcached_instance_st* replica= memcached_instance_fetch(instance->root, server_key); if (memcached_fatal(memcached_vdo(replica, vector, 4, should_flush))) { @@ -161,7 +161,7 @@ memcached_return_t memcached_delete_by_key(memcached_st *shell, } uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + memcached_instance_st* instance= memcached_instance_fetch(memc, server_key); bool is_buffering= memcached_is_buffering(instance->root); bool is_replying= memcached_is_replying(instance->root); diff --git a/libmemcached/do.cc b/libmemcached/do.cc index 73ef06d3..9ba513f2 100644 --- a/libmemcached/do.cc +++ b/libmemcached/do.cc @@ -11,7 +11,7 @@ #include -static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance, +static memcached_return_t _vdo_udp(memcached_instance_st* instance, libmemcached_io_vector_st vector[], const size_t count) { @@ -64,7 +64,7 @@ static memcached_return_t _vdo_udp(org::libmemcached::Instance* instance, #endif } -memcached_return_t memcached_vdo(org::libmemcached::Instance* instance, +memcached_return_t memcached_vdo(memcached_instance_st* instance, libmemcached_io_vector_st vector[], const size_t count, const bool with_flush) diff --git a/libmemcached/do.hpp b/libmemcached/do.hpp index 109c0ac1..d2dc6671 100644 --- a/libmemcached/do.hpp +++ b/libmemcached/do.hpp @@ -2,7 +2,7 @@ * * Libmemcached library * - * Copyright (C) 2011 Data Differential, http://datadifferential.com/ + * Copyright (C) 2011-2013 Data Differential, http://datadifferential.com/ * Copyright (C) 2006-2009 Brian Aker All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -37,7 +37,7 @@ #pragma once -memcached_return_t memcached_vdo(org::libmemcached::Instance* ptr, +memcached_return_t memcached_vdo(memcached_instance_st*, libmemcached_io_vector_st vector[], const size_t count, const bool with_flush); diff --git a/libmemcached/dump.cc b/libmemcached/dump.cc index 35da13f5..8ddb2eef 100644 --- a/libmemcached/dump.cc +++ b/libmemcached/dump.cc @@ -68,7 +68,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac // Send message to all servers for (uint32_t server_key= 0; server_key < memcached_server_count(memc); server_key++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + memcached_instance_st* instance= memcached_instance_fetch(memc, server_key); memcached_return_t vdo_rc; if (memcached_success((vdo_rc= memcached_vdo(instance, vector, 3, true)))) @@ -82,7 +82,7 @@ static memcached_return_t ascii_dump(Memcached *memc, memcached_dump_fn *callbac } // Collect the returned items - org::libmemcached::Instance* instance; + memcached_instance_st* instance; memcached_return_t read_ret= MEMCACHED_SUCCESS; while ((instance= memcached_io_get_readable_server(memc, read_ret))) { diff --git a/libmemcached/error.cc b/libmemcached/error.cc index 64aefa03..266f78b5 100644 --- a/libmemcached/error.cc +++ b/libmemcached/error.cc @@ -52,7 +52,7 @@ struct memcached_error_t char message[MAX_ERROR_LENGTH]; }; -static void _set(org::libmemcached::Instance& server, Memcached& memc) +static void _set(memcached_instance_st& server, Memcached& memc) { if (server.error_messages and server.error_messages->query_id != server.root->query_id) { @@ -215,7 +215,7 @@ memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, c return memcached_set_error(memc, rc, at, tmp); } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, const char *str, size_t length) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a Instance"); @@ -255,7 +255,7 @@ memcached_return_t memcached_set_parser_error(Memcached& memc, return memcached_set_error(memc, MEMCACHED_PARSE_ERROR, at, buffer, length); } -static inline size_t append_host_to_string(org::libmemcached::Instance& self, char* buffer, const size_t buffer_length) +static inline size_t append_host_to_string(memcached_instance_st& self, char* buffer, const size_t buffer_length) { size_t size= 0; switch (self.type) @@ -275,10 +275,10 @@ static inline size_t append_host_to_string(org::libmemcached::Instance& self, ch return size; } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at, memcached_string_t& str) { assert_msg(rc != MEMCACHED_ERRNO, "Programmer error, MEMCACHED_ERRNO was set to be returned to client"); - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st"); if (memcached_fatal(rc) == false and rc != MEMCACHED_CLIENT_ERROR) { return rc; @@ -313,9 +313,9 @@ memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcac return rc; } -memcached_return_t memcached_set_error(org::libmemcached::Instance& self, memcached_return_t rc, const char *at) +memcached_return_t memcached_set_error(memcached_instance_st& self, memcached_return_t rc, const char *at) { - assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a org::libmemcached::Instance"); + assert_msg(rc != MEMCACHED_SOME_ERRORS, "Programmer error, MEMCACHED_SOME_ERRORS was about to be set on a memcached_instance_st"); if (memcached_fatal(rc) == false) { return rc; @@ -356,7 +356,7 @@ memcached_return_t memcached_set_errno(Memcached& self, int local_errno, const c return memcached_set_errno(self, local_errno, at, tmp); } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, const char *str, size_t length) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, const char *str, size_t length) { memcached_string_t tmp= { str, length }; return memcached_set_errno(self, local_errno, at, tmp); @@ -388,7 +388,7 @@ memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const c return rc; } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at, memcached_string_t& str) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at, memcached_string_t& str) { if (local_errno == 0) { @@ -427,7 +427,7 @@ memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int lo return rc; } -memcached_return_t memcached_set_errno(org::libmemcached::Instance& self, int local_errno, const char *at) +memcached_return_t memcached_set_errno(memcached_instance_st& self, int local_errno, const char *at) { if (local_errno == 0) { @@ -482,7 +482,7 @@ void memcached_error_print(const Memcached *shell) for (uint32_t x= 0; x < memcached_server_count(self); x++) { - org::libmemcached::Instance* instance= memcached_instance_by_position(self, x); + memcached_instance_st* instance= memcached_instance_by_position(self, x); _error_print(instance->error_messages); } @@ -504,7 +504,7 @@ void memcached_error_free(Memcached& self) self.error_messages= NULL; } -void memcached_error_free(org::libmemcached::Instance& self) +void memcached_error_free(memcached_instance_st& self) { _error_free(self.error_messages); self.error_messages= NULL; @@ -554,7 +554,7 @@ bool memcached_has_current_error(Memcached &memc) return false; } -bool memcached_has_current_error(org::libmemcached::Instance& server) +bool memcached_has_current_error(memcached_instance_st& server) { return memcached_has_current_error(*(server.root)); } @@ -591,7 +591,7 @@ int memcached_last_error_errno(const memcached_st *shell) return memc->error_messages->local_errno; } -const char *memcached_server_error(const memcached_server_instance_st server) +const char *memcached_server_error(const memcached_instance_st * server) { if (server == NULL) { @@ -612,7 +612,7 @@ const char *memcached_server_error(const memcached_server_instance_st server) } -memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& server) +memcached_error_t *memcached_error_copy(const memcached_instance_st& server) { if (server.error_messages == NULL) { @@ -626,7 +626,7 @@ memcached_error_t *memcached_error_copy(const org::libmemcached::Instance& serve return error; } -memcached_return_t memcached_server_error_return(memcached_server_instance_st ptr) +memcached_return_t memcached_server_error_return(const memcached_instance_st * ptr) { if (ptr == NULL) { @@ -641,7 +641,7 @@ memcached_return_t memcached_server_error_return(memcached_server_instance_st pt return MEMCACHED_SUCCESS; } -memcached_return_t memcached_instance_error_return(org::libmemcached::Instance* instance) +memcached_return_t memcached_instance_error_return(memcached_instance_st* instance) { if (instance == NULL) { diff --git a/libmemcached/error.hpp b/libmemcached/error.hpp index 733f7686..847dbc24 100644 --- a/libmemcached/error.hpp +++ b/libmemcached/error.hpp @@ -51,40 +51,40 @@ memcached_return_t memcached_set_parser_error(Memcached& memc, memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at); -memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at); +memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at); memcached_return_t memcached_set_error(Memcached&, memcached_return_t rc, const char *at, const char *str, size_t length); -memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, const char *str, size_t length); +memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, const char *str, size_t length); memcached_return_t memcached_set_error(Memcached& memc, memcached_return_t rc, const char *at, memcached_string_t& str); -memcached_return_t memcached_set_error(org::libmemcached::Instance&, memcached_return_t rc, const char *at, memcached_string_t& str); +memcached_return_t memcached_set_error(memcached_instance_st&, memcached_return_t rc, const char *at, memcached_string_t& str); memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, memcached_string_t& str); -memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, memcached_string_t& str); +memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, memcached_string_t& str); memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at, const char *str, size_t length); -memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at, const char *str, size_t length); +memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at, const char *str, size_t length); memcached_return_t memcached_set_errno(Memcached& memc, int local_errno, const char *at); -memcached_return_t memcached_set_errno(org::libmemcached::Instance&, int local_errno, const char *at); +memcached_return_t memcached_set_errno(memcached_instance_st&, int local_errno, const char *at); bool memcached_has_current_error(Memcached&); -bool memcached_has_current_error(org::libmemcached::Instance&); +bool memcached_has_current_error(memcached_instance_st&); void memcached_error_free(Memcached&); void memcached_error_free(memcached_server_st&); -void memcached_error_free(org::libmemcached::Instance& self); +void memcached_error_free(memcached_instance_st& self); -memcached_error_t *memcached_error_copy(const org::libmemcached::Instance&); +memcached_error_t *memcached_error_copy(const memcached_instance_st&); -memcached_return_t memcached_instance_error_return(org::libmemcached::Instance*); +memcached_return_t memcached_instance_error_return(memcached_instance_st*); #endif diff --git a/libmemcached/exist.cc b/libmemcached/exist.cc index 8ed60545..3afb42d4 100644 --- a/libmemcached/exist.cc +++ b/libmemcached/exist.cc @@ -36,7 +36,7 @@ #include -static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length) +static memcached_return_t ascii_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length) { libmemcached_io_vector_st vector[]= { @@ -74,7 +74,7 @@ static memcached_return_t ascii_exist(Memcached *memc, org::libmemcached::Instan return rc; } -static memcached_return_t binary_exist(Memcached *memc, org::libmemcached::Instance* instance, const char *key, size_t key_length) +static memcached_return_t binary_exist(Memcached *memc, memcached_instance_st* instance, const char *key, size_t key_length) { protocol_binary_request_set request= {}; size_t send_length= sizeof(request.bytes); @@ -144,7 +144,7 @@ memcached_return_t memcached_exist_by_key(memcached_st *shell, } uint32_t server_key= memcached_generate_hash_with_redistribution(memc, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, server_key); + memcached_instance_st* instance= memcached_instance_fetch(memc, server_key); if (memcached_is_binary(memc)) { diff --git a/libmemcached/fetch.cc b/libmemcached/fetch.cc index 8eef0c78..7f677d02 100644 --- a/libmemcached/fetch.cc +++ b/libmemcached/fetch.cc @@ -192,7 +192,7 @@ memcached_result_st *memcached_fetch_result(memcached_st *ptr, } *error= MEMCACHED_MAXIMUM_RETURN; // We use this to see if we ever go into the loop - org::libmemcached::Instance *server; + memcached_instance_st *server; memcached_return_t read_ret= MEMCACHED_SUCCESS; while ((server= memcached_io_get_readable_server(ptr, read_ret))) { diff --git a/libmemcached/flush.cc b/libmemcached/flush.cc index 521515ac..cbb66bfe 100644 --- a/libmemcached/flush.cc +++ b/libmemcached/flush.cc @@ -52,7 +52,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr, for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); initialize_binary_request(instance, request.message.header); if (reply) @@ -84,7 +84,7 @@ static memcached_return_t memcached_flush_binary(Memcached *ptr, for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); if (instance->response_count() > 0) { @@ -115,7 +115,7 @@ static memcached_return_t memcached_flush_textual(Memcached *ptr, memcached_return_t rc= MEMCACHED_SUCCESS; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); libmemcached_io_vector_st vector[]= { diff --git a/libmemcached/flush_buffers.cc b/libmemcached/flush_buffers.cc index 3fa935c8..24f7c0df 100644 --- a/libmemcached/flush_buffers.cc +++ b/libmemcached/flush_buffers.cc @@ -46,7 +46,7 @@ memcached_return_t memcached_flush_buffers(memcached_st *shell) for (uint32_t x= 0; x < memcached_server_count(memc); ++x) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); if (instance->write_buffer_offset != 0) { diff --git a/libmemcached/get.cc b/libmemcached/get.cc index 0f151e8d..1f7e775c 100644 --- a/libmemcached/get.cc +++ b/libmemcached/get.cc @@ -244,7 +244,7 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, */ for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); if (instance->response_count()) { @@ -293,7 +293,7 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); libmemcached_io_vector_st vector[]= { @@ -354,7 +354,7 @@ static memcached_return_t __mget_by_key_real(memcached_st *ptr, bool success_happened= false; for (uint32_t x= 0; x < memcached_server_count(ptr); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); if (instance->response_count()) { @@ -480,7 +480,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, server_key= memcached_generate_hash_with_redistribution(ptr, keys[x], key_length[x]); } - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); if (instance->response_count() == 0) { @@ -553,7 +553,7 @@ static memcached_return_t simple_binary_mget(memcached_st *ptr, for (uint32_t x= 0; x < memcached_server_count(ptr); ++x) { - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, x); + memcached_instance_st* instance= memcached_instance_fetch(ptr, x); if (instance->response_count()) { @@ -618,7 +618,7 @@ static memcached_return_t replication_binary_mget(memcached_st *ptr, continue; } - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server); if (instance->response_count() == 0) { diff --git a/libmemcached/hosts.cc b/libmemcached/hosts.cc index 747245f9..121e8f7c 100644 --- a/libmemcached/hosts.cc +++ b/libmemcached/hosts.cc @@ -46,8 +46,8 @@ static memcached_return_t update_continuum(Memcached *ptr); static int compare_servers(const void *p1, const void *p2) { - memcached_server_instance_st a= (memcached_server_instance_st)p1; - memcached_server_instance_st b= (memcached_server_instance_st)p2; + const memcached_instance_st * a= (const memcached_instance_st *)p1; + const memcached_instance_st * b= (const memcached_instance_st *)p2; int return_value= strcmp(a->_hostname, b->_hostname); @@ -63,7 +63,7 @@ static void sort_hosts(Memcached *ptr) { if (memcached_server_count(ptr)) { - qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(org::libmemcached::Instance), compare_servers); + qsort(memcached_instance_list(ptr), memcached_server_count(ptr), sizeof(memcached_instance_st), compare_servers); } } @@ -146,7 +146,7 @@ static memcached_return_t update_continuum(Memcached *ptr) return memcached_set_errno(*ptr, errno, MEMCACHED_AT); } - org::libmemcached::Instance* list= memcached_instance_list(ptr); + memcached_instance_st* list= memcached_instance_list(ptr); /* count live servers (those without a retry delay set) */ bool is_auto_ejecting= _is_auto_eject_host(ptr); @@ -365,7 +365,7 @@ static memcached_return_t server_add(Memcached *memc, } uint32_t host_list_size= memc->number_of_hosts +1; - org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, org::libmemcached::Instance); + memcached_instance_st* new_host_list= libmemcached_xrealloc(memc, memcached_instance_list(memc), host_list_size, memcached_instance_st); if (new_host_list == NULL) { @@ -376,7 +376,7 @@ static memcached_return_t server_add(Memcached *memc, assert(memc->number_of_hosts == host_list_size); /* TODO: Check return type */ - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1); + memcached_instance_st* instance= memcached_instance_fetch(memc, memcached_server_count(memc) -1); if (__instance_create_with(memc, instance, hostname, port, weight, type) == NULL) { @@ -409,7 +409,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se uint32_t count= memcached_server_list_count(list); uint32_t host_list_size= count +original_host_size; - org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance); + memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st); if (new_host_list == NULL) { @@ -424,7 +424,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se WATCHPOINT_ASSERT(list[x].hostname[0] != 0); // We have extended the array, and now we will find it, and use it. - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size); + memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size); WATCHPOINT_ASSERT(instance); memcached_string_t hostname= { memcached_string_make_from_cstr(list[x].hostname) }; @@ -449,7 +449,7 @@ memcached_return_t memcached_server_push(memcached_st *shell, const memcached_se return MEMCACHED_INVALID_ARGUMENTS; } -memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org::libmemcached::Instance* list, uint32_t number_of_hosts) +memcached_return_t memcached_instance_push(memcached_st *ptr, const struct memcached_instance_st* list, uint32_t number_of_hosts) { if (list == NULL) { @@ -458,7 +458,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org:: uint32_t original_host_size= memcached_server_count(ptr); uint32_t host_list_size= number_of_hosts +original_host_size; - org::libmemcached::Instance* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, org::libmemcached::Instance); + memcached_instance_st* new_host_list= libmemcached_xrealloc(ptr, memcached_instance_list(ptr), host_list_size, memcached_instance_st); if (new_host_list == NULL) { @@ -477,7 +477,7 @@ memcached_return_t memcached_instance_push(memcached_st *ptr, const struct org:: WATCHPOINT_ASSERT(list[x]._hostname[0] != 0); // We have extended the array, and now we will find it, and use it. - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, original_host_size); + memcached_instance_st* instance= memcached_instance_fetch(ptr, original_host_size); WATCHPOINT_ASSERT(instance); memcached_string_t hostname= { memcached_string_make_from_cstr(list[x]._hostname) }; diff --git a/libmemcached/instance.cc b/libmemcached/instance.cc index ca3a30d8..82621f7a 100644 --- a/libmemcached/instance.cc +++ b/libmemcached/instance.cc @@ -37,7 +37,7 @@ #include -static inline void _server_init(org::libmemcached::Instance* self, Memcached *root, +static inline void _server_init(memcached_instance_st* self, Memcached *root, const memcached_string_t& hostname, in_port_t port, uint32_t weight, memcached_connection_t type) @@ -87,11 +87,11 @@ static inline void _server_init(org::libmemcached::Instance* self, Memcached *ro self->hostname(hostname); } -static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* self, const memcached_st *memc) +static memcached_instance_st* _server_create(memcached_instance_st* self, const memcached_st *memc) { if (self == NULL) { - self= libmemcached_xmalloc(memc, org::libmemcached::Instance); + self= libmemcached_xmalloc(memc, memcached_instance_st); if (self == NULL) { @@ -110,7 +110,7 @@ static org::libmemcached::Instance* _server_create(org::libmemcached::Instance* return self; } -void org::libmemcached::Instance::events(short arg) +void memcached_instance_st::events(short arg) { if ((_events | arg) == _events) { @@ -120,7 +120,7 @@ void org::libmemcached::Instance::events(short arg) _events|= arg; } -void org::libmemcached::Instance::revents(short arg) +void memcached_instance_st::revents(short arg) { if (arg) { @@ -131,8 +131,8 @@ void org::libmemcached::Instance::revents(short arg) _events&= short(~arg); } -org::libmemcached::Instance* __instance_create_with(memcached_st *memc, - org::libmemcached::Instance* self, +memcached_instance_st* __instance_create_with(memcached_st *memc, + memcached_instance_st* self, const memcached_string_t& hostname, const in_port_t port, uint32_t weight, @@ -162,7 +162,7 @@ org::libmemcached::Instance* __instance_create_with(memcached_st *memc, return self; } -void __instance_free(org::libmemcached::Instance* self) +void __instance_free(memcached_instance_st* self) { memcached_quit_server(self, false); @@ -181,7 +181,7 @@ void __instance_free(org::libmemcached::Instance* self) } } -void memcached_instance_free(org::libmemcached::Instance* self) +void memcached_instance_free(memcached_instance_st* self) { if (self) { @@ -204,7 +204,7 @@ memcached_return_t memcached_server_cursor(const memcached_st* shell, size_t errors= 0; for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++) { - org::libmemcached::Instance* instance= memcached_instance_by_position(memc, x); + memcached_instance_st* instance= memcached_instance_by_position(memc, x); for (uint32_t y= 0; y < number_of_callbacks; y++) { @@ -233,7 +233,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc, bool some_errors= false;; for (uint32_t x= 0; x < memcached_instance_list_count(memc); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); memcached_return_t rc= (*callback)(memc, instance, context); if (rc == MEMCACHED_INVALID_ARGUMENTS) @@ -250,7 +250,7 @@ memcached_return_t memcached_server_execute(memcached_st *memc, return MEMCACHED_SUCCESS; } -memcached_server_instance_st memcached_server_by_key(memcached_st *shell, +const memcached_instance_st * memcached_server_by_key(memcached_st *shell, const char *key, size_t key_length, memcached_return_t *error) @@ -283,7 +283,7 @@ memcached_server_instance_st memcached_server_by_key(memcached_st *shell, /* If we do not have a valid object to clone from, we toss an error. */ -static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached::Instance* source) +static memcached_instance_st* memcached_instance_clone(memcached_instance_st* source) { /* We just do a normal create if source is missing */ if (source == NULL) @@ -299,7 +299,7 @@ static org::libmemcached::Instance* memcached_instance_clone(org::libmemcached:: source->type); } -void set_last_disconnected_host(org::libmemcached::Instance* self) +void set_last_disconnected_host(memcached_instance_st* self) { assert(self->root); if (self->root) @@ -313,54 +313,48 @@ void set_last_disconnected_host(org::libmemcached::Instance* self) // const_cast memcached_st *root= (memcached_st *)self->root; - memcached_instance_free((org::libmemcached::Instance*)(root->last_disconnected_server)); + memcached_instance_free((memcached_instance_st*)(root->last_disconnected_server)); // We set is_parsing so that no lookup happens root->state.is_parsing= true; root->last_disconnected_server= memcached_instance_clone(self); root->state.is_parsing= false; - ((org::libmemcached::Instance*)memcached_server_get_last_disconnect(root))->version= self->version; + ((memcached_instance_st*)memcached_server_get_last_disconnect(root))->version= self->version; } } -memcached_server_instance_st memcached_server_get_last_disconnect(const memcached_st *shell) +const memcached_instance_st * memcached_server_get_last_disconnect(const memcached_st *shell) { const Memcached* self= memcached2Memcached(shell); if (self) { - return (memcached_server_instance_st)self->last_disconnected_server; + return (const memcached_instance_st *)self->last_disconnected_server; } return 0; } -void memcached_instance_next_retry(memcached_server_instance_st self, const time_t absolute_time) +void memcached_instance_next_retry(const memcached_instance_st * self, const time_t absolute_time) { WATCHPOINT_ASSERT(self); if (self) { - ((org::libmemcached::Instance*)self)->next_retry= absolute_time; + ((memcached_instance_st*)self)->next_retry= absolute_time; } } -namespace org { -namespace libmemcached { - - bool Instance::valid() const +bool memcached_instance_st::valid() const +{ + if (fd == INVALID_SOCKET) { - if (fd == INVALID_SOCKET) - { - return false; - } - - return true; + return false; } - bool Instance::is_shutting_down() const - { - return options.is_shutting_down; - } + return true; +} -} // namespace libmemcached -} // namespace org +bool memcached_instance_st::is_shutting_down() const +{ + return options.is_shutting_down; +} diff --git a/libmemcached/instance.hpp b/libmemcached/instance.hpp index d0a772b9..c76dc7ee 100644 --- a/libmemcached/instance.hpp +++ b/libmemcached/instance.hpp @@ -58,11 +58,8 @@ #include "libmemcached/string.hpp" -namespace org { -namespace libmemcached { - // @todo Complete class transformation -struct Instance { +struct memcached_instance_st { in_port_t port() const { return port_; @@ -188,16 +185,13 @@ struct Instance { } }; -} // namespace libmemcached -} // namespace org - -org::libmemcached::Instance* __instance_create_with(memcached_st *memc, - org::libmemcached::Instance* self, - const memcached_string_t& _hostname, - const in_port_t port, - uint32_t weight, - const memcached_connection_t type); +memcached_instance_st* __instance_create_with(memcached_st *memc, + memcached_instance_st* self, + const memcached_string_t& _hostname, + const in_port_t port, + uint32_t weight, + const memcached_connection_t type); -memcached_return_t memcached_instance_push(memcached_st *ptr, const org::libmemcached::Instance*, uint32_t); +memcached_return_t memcached_instance_push(memcached_st *ptr, const memcached_instance_st*, uint32_t); -void __instance_free(org::libmemcached::Instance *); +void __instance_free(memcached_instance_st *); diff --git a/libmemcached/io.cc b/libmemcached/io.cc index 1cd03769..cb8ed5c2 100644 --- a/libmemcached/io.cc +++ b/libmemcached/io.cc @@ -43,7 +43,7 @@ # include #endif -void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header& header) +void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header& header) { server->request_id++; header.request.magic= PROTOCOL_BINARY_REQ; @@ -61,7 +61,7 @@ enum memc_read_or_write { * * @param instance the server to pack */ -static bool repack_input_buffer(org::libmemcached::Instance* instance) +static bool repack_input_buffer(memcached_instance_st* instance) { if (instance->read_ptr != instance->read_buffer) { @@ -134,7 +134,7 @@ static bool repack_input_buffer(org::libmemcached::Instance* instance) * @param instance the server to star processing iput messages for * @return true if we processed anything, false otherwise */ -static bool process_input_buffer(org::libmemcached::Instance* instance) +static bool process_input_buffer(memcached_instance_st* instance) { /* ** We might be able to process some of the response messages if we @@ -176,7 +176,7 @@ static bool process_input_buffer(org::libmemcached::Instance* instance) return false; } -static memcached_return_t io_wait(org::libmemcached::Instance* instance, +static memcached_return_t io_wait(memcached_instance_st* instance, const memc_read_or_write read_or_write) { /* @@ -296,7 +296,7 @@ static memcached_return_t io_wait(org::libmemcached::Instance* instance, memcached_literal_param("number of attempts to call io_wait() failed")); } -static bool io_flush(org::libmemcached::Instance* instance, +static bool io_flush(memcached_instance_st* instance, const bool with_flush, memcached_return_t& error) { @@ -407,12 +407,12 @@ static bool io_flush(org::libmemcached::Instance* instance, return true; } -memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* instance) +memcached_return_t memcached_io_wait_for_write(memcached_instance_st* instance) { return io_wait(instance, MEM_WRITE); } -static memcached_return_t _io_fill(org::libmemcached::Instance* instance) +static memcached_return_t _io_fill(memcached_instance_st* instance) { ssize_t data_read; do @@ -488,7 +488,7 @@ static memcached_return_t _io_fill(org::libmemcached::Instance* instance) return MEMCACHED_SUCCESS; } -memcached_return_t memcached_io_read(org::libmemcached::Instance* instance, +memcached_return_t memcached_io_read(memcached_instance_st* instance, void *buffer, size_t length, ssize_t& nread) { assert(memcached_is_udp(instance->root) == false); @@ -540,7 +540,7 @@ memcached_return_t memcached_io_read(org::libmemcached::Instance* instance, return MEMCACHED_SUCCESS; } -memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance) +memcached_return_t memcached_io_slurp(memcached_instance_st* instance) { assert_msg(instance, "Programmer error, invalid Instance"); assert(memcached_is_udp(instance->root) == false); @@ -597,7 +597,7 @@ memcached_return_t memcached_io_slurp(org::libmemcached::Instance* instance) return MEMCACHED_CONNECTION_FAILURE; } -static bool _io_write(org::libmemcached::Instance* instance, +static bool _io_write(memcached_instance_st* instance, const void *buffer, size_t length, bool with_flush, size_t& written) { @@ -650,13 +650,13 @@ static bool _io_write(org::libmemcached::Instance* instance, return true; } -bool memcached_io_write(org::libmemcached::Instance* instance) +bool memcached_io_write(memcached_instance_st* instance) { size_t written; return _io_write(instance, NULL, 0, true, written); } -ssize_t memcached_io_write(org::libmemcached::Instance* instance, +ssize_t memcached_io_write(memcached_instance_st* instance, const void *buffer, const size_t length, const bool with_flush) { size_t written; @@ -669,7 +669,7 @@ ssize_t memcached_io_write(org::libmemcached::Instance* instance, return ssize_t(written); } -bool memcached_io_writev(org::libmemcached::Instance* instance, +bool memcached_io_writev(memcached_instance_st* instance, libmemcached_io_vector_st vector[], const size_t number_of, const bool with_flush) { @@ -701,7 +701,7 @@ bool memcached_io_writev(org::libmemcached::Instance* instance, return (complete_total == total); } -void org::libmemcached::Instance::start_close_socket() +void memcached_instance_st::start_close_socket() { if (fd != INVALID_SOCKET) { @@ -710,7 +710,7 @@ void org::libmemcached::Instance::start_close_socket() } } -void org::libmemcached::Instance::reset_socket() +void memcached_instance_st::reset_socket() { if (fd != INVALID_SOCKET) { @@ -719,7 +719,7 @@ void org::libmemcached::Instance::reset_socket() } } -void org::libmemcached::Instance::close_socket() +void memcached_instance_st::close_socket() { if (fd != INVALID_SOCKET) { @@ -755,7 +755,7 @@ void org::libmemcached::Instance::close_socket() major_version= minor_version= micro_version= UINT8_MAX; } -org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&) +memcached_instance_st* memcached_io_get_readable_server(Memcached *memc, memcached_return_t&) { #define MAX_SERVERS_TO_POLL 100 struct pollfd fds[MAX_SERVERS_TO_POLL]; @@ -763,7 +763,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m for (uint32_t x= 0; x < memcached_server_count(memc) and host_index < MAX_SERVERS_TO_POLL; ++x) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); if (instance->read_buffer_length > 0) /* I have data in the buffer */ { @@ -784,7 +784,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m /* We have 0 or 1 server with pending events.. */ for (uint32_t x= 0; x< memcached_server_count(memc); ++x) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); if (instance->response_count() > 0) { @@ -811,7 +811,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m { for (uint32_t y= 0; y < memcached_server_count(memc); ++y) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, y); + memcached_instance_st* instance= memcached_instance_fetch(memc, y); if (instance->fd == fds[x].fd) { @@ -828,7 +828,7 @@ org::libmemcached::Instance* memcached_io_get_readable_server(Memcached *memc, m /* Eventually we will just kill off the server with the problem. */ -void memcached_io_reset(org::libmemcached::Instance* instance) +void memcached_io_reset(memcached_instance_st* instance) { memcached_quit_server(instance, true); } @@ -837,7 +837,7 @@ void memcached_io_reset(org::libmemcached::Instance* instance) * Read a given number of bytes from the server and place it into a specific * buffer. Reset the IO channel on this server if an error occurs. */ -memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance, +memcached_return_t memcached_safe_read(memcached_instance_st* instance, void *dta, const size_t size) { @@ -862,7 +862,7 @@ memcached_return_t memcached_safe_read(org::libmemcached::Instance* instance, return MEMCACHED_SUCCESS; } -memcached_return_t memcached_io_readline(org::libmemcached::Instance* instance, +memcached_return_t memcached_io_readline(memcached_instance_st* instance, char *buffer_ptr, size_t size, size_t& total_nr) diff --git a/libmemcached/io.hpp b/libmemcached/io.hpp index bf2133e8..f3fed345 100644 --- a/libmemcached/io.hpp +++ b/libmemcached/io.hpp @@ -38,35 +38,35 @@ #pragma once -void initialize_binary_request(org::libmemcached::Instance* server, protocol_binary_request_header&); +void initialize_binary_request(memcached_instance_st* server, protocol_binary_request_header&); -bool memcached_io_write(org::libmemcached::Instance* ptr); +bool memcached_io_write(memcached_instance_st* ptr); -ssize_t memcached_io_write(org::libmemcached::Instance* ptr, +ssize_t memcached_io_write(memcached_instance_st* ptr, const void *buffer, size_t length, bool with_flush); -bool memcached_io_writev(org::libmemcached::Instance* ptr, +bool memcached_io_writev(memcached_instance_st* ptr, libmemcached_io_vector_st vector[], const size_t number_of, const bool with_flush); -memcached_return_t memcached_io_wait_for_write(org::libmemcached::Instance* ptr); +memcached_return_t memcached_io_wait_for_write(memcached_instance_st* ptr); -void memcached_io_reset(org::libmemcached::Instance* ptr); +void memcached_io_reset(memcached_instance_st* ptr); -memcached_return_t memcached_io_read(org::libmemcached::Instance* ptr, +memcached_return_t memcached_io_read(memcached_instance_st* ptr, void *buffer, size_t length, ssize_t& nread); /* Read a line (terminated by '\n') into the buffer */ -memcached_return_t memcached_io_readline(org::libmemcached::Instance* ptr, +memcached_return_t memcached_io_readline(memcached_instance_st* ptr, char *buffer_ptr, size_t size, size_t& total); /* Read n bytes of data from the server and store them in dta */ -memcached_return_t memcached_safe_read(org::libmemcached::Instance* ptr, +memcached_return_t memcached_safe_read(memcached_instance_st* ptr, void *dta, const size_t size); -org::libmemcached::Instance* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&); +memcached_instance_st* memcached_io_get_readable_server(memcached_st *memc, memcached_return_t&); -memcached_return_t memcached_io_slurp(org::libmemcached::Instance* ptr); +memcached_return_t memcached_io_slurp(memcached_instance_st* ptr); diff --git a/libmemcached/memcached.cc b/libmemcached/memcached.cc index a5d1a527..a3c6a679 100644 --- a/libmemcached/memcached.cc +++ b/libmemcached/memcached.cc @@ -136,7 +136,7 @@ static void __memcached_free(Memcached *ptr, bool release_st) memcached_virtual_bucket_free(ptr); - memcached_instance_free((org::libmemcached::Instance*)ptr->last_disconnected_server); + memcached_instance_free((memcached_instance_st*)ptr->last_disconnected_server); if (ptr->on_cleanup) { @@ -297,7 +297,7 @@ void memcached_reset_last_disconnected_server(memcached_st *shell) Memcached* self= memcached2Memcached(shell); if (self) { - memcached_instance_free((org::libmemcached::Instance*)self->last_disconnected_server); + memcached_instance_free((memcached_instance_st*)self->last_disconnected_server); self->last_disconnected_server= NULL; } } @@ -432,10 +432,10 @@ void *memcached_set_user_data(memcached_st *shell, void *data) memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source) { - return memcached_instance_push(destination, (org::libmemcached::Instance*)source->servers, source->number_of_hosts); + return memcached_instance_push(destination, (memcached_instance_st*)source->servers, source->number_of_hosts); } -org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t server_key) +memcached_instance_st* memcached_instance_fetch(Memcached *ptr, uint32_t server_key) { if (ptr == NULL) { @@ -445,7 +445,7 @@ org::libmemcached::Instance* memcached_instance_fetch(Memcached *ptr, uint32_t s return &ptr->servers[server_key]; } -memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key) +const memcached_instance_st * memcached_server_instance_by_position(const memcached_st *shell, uint32_t server_key) { const Memcached* memc= memcached2Memcached(shell); if (memc) @@ -456,7 +456,7 @@ memcached_server_instance_st memcached_server_instance_by_position(const memcach return NULL; } -org::libmemcached::Instance* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key) +memcached_instance_st* memcached_instance_by_position(const memcached_st *shell, uint32_t server_key) { const Memcached* memc= memcached2Memcached(shell); if (memc) @@ -478,12 +478,12 @@ uint64_t memcached_query_id(const memcached_st *shell) return 0; } -org::libmemcached::Instance* memcached_instance_list(const memcached_st *shell) +memcached_instance_st* memcached_instance_list(const memcached_st *shell) { const Memcached* memc= memcached2Memcached(shell); if (memc) { - return (org::libmemcached::Instance*)memc->servers; + return (memcached_instance_st*)memc->servers; } return NULL; diff --git a/libmemcached/purge.cc b/libmemcached/purge.cc index b1390d9c..5f6d4bb7 100644 --- a/libmemcached/purge.cc +++ b/libmemcached/purge.cc @@ -79,7 +79,7 @@ private: int32_t& _origin; }; -bool memcached_purge(org::libmemcached::Instance* ptr) +bool memcached_purge(memcached_instance_st* ptr) { Memcached *root= (Memcached *)ptr->root; diff --git a/libmemcached/quit.cc b/libmemcached/quit.cc index 61930beb..7ece03b9 100644 --- a/libmemcached/quit.cc +++ b/libmemcached/quit.cc @@ -38,7 +38,7 @@ #include namespace { - memcached_return_t send_quit_message(org::libmemcached::Instance* instance) + memcached_return_t send_quit_message(memcached_instance_st* instance) { memcached_return_t rc; if (instance->root->flags.binary_protocol) @@ -70,7 +70,7 @@ namespace { return rc; } - void drain_instance(org::libmemcached::Instance* instance) + void drain_instance(memcached_instance_st* instance) { /* read until socket is closed, or there is an error * closing the socket before all data is read @@ -105,7 +105,7 @@ namespace { will force data to be completed. */ -void memcached_quit_server(org::libmemcached::Instance* instance, bool io_death) +void memcached_quit_server(memcached_instance_st* instance, bool io_death) { if (instance->valid()) { @@ -130,7 +130,7 @@ void send_quit(Memcached *memc) { for (uint32_t x= 0; x < memcached_server_count(memc); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); memcached_quit_server(instance, false); } diff --git a/libmemcached/quit.hpp b/libmemcached/quit.hpp index 76737b95..a48a8a7e 100644 --- a/libmemcached/quit.hpp +++ b/libmemcached/quit.hpp @@ -36,6 +36,6 @@ #pragma once -void memcached_quit_server(org::libmemcached::Instance* ptr, bool io_death); +void memcached_quit_server(memcached_instance_st* ptr, bool io_death); void send_quit(memcached_st *ptr); diff --git a/libmemcached/response.cc b/libmemcached/response.cc index 7503c5a0..c01d5089 100644 --- a/libmemcached/response.cc +++ b/libmemcached/response.cc @@ -38,7 +38,7 @@ #include #include -static memcached_return_t textual_value_fetch(org::libmemcached::Instance* instance, +static memcached_return_t textual_value_fetch(memcached_instance_st* instance, char *buffer, memcached_result_st *result) { @@ -210,7 +210,7 @@ read_error: return MEMCACHED_PARTIAL_READ; } -static memcached_return_t textual_read_one_response(org::libmemcached::Instance* instance, +static memcached_return_t textual_read_one_response(memcached_instance_st* instance, char *buffer, const size_t buffer_length, memcached_result_st *result) { @@ -493,7 +493,7 @@ static memcached_return_t textual_read_one_response(org::libmemcached::Instance* buffer, total_read); } -static memcached_return_t binary_read_one_response(org::libmemcached::Instance* instance, +static memcached_return_t binary_read_one_response(memcached_instance_st* instance, char *buffer, const size_t buffer_length, memcached_result_st *result) { @@ -831,7 +831,7 @@ static memcached_return_t binary_read_one_response(org::libmemcached::Instance* return rc; } -static memcached_return_t _read_one_response(org::libmemcached::Instance* instance, +static memcached_return_t _read_one_response(memcached_instance_st* instance, char *buffer, const size_t buffer_length, memcached_result_st *result) { @@ -861,7 +861,7 @@ static memcached_return_t _read_one_response(org::libmemcached::Instance* instan return rc; } -memcached_return_t memcached_read_one_response(org::libmemcached::Instance* instance, +memcached_return_t memcached_read_one_response(memcached_instance_st* instance, memcached_result_st *result) { char buffer[SMALL_STRING_LEN]; @@ -875,7 +875,7 @@ memcached_return_t memcached_read_one_response(org::libmemcached::Instance* inst return _read_one_response(instance, buffer, sizeof(buffer), result); } -memcached_return_t memcached_response(org::libmemcached::Instance* instance, +memcached_return_t memcached_response(memcached_instance_st* instance, memcached_result_st *result) { char buffer[1024]; @@ -883,7 +883,7 @@ memcached_return_t memcached_response(org::libmemcached::Instance* instance, return memcached_response(instance, buffer, sizeof(buffer), result); } -memcached_return_t memcached_response(org::libmemcached::Instance* instance, +memcached_return_t memcached_response(memcached_instance_st* instance, char *buffer, size_t buffer_length, memcached_result_st *result) { diff --git a/libmemcached/response.h b/libmemcached/response.h index 6d6d5644..c066f3b3 100644 --- a/libmemcached/response.h +++ b/libmemcached/response.h @@ -38,12 +38,12 @@ #pragma once /* Read a single response from the server */ -memcached_return_t memcached_read_one_response(org::libmemcached::Instance* ptr, +memcached_return_t memcached_read_one_response(memcached_instance_st* ptr, memcached_result_st *result); -memcached_return_t memcached_response(org::libmemcached::Instance* ptr, +memcached_return_t memcached_response(memcached_instance_st* ptr, memcached_result_st *result); -memcached_return_t memcached_response(org::libmemcached::Instance* ptr, +memcached_return_t memcached_response(memcached_instance_st* ptr, char *buffer, size_t buffer_length, memcached_result_st *result); diff --git a/libmemcached/sasl.cc b/libmemcached/sasl.cc index 8e180d6f..ee225868 100644 --- a/libmemcached/sasl.cc +++ b/libmemcached/sasl.cc @@ -75,7 +75,7 @@ sasl_callback_t *memcached_get_sasl_callbacks(memcached_st *shell) * @param raddr remote address (out) * @return true on success false otherwise (errno contains more info) */ -static memcached_return_t resolve_names(org::libmemcached::Instance& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length) +static memcached_return_t resolve_names(memcached_instance_st& server, char *laddr, size_t laddr_length, char *raddr, size_t raddr_length) { char host[MEMCACHED_NI_MAXHOST]; char port[MEMCACHED_NI_MAXSERV]; @@ -133,7 +133,7 @@ static void sasl_startup_function(void) } // extern "C" -memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server) +memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server) { if (LIBMEMCACHED_WITH_SASL_SUPPORT == 0) { diff --git a/libmemcached/sasl.hpp b/libmemcached/sasl.hpp index c990cfb8..bda6b227 100644 --- a/libmemcached/sasl.hpp +++ b/libmemcached/sasl.hpp @@ -39,4 +39,4 @@ memcached_return_t memcached_clone_sasl(memcached_st *clone, const memcached_st *source); -memcached_return_t memcached_sasl_authenticate_connection(org::libmemcached::Instance* server); +memcached_return_t memcached_sasl_authenticate_connection(memcached_instance_st* server); diff --git a/libmemcached/server.cc b/libmemcached/server.cc index ba40a6ee..b38120ad 100644 --- a/libmemcached/server.cc +++ b/libmemcached/server.cc @@ -191,7 +191,7 @@ uint32_t memcached_server_count(const memcached_st *self) return self->number_of_hosts; } -const char *memcached_server_name(const memcached_server_instance_st self) +const char *memcached_server_name(const memcached_instance_st * self) { WATCHPOINT_ASSERT(self); if (self) @@ -202,7 +202,7 @@ const char *memcached_server_name(const memcached_server_instance_st self) return NULL; } -in_port_t memcached_server_port(const memcached_server_instance_st self) +in_port_t memcached_server_port(const memcached_instance_st * self) { WATCHPOINT_ASSERT(self); if (self == NULL) @@ -213,7 +213,7 @@ in_port_t memcached_server_port(const memcached_server_instance_st self) return self->port(); } -uint32_t memcached_server_response_count(const memcached_server_instance_st self) +uint32_t memcached_server_response_count(const memcached_instance_st * self) { WATCHPOINT_ASSERT(self); if (self == NULL) @@ -224,7 +224,7 @@ uint32_t memcached_server_response_count(const memcached_server_instance_st self return self->cursor_active_; } -const char *memcached_server_type(const memcached_server_instance_st ptr) +const char *memcached_server_type(const memcached_instance_st * ptr) { if (ptr) { @@ -244,7 +244,7 @@ const char *memcached_server_type(const memcached_server_instance_st ptr) return "UNKNOWN"; } -uint8_t memcached_server_major_version(const memcached_server_instance_st instance) +uint8_t memcached_server_major_version(const memcached_instance_st * instance) { if (instance) { @@ -254,7 +254,7 @@ uint8_t memcached_server_major_version(const memcached_server_instance_st instan return UINT8_MAX; } -uint8_t memcached_server_minor_version(const memcached_server_instance_st instance) +uint8_t memcached_server_minor_version(const memcached_instance_st * instance) { if (instance) { @@ -264,7 +264,7 @@ uint8_t memcached_server_minor_version(const memcached_server_instance_st instan return UINT8_MAX; } -uint8_t memcached_server_micro_version(const memcached_server_instance_st instance) +uint8_t memcached_server_micro_version(const memcached_instance_st * instance) { if (instance) { diff --git a/libmemcached/server.hpp b/libmemcached/server.hpp index 8cbdc151..0c6ac798 100644 --- a/libmemcached/server.hpp +++ b/libmemcached/server.hpp @@ -68,11 +68,11 @@ static inline bool memcached_is_valid_filename(const memcached_string_t& arg) return arg.c_str != NULL and arg.size > 0 and arg.size < MEMCACHED_NI_MAXHOST; } -void memcached_instance_free(org::libmemcached::Instance *); +void memcached_instance_free(memcached_instance_st *); -void set_last_disconnected_host(org::libmemcached::Instance* self); +void set_last_disconnected_host(memcached_instance_st* self); -static inline void memcached_mark_server_for_timeout(org::libmemcached::Instance* server) +static inline void memcached_mark_server_for_timeout(memcached_instance_st* server) { if (server->state != MEMCACHED_SERVER_STATE_IN_TIMEOUT) { diff --git a/libmemcached/server_instance.h b/libmemcached/server_instance.h index 3b69b77b..187f2744 100644 --- a/libmemcached/server_instance.h +++ b/libmemcached/server_instance.h @@ -38,8 +38,7 @@ #pragma once #ifdef __cplusplus -namespace org { namespace libmemcached { struct Instance; } } -typedef struct org::libmemcached::Instance* memcached_server_write_instance_st; +typedef struct memcached_instance_st* memcached_server_write_instance_st; #else typedef void* memcached_server_write_instance_st; #endif diff --git a/libmemcached/server_list.cc b/libmemcached/server_list.cc index b42a9095..b5d5b72e 100644 --- a/libmemcached/server_list.cc +++ b/libmemcached/server_list.cc @@ -127,7 +127,7 @@ uint32_t memcached_instance_list_count(const memcached_st* self) : self->number_of_hosts; } -void memcached_instance_set(memcached_st* memc, org::libmemcached::Instance* list, const uint32_t host_list_size) +void memcached_instance_set(memcached_st* memc, memcached_instance_st* list, const uint32_t host_list_size) { assert(memc); memc->servers= list; @@ -148,7 +148,7 @@ void memcached_server_list_free(memcached_server_list_st self) } } -void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t instance_count) +void memcached_instance_list_free(memcached_instance_st* self, uint32_t instance_count) { if (self) { diff --git a/libmemcached/server_list.hpp b/libmemcached/server_list.hpp index ffbb6a36..0280332c 100644 --- a/libmemcached/server_list.hpp +++ b/libmemcached/server_list.hpp @@ -36,12 +36,12 @@ #pragma once -org::libmemcached::Instance* memcached_instance_list(const memcached_st *); +memcached_instance_st* memcached_instance_list(const memcached_st *); uint32_t memcached_instance_list_count(const memcached_st*); uint32_t memcached_servers_set_count(memcached_server_list_st servers, uint32_t count); -void memcached_instance_list_free(org::libmemcached::Instance* self, uint32_t count); +void memcached_instance_list_free(memcached_instance_st* self, uint32_t count); -void memcached_instance_set(memcached_st*, org::libmemcached::Instance*, const uint32_t host_list_size); +void memcached_instance_set(memcached_st*, memcached_instance_st*, const uint32_t host_list_size); diff --git a/libmemcached/stats.cc b/libmemcached/stats.cc index 01a8baf6..d70972ef 100644 --- a/libmemcached/stats.cc +++ b/libmemcached/stats.cc @@ -477,7 +477,7 @@ char *memcached_stat_get_value(const memcached_st *, memcached_stat_st *memc_sta static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat, const char *args, const size_t args_length, - org::libmemcached::Instance* instance, + memcached_instance_st* instance, struct local_context *check) { char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; @@ -567,7 +567,7 @@ static memcached_return_t binary_stats_fetch(memcached_stat_st *memc_stat, static memcached_return_t ascii_stats_fetch(memcached_stat_st *memc_stat, const char *args, const size_t args_length, - org::libmemcached::Instance* instance, + memcached_instance_st* instance, struct local_context *check) { libmemcached_io_vector_st vector[]= @@ -684,7 +684,7 @@ memcached_stat_st *memcached_stat(memcached_st *shell, char *args, memcached_ret stat_instance->pid= -1; stat_instance->root= self; - org::libmemcached::Instance* instance= memcached_instance_fetch(self, x); + memcached_instance_st* instance= memcached_instance_fetch(self, x); memcached_return_t temp_return; if (memcached_is_binary(self)) @@ -751,7 +751,7 @@ memcached_return_t memcached_stat_servername(memcached_stat_st *memc_stat, char if (memcached_success(rc)) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0); + memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0); if (memc.flags.binary_protocol) { rc= binary_stats_fetch(memc_stat, args, args_length, instance, NULL); @@ -813,7 +813,7 @@ void memcached_stat_free(const memcached_st *, memcached_stat_st *memc_stat) } static memcached_return_t call_stat_fn(memcached_st *memc, - org::libmemcached::Instance* instance, + memcached_instance_st* instance, void *context) { if (memc) diff --git a/libmemcached/storage.cc b/libmemcached/storage.cc index 558d2ed5..80b5a7f1 100644 --- a/libmemcached/storage.cc +++ b/libmemcached/storage.cc @@ -139,7 +139,7 @@ static inline uint8_t get_com_code(const memcached_storage_action_t verb, const } static memcached_return_t memcached_send_binary(Memcached *ptr, - org::libmemcached::Instance* server, + memcached_instance_st* server, uint32_t server_key, const char *key, const size_t key_length, @@ -218,7 +218,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr, server_key= 0; } - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); if (memcached_vdo(instance, vector, 5, false) != MEMCACHED_SUCCESS) { @@ -246,7 +246,7 @@ static memcached_return_t memcached_send_binary(Memcached *ptr, } static memcached_return_t memcached_send_ascii(Memcached *ptr, - org::libmemcached::Instance* instance, + memcached_instance_st* instance, const char *key, const size_t key_length, const char *value, @@ -373,7 +373,7 @@ static inline memcached_return_t memcached_send(memcached_st *shell, } uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); WATCHPOINT_SET(instance->io_wait_count.read= 0); WATCHPOINT_SET(instance->io_wait_count.write= 0); diff --git a/libmemcached/touch.cc b/libmemcached/touch.cc index 0c24aed1..1f793c55 100644 --- a/libmemcached/touch.cc +++ b/libmemcached/touch.cc @@ -38,7 +38,7 @@ #include #include -static memcached_return_t ascii_touch(org::libmemcached::Instance* instance, +static memcached_return_t ascii_touch(memcached_instance_st* instance, const char *key, size_t key_length, time_t expiration) { @@ -70,7 +70,7 @@ static memcached_return_t ascii_touch(org::libmemcached::Instance* instance, return rc; } -static memcached_return_t binary_touch(org::libmemcached::Instance* instance, +static memcached_return_t binary_touch(memcached_instance_st* instance, const char *key, size_t key_length, time_t expiration) { @@ -130,7 +130,7 @@ memcached_return_t memcached_touch_by_key(memcached_st *shell, } uint32_t server_key= memcached_generate_hash_with_redistribution(ptr, group_key, group_key_length); - org::libmemcached::Instance* instance= memcached_instance_fetch(ptr, server_key); + memcached_instance_st* instance= memcached_instance_fetch(ptr, server_key); if (ptr->flags.binary_protocol) { diff --git a/libmemcached/udp.cc b/libmemcached/udp.cc index 923e2734..5d21f9ff 100644 --- a/libmemcached/udp.cc +++ b/libmemcached/udp.cc @@ -48,7 +48,7 @@ * extracts the message number from message_id, increments it and then * writes the new value back into the header */ -void increment_udp_message_id(org::libmemcached::Instance* ptr) +void increment_udp_message_id(memcached_instance_st* ptr) { struct udp_datagram_header_st *header= (struct udp_datagram_header_st *)ptr->write_buffer; uint16_t cur_req= get_udp_datagram_request_id(header); @@ -61,7 +61,7 @@ void increment_udp_message_id(org::libmemcached::Instance* ptr) header->request_id= htons((uint16_t) (thread_id | msg_num)); } -bool memcached_io_init_udp_header(org::libmemcached::Instance* ptr, const uint16_t thread_id) +bool memcached_io_init_udp_header(memcached_instance_st* ptr, const uint16_t thread_id) { if (thread_id > UDP_REQUEST_ID_MAX_THREAD_ID) { diff --git a/libmemcached/udp.hpp b/libmemcached/udp.hpp index b2d2e9e9..7442c597 100644 --- a/libmemcached/udp.hpp +++ b/libmemcached/udp.hpp @@ -55,5 +55,5 @@ struct udp_datagram_header_st uint16_t reserved; }; -bool memcached_io_init_udp_header(org::libmemcached::Instance*, const uint16_t thread_id); -void increment_udp_message_id(org::libmemcached::Instance*); +bool memcached_io_init_udp_header(memcached_instance_st*, const uint16_t thread_id); +void increment_udp_message_id(memcached_instance_st*); diff --git a/libmemcached/verbosity.cc b/libmemcached/verbosity.cc index 7f3a16e4..ed0e2440 100644 --- a/libmemcached/verbosity.cc +++ b/libmemcached/verbosity.cc @@ -44,7 +44,7 @@ struct context_st }; static memcached_return_t _set_verbosity(const Memcached *, - const memcached_server_instance_st server, + const memcached_instance_st * server, void *context) { libmemcached_io_vector_st *vector= (libmemcached_io_vector_st *)context; @@ -56,7 +56,7 @@ static memcached_return_t _set_verbosity(const Memcached *, if (rc == MEMCACHED_SUCCESS) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc_ptr, 0); + memcached_instance_st* instance= memcached_instance_fetch(memc_ptr, 0); rc= memcached_vdo(instance, vector, 4, true); diff --git a/libmemcached/version.cc b/libmemcached/version.cc index bbe46cc5..5f074912 100644 --- a/libmemcached/version.cc +++ b/libmemcached/version.cc @@ -52,7 +52,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc) bool errors_happened= false; for (uint32_t x= 0; x < memcached_server_count(memc); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); // Optimization, we only fetch version once. if (instance->major_version != UINT8_MAX) @@ -73,7 +73,7 @@ static inline memcached_return_t memcached_version_textual(Memcached *memc) if (success) { // Collect the returned items - org::libmemcached::Instance* instance; + memcached_instance_st* instance; memcached_return_t readable_error; while ((instance= memcached_io_get_readable_server(memc, readable_error))) { @@ -105,7 +105,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc) bool errors_happened= false; for (uint32_t x= 0; x < memcached_server_count(memc); x++) { - org::libmemcached::Instance* instance= memcached_instance_fetch(memc, x); + memcached_instance_st* instance= memcached_instance_fetch(memc, x); initialize_binary_request(instance, request.message.header); @@ -128,7 +128,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc) if (success) { // Collect the returned items - org::libmemcached::Instance* instance; + memcached_instance_st* instance; memcached_return_t readable_error; while ((instance= memcached_io_get_readable_server(memc, readable_error))) { @@ -145,7 +145,7 @@ static inline memcached_return_t memcached_version_binary(Memcached *memc) return errors_happened ? MEMCACHED_SOME_ERRORS : MEMCACHED_SUCCESS; } -static inline void version_ascii_instance(org::libmemcached::Instance* instance) +static inline void version_ascii_instance(memcached_instance_st* instance) { if (instance->major_version != UINT8_MAX) { @@ -158,7 +158,7 @@ static inline void version_ascii_instance(org::libmemcached::Instance* instance) } } -static inline void version_binary_instance(org::libmemcached::Instance* instance) +static inline void version_binary_instance(memcached_instance_st* instance) { if (instance->major_version != UINT8_MAX) { @@ -178,7 +178,7 @@ static inline void version_binary_instance(org::libmemcached::Instance* instance } } -void memcached_version_instance(org::libmemcached::Instance* instance) +void memcached_version_instance(memcached_instance_st* instance) { if (instance) { diff --git a/libmemcached/version.hpp b/libmemcached/version.hpp index b4a8234b..f420a262 100644 --- a/libmemcached/version.hpp +++ b/libmemcached/version.hpp @@ -41,4 +41,4 @@ #pragma once -void memcached_version_instance(org::libmemcached::Instance*); +void memcached_version_instance(memcached_instance_st*); -- cgit v1.2.1