Fixed autoconf macros for cross compile
[awesomized/libmemcached] / libmemcached / memcached.c
1 /* LibMemcached
2 * Copyright (C) 2006-2010 Brian Aker
3 * All rights reserved.
4 *
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
7 *
8 * Summary:
9 *
10 */
11
12 #include "common.h"
13
14 static const memcached_st global_copy= {
15 .state= {
16 .is_purging= false,
17 .is_processing_input= false,
18 .is_time_for_rebuild= false,
19 },
20 .flags= {
21 .auto_eject_hosts= false,
22 .binary_protocol= false,
23 .buffer_requests= false,
24 .cork= false,
25 .hash_with_prefix_key= false,
26 .ketama_weighted= false,
27 .no_block= false,
28 .no_reply= false,
29 .randomize_replica_read= false,
30 .reuse_memory= false,
31 .support_cas= false,
32 .tcp_nodelay= false,
33 .use_cache_lookups= false,
34 .use_sort_hosts= false,
35 .use_udp= false,
36 .verify_key= false,
37 .tcp_keepalive= false
38 }
39 };
40
41 static inline bool _memcached_init(memcached_st *self)
42 {
43 self->state= global_copy.state;
44 self->flags= global_copy.flags;
45
46 self->distribution= MEMCACHED_DISTRIBUTION_MODULA;
47
48 hashkit_st *hash_ptr;
49 hash_ptr= hashkit_create(&self->hashkit);
50 if (! hash_ptr)
51 return false;
52
53 self->continuum_points_counter= 0;
54
55 self->number_of_hosts= 0;
56 self->servers= NULL;
57 self->last_disconnected_server= NULL;
58
59 self->snd_timeout= 0;
60 self->rcv_timeout= 0;
61 self->server_failure_limit= 0;
62
63 /* TODO, Document why we picked these defaults */
64 self->io_msg_watermark= 500;
65 self->io_bytes_watermark= 65 * 1024;
66
67 self->tcp_keepidle= 0;
68
69 self->io_key_prefetch= 0;
70 self->cached_errno= 0;
71 self->poll_timeout= MEMCACHED_DEFAULT_TIMEOUT;
72 self->connect_timeout= MEMCACHED_DEFAULT_CONNECT_TIMEOUT;
73 self->retry_timeout= 0;
74 self->continuum_count= 0;
75
76 self->send_size= -1;
77 self->recv_size= -1;
78
79 self->user_data= NULL;
80 self->next_distribution_rebuild= 0;
81 self->prefix_key_length= 0;
82 self->number_of_replicas= 0;
83 hash_ptr= hashkit_create(&self->distribution_hashkit);
84 if (! hash_ptr)
85 return false;
86 self->continuum= NULL;
87
88 self->allocators= memcached_allocators_return_default();
89
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= NULL;
96
97 return true;
98 }
99
100 memcached_st *memcached_create(memcached_st *ptr)
101 {
102 if (ptr == NULL)
103 {
104 ptr= (memcached_st *)malloc(sizeof(memcached_st));
105
106 if (! ptr)
107 {
108 return NULL; /* MEMCACHED_MEMORY_ALLOCATION_FAILURE */
109 }
110
111 ptr->options.is_allocated= true;
112 }
113 else
114 {
115 ptr->options.is_allocated= false;
116 }
117
118 #if 0
119 memcached_set_purging(ptr, false);
120 memcached_set_processing_input(ptr, false);
121 #endif
122
123 if (! _memcached_init(ptr))
124 {
125 memcached_free(ptr);
126 return NULL;
127 }
128
129 if (! memcached_result_create(ptr, &ptr->result))
130 {
131 memcached_free(ptr);
132 return NULL;
133 }
134
135 WATCHPOINT_ASSERT_INITIALIZED(&ptr->result);
136
137 return ptr;
138 }
139
140 void memcached_servers_reset(memcached_st *ptr)
141 {
142 memcached_server_list_free(memcached_server_list(ptr));
143
144 memcached_server_list_set(ptr, NULL);
145 ptr->number_of_hosts= 0;
146 if (ptr->last_disconnected_server)
147 {
148 memcached_server_free(ptr->last_disconnected_server);
149 }
150 ptr->last_disconnected_server= NULL;
151 ptr->server_failure_limit= 0;
152 }
153
154 void memcached_reset_last_disconnected_server(memcached_st *ptr)
155 {
156 if (ptr->last_disconnected_server)
157 {
158 memcached_server_free(ptr->last_disconnected_server);
159 ptr->last_disconnected_server= NULL;
160 }
161 }
162
163 void memcached_free(memcached_st *ptr)
164 {
165 /* If we have anything open, lets close it now */
166 memcached_quit(ptr);
167 memcached_server_list_free(memcached_server_list(ptr));
168 memcached_result_free(&ptr->result);
169
170 if (ptr->last_disconnected_server)
171 memcached_server_free(ptr->last_disconnected_server);
172
173 if (ptr->on_cleanup)
174 ptr->on_cleanup(ptr);
175
176 if (ptr->continuum)
177 libmemcached_free(ptr, ptr->continuum);
178
179 if (ptr->sasl)
180 {
181 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
182 memcached_destroy_sasl_auth_data(ptr);
183 #endif
184 }
185
186 if (memcached_is_allocated(ptr))
187 {
188 libmemcached_free(ptr, ptr);
189 }
190 }
191
192 /*
193 clone is the destination, while source is the structure to clone.
194 If source is NULL the call is the same as if a memcached_create() was
195 called.
196 */
197 memcached_st *memcached_clone(memcached_st *clone, const memcached_st *source)
198 {
199 memcached_return_t rc= MEMCACHED_SUCCESS;
200 memcached_st *new_clone;
201
202 if (source == NULL)
203 return memcached_create(clone);
204
205 if (clone && memcached_is_allocated(clone))
206 {
207 return NULL;
208 }
209
210 new_clone= memcached_create(clone);
211
212 if (new_clone == NULL)
213 return NULL;
214
215 new_clone->flags= source->flags;
216 new_clone->send_size= source->send_size;
217 new_clone->recv_size= source->recv_size;
218 new_clone->poll_timeout= source->poll_timeout;
219 new_clone->connect_timeout= source->connect_timeout;
220 new_clone->retry_timeout= source->retry_timeout;
221 new_clone->distribution= source->distribution;
222
223 hashkit_st *hash_ptr;
224
225 hash_ptr= hashkit_clone(&new_clone->hashkit, &source->hashkit);
226 if (! hash_ptr)
227 {
228 memcached_free(new_clone);
229 return NULL;
230 }
231
232 hash_ptr= hashkit_clone(&new_clone->distribution_hashkit, &source->distribution_hashkit);
233 if (! hash_ptr)
234 {
235 memcached_free(new_clone);
236 return NULL;
237 }
238
239 new_clone->user_data= source->user_data;
240
241 new_clone->snd_timeout= source->snd_timeout;
242 new_clone->rcv_timeout= source->rcv_timeout;
243
244 new_clone->on_clone= source->on_clone;
245 new_clone->on_cleanup= source->on_cleanup;
246
247 new_clone->allocators= source->allocators;
248
249 new_clone->get_key_failure= source->get_key_failure;
250 new_clone->delete_trigger= source->delete_trigger;
251 new_clone->server_failure_limit= source->server_failure_limit;
252 new_clone->io_msg_watermark= source->io_msg_watermark;
253 new_clone->io_bytes_watermark= source->io_bytes_watermark;
254 new_clone->io_key_prefetch= source->io_key_prefetch;
255 new_clone->number_of_replicas= source->number_of_replicas;
256 new_clone->tcp_keepidle= source->tcp_keepidle;
257
258 if (memcached_server_count(source))
259 rc= memcached_push(new_clone, source);
260
261 if (rc != MEMCACHED_SUCCESS)
262 {
263 memcached_free(new_clone);
264
265 return NULL;
266 }
267
268
269 if (source->prefix_key_length)
270 {
271 strcpy(new_clone->prefix_key, source->prefix_key);
272 new_clone->prefix_key_length= source->prefix_key_length;
273 }
274
275 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
276 if (source->sasl && source->sasl->callbacks)
277 {
278 if (memcached_clone_sasl(new_clone, source) != MEMCACHED_SUCCESS)
279 {
280 memcached_free(new_clone);
281 return NULL;
282 }
283 }
284 #endif
285
286 rc= run_distribution(new_clone);
287
288 if (rc != MEMCACHED_SUCCESS)
289 {
290 memcached_free(new_clone);
291
292 return NULL;
293 }
294
295 if (source->on_clone)
296 source->on_clone(new_clone, source);
297
298 return new_clone;
299 }
300
301 void *memcached_get_user_data(const memcached_st *ptr)
302 {
303 return ptr->user_data;
304 }
305
306 void *memcached_set_user_data(memcached_st *ptr, void *data)
307 {
308 void *ret= ptr->user_data;
309 ptr->user_data= data;
310
311 return ret;
312 }
313
314 memcached_return_t memcached_push(memcached_st *destination, const memcached_st *source)
315 {
316 return memcached_server_push(destination, source->servers);
317 }
318
319 memcached_server_write_instance_st memcached_server_instance_fetch(memcached_st *ptr, uint32_t server_key)
320 {
321 return &ptr->servers[server_key];
322 }
323
324 memcached_server_instance_st memcached_server_instance_by_position(const memcached_st *ptr, uint32_t server_key)
325 {
326 return &ptr->servers[server_key];
327 }