2 +--------------------------------------------------------------------+
3 | libmemcached-awesome - C/C++ Client Library for memcached |
4 +--------------------------------------------------------------------+
5 | Redistribution and use in source and binary forms, with or without |
6 | modification, are permitted under the terms of the BSD license. |
7 | You should have received a copy of the license in a bundled file |
8 | named LICENSE; in case you did not receive a copy you can review |
9 | the terms online at: https://opensource.org/licenses/BSD-3-Clause |
10 +--------------------------------------------------------------------+
11 | Copyright (c) 2006-2014 Brian Aker https://datadifferential.com/ |
12 | Copyright (c) 2020-2021 Michael Wallner https://awesome.co/ |
13 +--------------------------------------------------------------------+
16 #include "libmemcached/common.h"
18 #include "libmemcached/options.hpp"
19 #include "libmemcached/virtual_bucket.h"
21 static inline bool _memcached_init(Memcached
*self
) {
22 self
->state
.is_purging
= false;
23 self
->state
.is_processing_input
= false;
24 self
->state
.is_time_for_rebuild
= false;
25 self
->state
.is_parsing
= false;
27 self
->flags
.auto_eject_hosts
= false;
28 self
->flags
.binary_protocol
= false;
29 self
->flags
.meta_protocol
= false;
30 self
->flags
.buffer_requests
= false;
31 self
->flags
.hash_with_namespace
= false;
32 self
->flags
.no_block
= false;
33 self
->flags
.reply
= true;
34 self
->flags
.randomize_replica_read
= false;
35 self
->flags
.support_cas
= false;
36 self
->flags
.tcp_nodelay
= false;
37 self
->flags
.use_sort_hosts
= false;
38 self
->flags
.use_udp
= false;
39 self
->flags
.verify_key
= false;
40 self
->flags
.tcp_keepalive
= false;
41 self
->flags
.is_aes
= false;
42 self
->flags
.is_fetching_version
= false;
44 self
->virtual_bucket
= NULL
;
46 self
->distribution
= MEMCACHED_DISTRIBUTION_MODULA
;
48 if (hashkit_create(&self
->hashkit
) == NULL
) {
52 self
->server_info
.version
= 0;
54 self
->ketama
.continuum
= NULL
;
55 self
->ketama
.continuum_count
= 0;
56 self
->ketama
.continuum_points_counter
= 0;
57 self
->ketama
.next_distribution_rebuild
= 0;
58 self
->ketama
.weighted_
= false;
60 self
->number_of_hosts
= 0;
62 self
->last_disconnected_server
= NULL
;
64 self
->snd_timeout
= 0;
65 self
->rcv_timeout
= 0;
66 self
->server_failure_limit
= MEMCACHED_SERVER_FAILURE_LIMIT
;
67 self
->server_timeout_limit
= MEMCACHED_SERVER_TIMEOUT_LIMIT
;
68 self
->query_id
= 1; // 0 is considered invalid
70 /* TODO, Document why we picked these defaults */
71 self
->io_msg_watermark
= 500;
72 self
->io_bytes_watermark
= 65 * 1024;
74 self
->tcp_keepidle
= 0;
76 self
->io_key_prefetch
= 0;
77 self
->poll_timeout
= MEMCACHED_DEFAULT_TIMEOUT
;
78 self
->connect_timeout
= MEMCACHED_DEFAULT_CONNECT_TIMEOUT
;
79 self
->retry_timeout
= MEMCACHED_SERVER_FAILURE_RETRY_TIMEOUT
;
80 self
->dead_timeout
= MEMCACHED_SERVER_FAILURE_DEAD_TIMEOUT
;
85 self
->user_data
= NULL
;
86 self
->number_of_replicas
= 0;
88 self
->allocators
= memcached_allocators_return_default();
90 self
->on_clone
= NULL
;
91 self
->on_cleanup
= NULL
;
92 self
->get_key_failure
= NULL
;
93 self
->delete_trigger
= NULL
;
94 self
->callbacks
= NULL
;
95 self
->sasl
.callbacks
= NULL
;
96 self
->sasl
.is_allocated
= false;
98 self
->error_messages
= NULL
;
99 self
->_namespace
= NULL
;
100 self
->configure
.initial_pool_size
= 1;
101 self
->configure
.max_pool_size
= 1;
102 self
->configure
.version
= -1;
103 self
->configure
.filename
= NULL
;
108 static void memcached_free_ex(Memcached
*ptr
, bool release_st
) {
109 /* If we have anything open, lets close it now */
111 memcached_instance_list_free(memcached_instance_list(ptr
), memcached_instance_list_count(ptr
));
112 memcached_result_free(&ptr
->result
);
114 memcached_virtual_bucket_free(ptr
);
116 memcached_instance_free((memcached_instance_st
*) ptr
->last_disconnected_server
);
118 if (ptr
->on_cleanup
) {
119 ptr
->on_cleanup(ptr
);
122 libmemcached_free(ptr
, ptr
->ketama
.continuum
);
123 ptr
->ketama
.continuum
= NULL
;
125 memcached_array_free(ptr
->_namespace
);
126 ptr
->_namespace
= NULL
;
128 memcached_error_free(*ptr
);
130 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and ptr
->sasl
.callbacks
) {
131 memcached_destroy_sasl_auth_data(ptr
);
135 memcached_array_free(ptr
->configure
.filename
);
136 ptr
->configure
.filename
= NULL
;
139 hashkit_free(&ptr
->hashkit
);
141 if (memcached_is_allocated(ptr
) and release_st
) {
142 libmemcached_free(ptr
, ptr
);
146 memcached_st
*memcached_create(memcached_st
*shell
) {
148 shell
->options
.is_allocated
= false;
150 shell
= (memcached_st
*) libmemcached_xmalloc(NULL
, memcached_st
);
153 return NULL
; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
156 shell
->options
.is_allocated
= true;
159 if (_memcached_init(shell
) == false) {
160 memcached_free(shell
);
164 Memcached
*memc
= memcached2Memcached(shell
);
165 if (memcached_result_create(shell
, &memc
->result
) == NULL
) {
166 memcached_free(shell
);
170 WATCHPOINT_ASSERT_INITIALIZED(&memc
->result
);
175 memcached_st
*memcached(const char *string
, size_t length
) {
176 if (length
== 0 and string
) {
180 if (length
and string
== NULL
) {
185 if (bool(getenv("LIBMEMCACHED"))) {
186 string
= getenv("LIBMEMCACHED");
187 length
= string
? strlen(string
) : 0;
191 memcached_st
*memc
= memcached_create(NULL
);
196 if (length
== 0 or string
== NULL
) {
200 memcached_return_t rc
= memcached_parse_configuration(memc
, string
, length
);
201 if (memcached_success(rc
) and memcached_parse_filename(memc
)) {
202 rc
= memcached_parse_configure_file(*memc
, memcached_parse_filename(memc
),
203 memcached_parse_filename_length(memc
));
206 if (memcached_failed(rc
)) {
207 memcached_free(memc
);
214 memcached_return_t
memcached_reset(memcached_st
*shell
) {
215 Memcached
*ptr
= memcached2Memcached(shell
);
216 WATCHPOINT_ASSERT(ptr
);
218 return MEMCACHED_INVALID_ARGUMENTS
;
221 bool stored_is_allocated
= memcached_is_allocated(ptr
);
222 uint64_t query_id
= ptr
->query_id
;
223 memcached_free_ex(ptr
, false);
224 memcached_create(ptr
);
225 memcached_set_allocated(ptr
, stored_is_allocated
);
226 ptr
->query_id
= query_id
;
228 if (ptr
->configure
.filename
) {
229 return memcached_parse_configure_file(*ptr
, memcached_param_array(ptr
->configure
.filename
));
232 return MEMCACHED_SUCCESS
;
235 void memcached_servers_reset(memcached_st
*shell
) {
236 Memcached
*self
= memcached2Memcached(shell
);
238 libmemcached_free(self
, self
->ketama
.continuum
);
239 self
->ketama
.continuum
= NULL
;
240 self
->ketama
.continuum_count
= 0;
241 self
->ketama
.continuum_points_counter
= 0;
243 memcached_instance_list_free(memcached_instance_list(self
), self
->number_of_hosts
);
244 memcached_instance_set(self
, NULL
, 0);
246 memcached_reset_last_disconnected_server(self
);
250 void memcached_reset_last_disconnected_server(memcached_st
*shell
) {
251 Memcached
*self
= memcached2Memcached(shell
);
253 memcached_instance_free((memcached_instance_st
*) self
->last_disconnected_server
);
254 self
->last_disconnected_server
= NULL
;
258 void memcached_free(memcached_st
*ptr
) {
260 memcached_free_ex(ptr
, true);
265 clone is the destination, while source is the structure to clone.
266 If source is NULL the call is the same as if a memcached_create() was
269 memcached_st
*memcached_clone(memcached_st
*clone
, const memcached_st
*source
) {
270 if (source
== NULL
) {
271 return memcached_create(clone
);
274 if (clone
and memcached_is_allocated(clone
)) {
278 memcached_st
*new_clone
= memcached_create(clone
);
280 if (new_clone
== NULL
) {
284 new_clone
->flags
= source
->flags
;
285 new_clone
->send_size
= source
->send_size
;
286 new_clone
->recv_size
= source
->recv_size
;
287 new_clone
->poll_timeout
= source
->poll_timeout
;
288 new_clone
->connect_timeout
= source
->connect_timeout
;
289 new_clone
->retry_timeout
= source
->retry_timeout
;
290 new_clone
->dead_timeout
= source
->dead_timeout
;
291 new_clone
->distribution
= source
->distribution
;
293 if (hashkit_clone(&new_clone
->hashkit
, &source
->hashkit
) == NULL
) {
294 memcached_free(new_clone
);
298 new_clone
->user_data
= source
->user_data
;
300 new_clone
->snd_timeout
= source
->snd_timeout
;
301 new_clone
->rcv_timeout
= source
->rcv_timeout
;
303 new_clone
->on_clone
= source
->on_clone
;
304 new_clone
->on_cleanup
= source
->on_cleanup
;
306 new_clone
->allocators
= source
->allocators
;
308 new_clone
->get_key_failure
= source
->get_key_failure
;
309 new_clone
->delete_trigger
= source
->delete_trigger
;
310 new_clone
->server_failure_limit
= source
->server_failure_limit
;
311 new_clone
->server_timeout_limit
= source
->server_timeout_limit
;
312 new_clone
->io_msg_watermark
= source
->io_msg_watermark
;
313 new_clone
->io_bytes_watermark
= source
->io_bytes_watermark
;
314 new_clone
->io_key_prefetch
= source
->io_key_prefetch
;
315 new_clone
->number_of_replicas
= source
->number_of_replicas
;
316 new_clone
->tcp_keepidle
= source
->tcp_keepidle
;
318 if (memcached_server_count(source
)) {
319 if (memcached_failed(memcached_push(new_clone
, source
))) {
324 new_clone
->_namespace
= memcached_array_clone(new_clone
, source
->_namespace
);
325 new_clone
->configure
.filename
= memcached_array_clone(new_clone
, source
->_namespace
);
326 new_clone
->configure
.version
= source
->configure
.version
;
328 if (LIBMEMCACHED_WITH_SASL_SUPPORT
and source
->sasl
.callbacks
) {
329 if (memcached_failed(memcached_clone_sasl(new_clone
, source
))) {
330 memcached_free(new_clone
);
335 if (memcached_failed(run_distribution(new_clone
))) {
336 memcached_free(new_clone
);
341 if (source
->on_clone
) {
342 source
->on_clone(new_clone
, source
);
348 void *memcached_get_user_data(const memcached_st
*shell
) {
349 const Memcached
*memc
= memcached2Memcached(shell
);
351 return memc
->user_data
;
357 void *memcached_set_user_data(memcached_st
*shell
, void *data
) {
358 Memcached
*memc
= memcached2Memcached(shell
);
360 void *ret
= memc
->user_data
;
361 memc
->user_data
= data
;
369 memcached_return_t
memcached_push(memcached_st
*destination
, const memcached_st
*source
) {
370 return memcached_instance_push(destination
, (memcached_instance_st
*) source
->servers
,
371 source
->number_of_hosts
);
374 memcached_instance_st
*memcached_instance_fetch(Memcached
*ptr
, uint32_t server_key
) {
379 return &ptr
->servers
[server_key
];
382 const memcached_instance_st
*memcached_server_instance_by_position(const memcached_st
*shell
,
383 uint32_t server_key
) {
384 const Memcached
*memc
= memcached2Memcached(shell
);
386 return &memc
->servers
[server_key
];
392 memcached_instance_st
*memcached_instance_by_position(const memcached_st
*shell
,
393 uint32_t server_key
) {
394 const Memcached
*memc
= memcached2Memcached(shell
);
396 return &memc
->servers
[server_key
];
402 uint64_t memcached_query_id(const memcached_st
*shell
) {
403 const Memcached
*memc
= memcached2Memcached(shell
);
405 return memc
->query_id
;
411 memcached_instance_st
*memcached_instance_list(const memcached_st
*shell
) {
412 const Memcached
*memc
= memcached2Memcached(shell
);
414 return (memcached_instance_st
*) memc
->servers
;