93bc140ae2175341c56c446935f5fa4a2420cee3
[m6w6/libmemcached] / libmemcached / memcached_storage.c
1 /*
2 Memcached library
3
4 memcached_set()
5 memcached_replace()
6 memcached_add()
7
8 */
9 #include "common.h"
10 #include "memcached_io.h"
11
12 typedef enum {
13 SET_OP,
14 REPLACE_OP,
15 ADD_OP,
16 PREPEND_OP,
17 APPEND_OP,
18 CAS_OP,
19 } memcached_storage_action;
20
21 /* Inline this */
22 static char *storage_op_string(memcached_storage_action verb)
23 {
24 switch (verb)
25 {
26 case SET_OP:
27 return "set";
28 case REPLACE_OP:
29 return "replace";
30 case ADD_OP:
31 return "add";
32 case PREPEND_OP:
33 return "prepend";
34 case APPEND_OP:
35 return "append";
36 case CAS_OP:
37 return "cas";
38 default:
39 return "tosserror"; /* This is impossible, fixes issue for compiler warning in VisualStudio */
40 };
41
42 return SET_OP;
43 }
44
45 static memcached_return memcached_send_binary(memcached_server_st* server,
46 const char *key,
47 size_t key_length,
48 const char *value,
49 size_t value_length,
50 time_t expiration,
51 uint32_t flags,
52 uint64_t cas,
53 memcached_storage_action verb);
54
55 static inline memcached_return memcached_send(memcached_st *ptr,
56 const char *master_key, size_t master_key_length,
57 const char *key, size_t key_length,
58 const char *value, size_t value_length,
59 time_t expiration,
60 uint32_t flags,
61 uint64_t cas,
62 memcached_storage_action verb)
63 {
64 char to_write;
65 size_t write_length;
66 ssize_t sent_length;
67 memcached_return rc;
68 char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE];
69 unsigned int server_key;
70
71 WATCHPOINT_ASSERT(!(value == NULL && value_length > 0));
72
73 unlikely (key_length == 0)
74 return MEMCACHED_NO_KEY_PROVIDED;
75
76 unlikely (ptr->number_of_hosts == 0)
77 return MEMCACHED_NO_SERVERS;
78
79 if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED))
80 return MEMCACHED_BAD_KEY_PROVIDED;
81
82 server_key= memcached_generate_hash(ptr, master_key, master_key_length);
83
84 if (ptr->flags & MEM_BINARY_PROTOCOL)
85 return memcached_send_binary(&ptr->hosts[server_key], key, key_length,
86 value, value_length, expiration,
87 flags, cas, verb);
88
89 if (cas)
90 write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
91 "%s %s%.*s %u %llu %zu %llu\r\n", storage_op_string(verb),
92 ptr->prefix_key,
93 (int)key_length, key, flags,
94 (unsigned long long)expiration, value_length,
95 (unsigned long long)cas);
96 else
97 write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE,
98 "%s %s%.*s %u %llu %zu\r\n", storage_op_string(verb),
99 ptr->prefix_key,
100 (int)key_length, key, flags,
101 (unsigned long long)expiration, value_length);
102
103 if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE)
104 {
105 rc= MEMCACHED_WRITE_FAILURE;
106 goto error;
107 }
108
109 rc= memcached_do(&ptr->hosts[server_key], buffer, write_length, 0);
110 if (rc != MEMCACHED_SUCCESS)
111 goto error;
112
113 if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1)
114 {
115 rc= MEMCACHED_WRITE_FAILURE;
116 goto error;
117 }
118
119 if ((ptr->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP)
120 to_write= 0;
121 else
122 to_write= 1;
123
124 if ((sent_length= memcached_io_write(&ptr->hosts[server_key], "\r\n", 2, to_write)) == -1)
125 {
126 rc= MEMCACHED_WRITE_FAILURE;
127 goto error;
128 }
129
130 if (to_write == 0)
131 return MEMCACHED_BUFFERED;
132
133 rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL);
134
135 if (rc == MEMCACHED_STORED)
136 return MEMCACHED_SUCCESS;
137 else
138 return rc;
139
140 error:
141 memcached_io_reset(&ptr->hosts[server_key]);
142
143 return rc;
144 }
145
146
147 memcached_return memcached_set(memcached_st *ptr, const char *key, size_t key_length,
148 const char *value, size_t value_length,
149 time_t expiration,
150 uint32_t flags)
151 {
152 memcached_return rc;
153 LIBMEMCACHED_MEMCACHED_SET_START();
154 rc= memcached_send(ptr, key, key_length,
155 key, key_length, value, value_length,
156 expiration, flags, 0, SET_OP);
157 LIBMEMCACHED_MEMCACHED_SET_END();
158 return rc;
159 }
160
161 memcached_return memcached_add(memcached_st *ptr,
162 const char *key, size_t key_length,
163 const char *value, size_t value_length,
164 time_t expiration,
165 uint32_t flags)
166 {
167 memcached_return rc;
168 LIBMEMCACHED_MEMCACHED_ADD_START();
169 rc= memcached_send(ptr, key, key_length,
170 key, key_length, value, value_length,
171 expiration, flags, 0, ADD_OP);
172 LIBMEMCACHED_MEMCACHED_ADD_END();
173 return rc;
174 }
175
176 memcached_return memcached_replace(memcached_st *ptr,
177 const char *key, size_t key_length,
178 const char *value, size_t value_length,
179 time_t expiration,
180 uint32_t flags)
181 {
182 memcached_return rc;
183 LIBMEMCACHED_MEMCACHED_REPLACE_START();
184 rc= memcached_send(ptr, key, key_length,
185 key, key_length, value, value_length,
186 expiration, flags, 0, REPLACE_OP);
187 LIBMEMCACHED_MEMCACHED_REPLACE_END();
188 return rc;
189 }
190
191 memcached_return memcached_prepend(memcached_st *ptr,
192 const char *key, size_t key_length,
193 const char *value, size_t value_length,
194 time_t expiration,
195 uint32_t flags)
196 {
197 memcached_return rc;
198 rc= memcached_send(ptr, key, key_length,
199 key, key_length, value, value_length,
200 expiration, flags, 0, PREPEND_OP);
201 return rc;
202 }
203
204 memcached_return memcached_append(memcached_st *ptr,
205 const char *key, size_t key_length,
206 const char *value, size_t value_length,
207 time_t expiration,
208 uint32_t flags)
209 {
210 memcached_return rc;
211 rc= memcached_send(ptr, key, key_length,
212 key, key_length, value, value_length,
213 expiration, flags, 0, APPEND_OP);
214 return rc;
215 }
216
217 memcached_return memcached_cas(memcached_st *ptr,
218 const char *key, size_t key_length,
219 const char *value, size_t value_length,
220 time_t expiration,
221 uint32_t flags,
222 uint64_t cas)
223 {
224 memcached_return rc;
225 rc= memcached_send(ptr, key, key_length,
226 key, key_length, value, value_length,
227 expiration, flags, cas, CAS_OP);
228 return rc;
229 }
230
231 memcached_return memcached_set_by_key(memcached_st *ptr,
232 const char *master_key __attribute__((unused)),
233 size_t master_key_length __attribute__((unused)),
234 const char *key, size_t key_length,
235 const char *value, size_t value_length,
236 time_t expiration,
237 uint32_t flags)
238 {
239 memcached_return rc;
240 LIBMEMCACHED_MEMCACHED_SET_START();
241 rc= memcached_send(ptr, master_key, master_key_length,
242 key, key_length, value, value_length,
243 expiration, flags, 0, SET_OP);
244 LIBMEMCACHED_MEMCACHED_SET_END();
245 return rc;
246 }
247
248 memcached_return memcached_add_by_key(memcached_st *ptr,
249 const char *master_key, size_t master_key_length,
250 const char *key, size_t key_length,
251 const char *value, size_t value_length,
252 time_t expiration,
253 uint32_t flags)
254 {
255 memcached_return rc;
256 LIBMEMCACHED_MEMCACHED_ADD_START();
257 rc= memcached_send(ptr, master_key, master_key_length,
258 key, key_length, value, value_length,
259 expiration, flags, 0, ADD_OP);
260 LIBMEMCACHED_MEMCACHED_ADD_END();
261 return rc;
262 }
263
264 memcached_return memcached_replace_by_key(memcached_st *ptr,
265 const char *master_key, size_t master_key_length,
266 const char *key, size_t key_length,
267 const char *value, size_t value_length,
268 time_t expiration,
269 uint32_t flags)
270 {
271 memcached_return rc;
272 LIBMEMCACHED_MEMCACHED_REPLACE_START();
273 rc= memcached_send(ptr, master_key, master_key_length,
274 key, key_length, value, value_length,
275 expiration, flags, 0, REPLACE_OP);
276 LIBMEMCACHED_MEMCACHED_REPLACE_END();
277 return rc;
278 }
279
280 memcached_return memcached_prepend_by_key(memcached_st *ptr,
281 const char *master_key, size_t master_key_length,
282 const char *key, size_t key_length,
283 const char *value, size_t value_length,
284 time_t expiration,
285 uint32_t flags)
286 {
287 memcached_return rc;
288 rc= memcached_send(ptr, master_key, master_key_length,
289 key, key_length, value, value_length,
290 expiration, flags, 0, PREPEND_OP);
291 return rc;
292 }
293
294 memcached_return memcached_append_by_key(memcached_st *ptr,
295 const char *master_key, size_t master_key_length,
296 const char *key, size_t key_length,
297 const char *value, size_t value_length,
298 time_t expiration,
299 uint32_t flags)
300 {
301 memcached_return rc;
302 rc= memcached_send(ptr, master_key, master_key_length,
303 key, key_length, value, value_length,
304 expiration, flags, 0, APPEND_OP);
305 return rc;
306 }
307
308 memcached_return memcached_cas_by_key(memcached_st *ptr,
309 const char *master_key, size_t master_key_length,
310 const char *key, size_t key_length,
311 const char *value, size_t value_length,
312 time_t expiration,
313 uint32_t flags,
314 uint64_t cas)
315 {
316 memcached_return rc;
317 rc= memcached_send(ptr, master_key, master_key_length,
318 key, key_length, value, value_length,
319 expiration, flags, cas, CAS_OP);
320 return rc;
321 }
322
323 static memcached_return memcached_send_binary(memcached_server_st* server,
324 const char *key,
325 size_t key_length,
326 const char *value,
327 size_t value_length,
328 time_t expiration,
329 uint32_t flags,
330 uint64_t cas,
331 memcached_storage_action verb)
332 {
333 char flush;
334 protocol_binary_request_set request= {.bytes= {0}};
335 size_t send_length= sizeof(request.bytes);
336
337 request.message.header.request.magic= PROTOCOL_BINARY_REQ;
338 switch (verb)
339 {
340 case SET_OP:
341 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_SET;
342 break;
343 case ADD_OP:
344 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_ADD;
345 break;
346 case REPLACE_OP:
347 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_REPLACE;
348 break;
349 case APPEND_OP:
350 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_APPEND;
351 break;
352 case PREPEND_OP:
353 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_PREPEND;
354 break;
355 case CAS_OP:
356 request.message.header.request.opcode= PROTOCOL_BINARY_CMD_REPLACE;
357 break;
358 }
359
360 request.message.header.request.keylen= htons((uint16_t)key_length);
361 request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES;
362 if (verb == APPEND_OP || verb == PREPEND_OP)
363 send_length -= 8; /* append & prepend does not contain extras! */
364 else
365 {
366 request.message.header.request.extlen= 8;
367 request.message.body.flags= htonl(flags);
368 request.message.body.expiration= htonl((uint32_t)expiration);
369 }
370
371 request.message.header.request.bodylen= htonl(key_length + value_length +
372 request.message.header.request.extlen);
373
374 if (cas)
375 request.message.header.request.cas= htonll(cas);
376
377 flush= ((server->root->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP) ? 0 : 1;
378 /* write the header */
379 if ((memcached_do(server, (const char*)request.bytes, send_length, 0) != MEMCACHED_SUCCESS) ||
380 (memcached_io_write(server, key, key_length, 0) == -1) ||
381 (memcached_io_write(server, value, value_length, flush) == -1))
382 {
383 memcached_io_reset(server);
384 return MEMCACHED_WRITE_FAILURE;
385 }
386
387 if (flush == 0)
388 return MEMCACHED_BUFFERED;
389
390 return memcached_response(server, NULL, 0, NULL);
391 }
392