Fix conversion from macro to inline.
[m6w6/libmemcached] / libmemcached / auto.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: Methods for adding or decrementing values from an object in memcached
9 *
10 */
11
12 #include "common.h"
13
14 static memcached_return_t memcached_auto(memcached_st *ptr,
15 const char *verb,
16 const char *master_key, size_t master_key_length,
17 const char *key, size_t key_length,
18 uint64_t offset,
19 uint64_t *value)
20 {
21 size_t send_length;
22 memcached_return_t rc;
23 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
24 uint32_t server_key;
25 memcached_server_instance_st *instance;
26 bool no_reply= ptr->flags.no_reply;
27
28 unlikely (memcached_server_count(ptr) == 0)
29 return MEMCACHED_NO_SERVERS;
30
31 if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
32 return MEMCACHED_BAD_KEY_PROVIDED;
33
34 server_key= memcached_generate_hash(ptr, master_key, master_key_length);
35 instance= memcached_server_instance_fetch(ptr, server_key);
36
37 send_length= (size_t)snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
38 "%s %.*s%.*s %" PRIu64 "%s\r\n", verb,
39 (int)ptr->prefix_key_length,
40 ptr->prefix_key,
41 (int)key_length, key,
42 offset, no_reply ? " noreply" : "");
43 unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
44 return MEMCACHED_WRITE_FAILURE;
45
46 rc= memcached_do(instance, buffer, send_length, 1);
47 if (no_reply || rc != MEMCACHED_SUCCESS)
48 return rc;
49
50 rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
51
52 /*
53 So why recheck responce? Because the protocol is brain dead :)
54 The number returned might end up equaling one of the string
55 values. Less chance of a mistake with strncmp() so we will
56 use it. We still called memcached_response() though since it
57 worked its magic for non-blocking IO.
58 */
59 if (!strncmp(buffer, "ERROR\r\n", 7))
60 {
61 *value= 0;
62 rc= MEMCACHED_PROTOCOL_ERROR;
63 }
64 else if (!strncmp(buffer, "NOT_FOUND\r\n", 11))
65 {
66 *value= 0;
67 rc= MEMCACHED_NOTFOUND;
68 }
69 else
70 {
71 *value= strtoull(buffer, (char **)NULL, 10);
72 rc= MEMCACHED_SUCCESS;
73 }
74
75 return rc;
76 }
77
78 static memcached_return_t binary_incr_decr(memcached_st *ptr, uint8_t cmd,
79 const char *master_key, size_t master_key_length,
80 const char *key, size_t key_length,
81 uint64_t offset, uint64_t initial,
82 uint32_t expiration,
83 uint64_t *value)
84 {
85 uint32_t server_key;
86 memcached_server_instance_st *instance;
87 bool no_reply= ptr->flags.no_reply;
88
89 unlikely (memcached_server_count(ptr) == 0)
90 return MEMCACHED_NO_SERVERS;
91
92 server_key= memcached_generate_hash(ptr, master_key, master_key_length);
93 instance= memcached_server_instance_fetch(ptr, server_key);
94
95 if (no_reply)
96 {
97 if(cmd == PROTOCOL_BINARY_CMD_DECREMENT)
98 cmd= PROTOCOL_BINARY_CMD_DECREMENTQ;
99 if(cmd == PROTOCOL_BINARY_CMD_INCREMENT)
100 cmd= PROTOCOL_BINARY_CMD_INCREMENTQ;
101 }
102 protocol_binary_request_incr request= {.bytes= {0}};
103
104 request.message.header.request.magic= PROTOCOL_BINARY_REQ;
105 request.message.header.request.opcode= cmd;
106 request.message.header.request.keylen= htons((uint16_t) key_length);
107 request.message.header.request.extlen= 20;
108 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
109 request.message.header.request.bodylen= htonl((uint32_t) (key_length + request.message.header.request.extlen));
110 request.message.body.delta= htonll(offset);
111 request.message.body.initial= htonll(initial);
112 request.message.body.expiration= htonl((uint32_t) expiration);
113
114 if ((memcached_do(instance, request.bytes,
115 sizeof(request.bytes), 0)!=MEMCACHED_SUCCESS) ||
116 (memcached_io_write(instance, key, key_length, 1) == -1))
117 {
118 memcached_io_reset(instance);
119 return MEMCACHED_WRITE_FAILURE;
120 }
121
122 if (no_reply)
123 return MEMCACHED_SUCCESS;
124 return memcached_response(instance, (char*)value, sizeof(*value), NULL);
125 }
126
127 memcached_return_t memcached_increment(memcached_st *ptr,
128 const char *key, size_t key_length,
129 uint32_t offset,
130 uint64_t *value)
131 {
132 return memcached_increment_by_key(ptr, key, key_length, key, key_length, offset, value);
133 }
134
135 memcached_return_t memcached_decrement(memcached_st *ptr,
136 const char *key, size_t key_length,
137 uint32_t offset,
138 uint64_t *value)
139 {
140 return memcached_decrement_by_key(ptr, key, key_length, key, key_length, offset, value);
141 }
142
143 memcached_return_t memcached_increment_by_key(memcached_st *ptr,
144 const char *master_key, size_t master_key_length,
145 const char *key, size_t key_length,
146 uint64_t offset,
147 uint64_t *value)
148 {
149 memcached_return_t rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol);
150 unlikely (rc != MEMCACHED_SUCCESS)
151 return rc;
152
153 LIBMEMCACHED_MEMCACHED_INCREMENT_START();
154 if (ptr->flags.binary_protocol)
155 {
156 rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT,
157 master_key, master_key_length, key, key_length,
158 (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD,
159 value);
160 }
161 else
162 {
163 rc= memcached_auto(ptr, "incr", master_key, master_key_length, key, key_length, offset, value);
164 }
165
166 LIBMEMCACHED_MEMCACHED_INCREMENT_END();
167
168 return rc;
169 }
170
171 memcached_return_t memcached_decrement_by_key(memcached_st *ptr,
172 const char *master_key, size_t master_key_length,
173 const char *key, size_t key_length,
174 uint64_t offset,
175 uint64_t *value)
176 {
177 memcached_return_t rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol);
178 unlikely (rc != MEMCACHED_SUCCESS)
179 return rc;
180
181 LIBMEMCACHED_MEMCACHED_DECREMENT_START();
182 if (ptr->flags.binary_protocol)
183 rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT,
184 master_key, master_key_length, key, key_length,
185 (uint64_t)offset, 0, MEMCACHED_EXPIRATION_NOT_ADD,
186 value);
187 else
188 rc= memcached_auto(ptr, "decr", master_key, master_key_length, key, key_length, offset, value);
189
190 LIBMEMCACHED_MEMCACHED_DECREMENT_END();
191
192 return rc;
193 }
194
195 memcached_return_t memcached_increment_with_initial(memcached_st *ptr,
196 const char *key,
197 size_t key_length,
198 uint64_t offset,
199 uint64_t initial,
200 time_t expiration,
201 uint64_t *value)
202 {
203 return memcached_increment_with_initial_by_key(ptr, key, key_length,
204 key, key_length,
205 offset, initial, expiration, value);
206 }
207
208 memcached_return_t memcached_increment_with_initial_by_key(memcached_st *ptr,
209 const char *master_key,
210 size_t master_key_length,
211 const char *key,
212 size_t key_length,
213 uint64_t offset,
214 uint64_t initial,
215 time_t expiration,
216 uint64_t *value)
217 {
218 memcached_return_t rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol);
219 unlikely (rc != MEMCACHED_SUCCESS)
220 return rc;
221
222 LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START();
223 if (ptr->flags.binary_protocol)
224 rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_INCREMENT,
225 master_key, master_key_length, key, key_length,
226 offset, initial, (uint32_t)expiration,
227 value);
228 else
229 rc= MEMCACHED_PROTOCOL_ERROR;
230
231 LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END();
232
233 return rc;
234 }
235
236 memcached_return_t memcached_decrement_with_initial(memcached_st *ptr,
237 const char *key,
238 size_t key_length,
239 uint64_t offset,
240 uint64_t initial,
241 time_t expiration,
242 uint64_t *value)
243 {
244 return memcached_decrement_with_initial_by_key(ptr, key, key_length,
245 key, key_length,
246 offset, initial, expiration, value);
247 }
248
249 memcached_return_t memcached_decrement_with_initial_by_key(memcached_st *ptr,
250 const char *master_key,
251 size_t master_key_length,
252 const char *key,
253 size_t key_length,
254 uint64_t offset,
255 uint64_t initial,
256 time_t expiration,
257 uint64_t *value)
258 {
259 memcached_return_t rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol);
260 unlikely (rc != MEMCACHED_SUCCESS)
261 return rc;
262
263 LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_START();
264 if (ptr->flags.binary_protocol)
265 {
266 rc= binary_incr_decr(ptr, PROTOCOL_BINARY_CMD_DECREMENT,
267 master_key, master_key_length, key, key_length,
268 offset, initial, (uint32_t)expiration,
269 value);
270 }
271 else
272 {
273 rc= MEMCACHED_PROTOCOL_ERROR;
274 }
275
276 LIBMEMCACHED_MEMCACHED_INCREMENT_WITH_INITIAL_END();
277
278 return rc;
279 }
280