We now check return key size for memcached_fetch() to make sure it is not
[m6w6/libmemcached] / libmemcached / behavior.c
1 /* LibMemcached
2 * Copyright (C) 2006-2009 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: Change the behavior of the memcached connection.
9 *
10 */
11
12 #include "common.h"
13 #include <time.h>
14 #include <sys/types.h>
15 #include <sys/socket.h>
16 #include <netinet/tcp.h>
17
18 static bool set_flag(uint64_t data)
19 {
20 // Wordy :)
21 return data ? true : false;
22 }
23
24 static memcached_return_t set_hash(memcached_hash_t *store, memcached_hash_t type)
25 {
26 #ifndef HAVE_HSIEH_HASH
27 if (type == MEMCACHED_HASH_HSIEH)
28 return MEMCACHED_FAILURE;
29 #endif
30 if (type < MEMCACHED_HASH_MAX)
31 {
32 *store= type;
33 }
34 else
35 {
36 return MEMCACHED_FAILURE;
37 }
38
39 return MEMCACHED_SUCCESS;
40 }
41 /*
42 This function is used to modify the behavior of running client.
43
44 We quit all connections so we can reset the sockets.
45 */
46
47 memcached_return_t memcached_behavior_set(memcached_st *ptr,
48 const memcached_behavior_t flag,
49 uint64_t data)
50 {
51 switch (flag)
52 {
53 case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
54 ptr->number_of_replicas= (uint32_t)data;
55 break;
56 case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
57 ptr->io_msg_watermark= (uint32_t) data;
58 break;
59 case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
60 ptr->io_bytes_watermark= (uint32_t)data;
61 break;
62 case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
63 ptr->io_key_prefetch = (uint32_t)data;
64 break;
65 case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
66 ptr->snd_timeout= (int32_t)data;
67 break;
68 case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
69 ptr->rcv_timeout= (int32_t)data;
70 break;
71 case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
72 ptr->server_failure_limit= (uint32_t)data;
73 break;
74 case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
75 if (data)
76 {
77 ptr->flags.verify_key= false;
78 }
79 ptr->flags.binary_protocol= set_flag(data);
80 break;
81 case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
82 ptr->flags.support_cas= set_flag(data);
83 break;
84 case MEMCACHED_BEHAVIOR_NO_BLOCK:
85 ptr->flags.no_block= set_flag(data);
86 memcached_quit(ptr);
87 break;
88 case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
89 ptr->flags.buffer_requests= set_flag(data);
90 memcached_quit(ptr);
91 break;
92 case MEMCACHED_BEHAVIOR_USE_UDP:
93 if (memcached_server_count(ptr))
94 {
95 return MEMCACHED_FAILURE;
96 }
97 ptr->flags.use_udp= set_flag(data);
98 if (data)
99 {
100 ptr->flags.no_reply= set_flag(data);
101 }
102 break;
103 case MEMCACHED_BEHAVIOR_TCP_NODELAY:
104 ptr->flags.tcp_nodelay= set_flag(data);
105 memcached_quit(ptr);
106 break;
107 case MEMCACHED_BEHAVIOR_DISTRIBUTION:
108 return memcached_behavior_set_distribution(ptr, (memcached_server_distribution_t)data);
109 case MEMCACHED_BEHAVIOR_KETAMA:
110 {
111 if (data)
112 {
113 (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
114 (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
115 (void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
116 }
117 else
118 {
119 (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_DEFAULT);
120 (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_DEFAULT);
121 (void)memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_MODULA);
122 }
123
124 break;
125 }
126 case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
127 {
128 (void)memcached_behavior_set_key_hash(ptr, MEMCACHED_HASH_MD5);
129 (void)memcached_behavior_set_distribution_hash(ptr, MEMCACHED_HASH_MD5);
130 ptr->flags.ketama_weighted= set_flag(data);
131 /**
132 @note We try to keep the same distribution going. This should be deprecated and rewritten.
133 */
134 return memcached_behavior_set_distribution(ptr, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
135 }
136 case MEMCACHED_BEHAVIOR_HASH:
137 return memcached_behavior_set_key_hash(ptr, (memcached_hash_t)(data));
138 case MEMCACHED_BEHAVIOR_KETAMA_HASH:
139 return memcached_behavior_set_distribution_hash(ptr, (memcached_hash_t)(data));
140 case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
141 ptr->flags.use_cache_lookups= set_flag(data);
142 memcached_quit(ptr);
143 break;
144 case MEMCACHED_BEHAVIOR_VERIFY_KEY:
145 if (ptr->flags.binary_protocol)
146 return MEMCACHED_FAILURE;
147 ptr->flags.verify_key= set_flag(data);
148 break;
149 case MEMCACHED_BEHAVIOR_SORT_HOSTS:
150 {
151 ptr->flags.use_sort_hosts= set_flag(data);
152 run_distribution(ptr);
153
154 break;
155 }
156 case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
157 ptr->poll_timeout= (int32_t)data;
158 break;
159 case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
160 ptr->connect_timeout= (int32_t)data;
161 break;
162 case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
163 ptr->retry_timeout= (int32_t)data;
164 break;
165 case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
166 ptr->send_size= (int32_t)data;
167 memcached_quit(ptr);
168 break;
169 case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
170 ptr->recv_size= (int32_t)data;
171 memcached_quit(ptr);
172 break;
173 case MEMCACHED_BEHAVIOR_USER_DATA:
174 return MEMCACHED_FAILURE;
175 case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
176 ptr->flags.hash_with_prefix_key= set_flag(data);
177 break;
178 case MEMCACHED_BEHAVIOR_NOREPLY:
179 ptr->flags.no_reply= set_flag(data);
180 break;
181 case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
182 ptr->flags.auto_eject_hosts= set_flag(data);
183 break;
184 case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
185 srandom((uint32_t) time(NULL));
186 ptr->flags.randomize_replica_read= set_flag(data);
187 break;
188 case MEMCACHED_BEHAVIOR_CORK:
189 {
190 memcached_server_instance_st *instance;
191 bool action= set_flag(data);
192
193 if (action == false)
194 {
195 ptr->flags.cork= set_flag(false);
196 return MEMCACHED_SUCCESS;
197 }
198
199 instance= memcached_server_instance_fetch(ptr, 0);
200 if (! instance)
201 return MEMCACHED_NO_SERVERS;
202
203
204 /* We just try the first host, and if it is down we return zero */
205 memcached_return_t rc;
206 rc= memcached_connect(instance);
207 if (rc != MEMCACHED_SUCCESS)
208 {
209 return rc;
210 }
211
212 /* Now we test! */
213 memcached_ternary_t enabled;
214 enabled= test_cork(instance, true);
215
216 switch (enabled)
217 {
218 case MEM_FALSE:
219 return ptr->cached_errno ? MEMCACHED_ERRNO : MEMCACHED_FAILURE ;
220 case MEM_TRUE:
221 {
222 enabled= test_cork(instance, false);
223
224 if (enabled == false) // Possible bug in OS?
225 {
226 memcached_quit_server(instance, false); // We should reset everything on this error.
227 return MEMCACHED_ERRNO; // Errno will be true because we will have already set it.
228 }
229 ptr->flags.cork= true;
230 ptr->flags.tcp_nodelay= true;
231 memcached_quit(ptr); // We go on and reset the connections.
232 }
233 break;
234 case MEM_NOT:
235 default:
236 return MEMCACHED_NOT_SUPPORTED;
237 }
238 }
239 break;
240 case MEMCACHED_BEHAVIOR_MAX:
241 default:
242 /* Shouldn't get here */
243 WATCHPOINT_ASSERT(0);
244 return MEMCACHED_FAILURE;
245 }
246
247 return MEMCACHED_SUCCESS;
248 }
249
250 uint64_t memcached_behavior_get(memcached_st *ptr,
251 const memcached_behavior_t flag)
252 {
253 switch (flag)
254 {
255 case MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS:
256 return ptr->number_of_replicas;
257 case MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK:
258 return ptr->io_msg_watermark;
259 case MEMCACHED_BEHAVIOR_IO_BYTES_WATERMARK:
260 return ptr->io_bytes_watermark;
261 case MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH:
262 return ptr->io_key_prefetch;
263 case MEMCACHED_BEHAVIOR_BINARY_PROTOCOL:
264 return ptr->flags.binary_protocol;
265 case MEMCACHED_BEHAVIOR_SUPPORT_CAS:
266 return ptr->flags.support_cas;
267 case MEMCACHED_BEHAVIOR_CACHE_LOOKUPS:
268 return ptr->flags.use_cache_lookups;
269 case MEMCACHED_BEHAVIOR_NO_BLOCK:
270 return ptr->flags.no_block;
271 case MEMCACHED_BEHAVIOR_BUFFER_REQUESTS:
272 return ptr->flags.buffer_requests;
273 case MEMCACHED_BEHAVIOR_USE_UDP:
274 return ptr->flags.use_udp;
275 case MEMCACHED_BEHAVIOR_TCP_NODELAY:
276 return ptr->flags.tcp_nodelay;
277 case MEMCACHED_BEHAVIOR_VERIFY_KEY:
278 return ptr->flags.verify_key;
279 case MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED:
280 return ptr->flags.ketama_weighted;
281 case MEMCACHED_BEHAVIOR_DISTRIBUTION:
282 return ptr->distribution;
283 case MEMCACHED_BEHAVIOR_KETAMA:
284 return (ptr->distribution == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) ? (uint64_t) 1 : 0;
285 case MEMCACHED_BEHAVIOR_HASH:
286 return ptr->hash;
287 case MEMCACHED_BEHAVIOR_KETAMA_HASH:
288 return ptr->distribution_hash;
289 case MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT:
290 return ptr->server_failure_limit;
291 case MEMCACHED_BEHAVIOR_SORT_HOSTS:
292 return ptr->flags.use_sort_hosts;
293 case MEMCACHED_BEHAVIOR_POLL_TIMEOUT:
294 return (uint64_t)ptr->poll_timeout;
295 case MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT:
296 return (uint64_t)ptr->connect_timeout;
297 case MEMCACHED_BEHAVIOR_RETRY_TIMEOUT:
298 return (uint64_t)ptr->retry_timeout;
299 case MEMCACHED_BEHAVIOR_SND_TIMEOUT:
300 return (uint64_t)ptr->snd_timeout;
301 case MEMCACHED_BEHAVIOR_RCV_TIMEOUT:
302 return (uint64_t)ptr->rcv_timeout;
303 case MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE:
304 {
305 int sock_size= 0;
306 socklen_t sock_length= sizeof(int);
307 memcached_server_instance_st *instance;
308
309 if (ptr->send_size != -1) // If value is -1 then we are using the default
310 return (uint64_t) ptr->send_size;
311
312 instance= memcached_server_instance_fetch(ptr, 0);
313
314 if (instance) // If we have an instance we test, otherwise we just set and pray
315 {
316 /* REFACTOR */
317 /* We just try the first host, and if it is down we return zero */
318 if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
319 return 0;
320
321 if (getsockopt(instance->fd, SOL_SOCKET,
322 SO_SNDBUF, &sock_size, &sock_length))
323 return 0; /* Zero means error */
324 }
325
326 return (uint64_t) sock_size;
327 }
328 case MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE:
329 {
330 int sock_size= 0;
331 socklen_t sock_length= sizeof(int);
332 memcached_server_instance_st *instance;
333
334 if (ptr->recv_size != -1) // If value is -1 then we are using the default
335 return (uint64_t) ptr->recv_size;
336
337 instance= memcached_server_instance_fetch(ptr, 0);
338
339 /**
340 @note REFACTOR
341 */
342 if (instance)
343 {
344 /* We just try the first host, and if it is down we return zero */
345 if ((memcached_connect(instance)) != MEMCACHED_SUCCESS)
346 return 0;
347
348 if (getsockopt(instance->fd, SOL_SOCKET,
349 SO_RCVBUF, &sock_size, &sock_length))
350 return 0; /* Zero means error */
351
352 }
353
354 return (uint64_t) sock_size;
355 }
356 case MEMCACHED_BEHAVIOR_USER_DATA:
357 return MEMCACHED_FAILURE;
358 case MEMCACHED_BEHAVIOR_HASH_WITH_PREFIX_KEY:
359 return ptr->flags.hash_with_prefix_key;
360 case MEMCACHED_BEHAVIOR_NOREPLY:
361 return ptr->flags.no_reply;
362 case MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS:
363 return ptr->flags.auto_eject_hosts;
364 case MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ:
365 return ptr->flags.randomize_replica_read;
366 case MEMCACHED_BEHAVIOR_CORK:
367 return ptr->flags.cork;
368 case MEMCACHED_BEHAVIOR_MAX:
369 default:
370 WATCHPOINT_ASSERT(0); /* Programming mistake if it gets this far */
371 return 0;
372 }
373
374 /* NOTREACHED */
375 }
376
377
378 memcached_return_t memcached_behavior_set_distribution(memcached_st *ptr, memcached_server_distribution_t type)
379 {
380 if (type < MEMCACHED_DISTRIBUTION_CONSISTENT_MAX)
381 {
382 ptr->distribution= type;
383 run_distribution(ptr);
384 }
385 else
386 {
387 return MEMCACHED_FAILURE;
388 }
389
390 return MEMCACHED_SUCCESS;
391 }
392
393
394 memcached_server_distribution_t memcached_behavior_get_distribution(memcached_st *ptr)
395 {
396 return ptr->distribution;
397 }
398
399 memcached_return_t memcached_behavior_set_key_hash(memcached_st *ptr, memcached_hash_t type)
400 {
401 return set_hash(&ptr->hash, type);
402 }
403
404 memcached_hash_t memcached_behavior_get_key_hash(memcached_st *ptr)
405 {
406 return ptr->hash;
407 }
408
409 memcached_return_t memcached_behavior_set_distribution_hash(memcached_st *ptr, memcached_hash_t type)
410 {
411 return set_hash(&ptr->distribution_hash, type);
412 }
413
414 memcached_hash_t memcached_behavior_get_distribution_hash(memcached_st *ptr)
415 {
416 return ptr->distribution_hash;
417 }