2 * Copyright (C) 2006-2009 Brian Aker
5 * Use and distribution licensed under the BSD license. See
6 * the COPYING file in the parent directory for full text.
8 * Summary: Storage related functions, aka set, replace,..
21 } memcached_storage_action_t
;
24 static inline const char *storage_op_string(memcached_storage_action_t verb
)
41 return "tosserror"; /* This is impossible, fixes issue for compiler warning in VisualStudio */
47 static memcached_return_t
memcached_send_binary(memcached_st
*ptr
,
48 const char *master_key
,
49 size_t master_key_length
,
57 memcached_storage_action_t verb
);
59 static inline memcached_return_t
memcached_send(memcached_st
*ptr
,
60 const char *master_key
, size_t master_key_length
,
61 const char *key
, size_t key_length
,
62 const char *value
, size_t value_length
,
66 memcached_storage_action_t verb
)
70 memcached_return_t rc
;
71 char buffer
[MEMCACHED_DEFAULT_COMMAND_SIZE
];
73 memcached_server_write_instance_st instance
;
75 WATCHPOINT_ASSERT(!(value
== NULL
&& value_length
> 0));
77 rc
= memcached_validate_key_length(key_length
, ptr
->flags
.binary_protocol
);
78 unlikely (rc
!= MEMCACHED_SUCCESS
)
81 unlikely (memcached_server_count(ptr
) == 0)
82 return MEMCACHED_NO_SERVERS
;
84 if (ptr
->flags
.verify_key
&& (memcached_key_test((const char **)&key
, &key_length
, 1) == MEMCACHED_BAD_KEY_PROVIDED
))
85 return MEMCACHED_BAD_KEY_PROVIDED
;
87 if (ptr
->flags
.binary_protocol
)
89 return memcached_send_binary(ptr
, master_key
, master_key_length
,
91 value
, value_length
, expiration
,
95 server_key
= memcached_generate_hash_with_redistribution(ptr
, master_key
, master_key_length
);
96 instance
= memcached_server_instance_fetch(ptr
, server_key
);
100 write_length
= (size_t) snprintf(buffer
, MEMCACHED_DEFAULT_COMMAND_SIZE
,
101 "%s %.*s%.*s %u %llu %zu %llu%s\r\n",
102 storage_op_string(verb
),
103 (int)ptr
->prefix_key_length
,
105 (int)key_length
, key
, flags
,
106 (unsigned long long)expiration
, value_length
,
107 (unsigned long long)cas
,
108 (ptr
->flags
.no_reply
) ? " noreply" : "");
112 char *buffer_ptr
= buffer
;
113 const char *command
= storage_op_string(verb
);
115 /* Copy in the command, no space needed, we handle that in the command function*/
116 memcpy(buffer_ptr
, command
, strlen(command
));
118 /* Copy in the key prefix, switch to the buffer_ptr */
119 buffer_ptr
= memcpy((buffer_ptr
+ strlen(command
)), ptr
->prefix_key
, ptr
->prefix_key_length
);
121 /* Copy in the key, adjust point if a key prefix was used. */
122 buffer_ptr
= memcpy(buffer_ptr
+ (ptr
->prefix_key_length
? ptr
->prefix_key_length
: 0),
124 buffer_ptr
+= key_length
;
128 write_length
= (size_t)(buffer_ptr
- buffer
);
129 write_length
+= (size_t) snprintf(buffer_ptr
, MEMCACHED_DEFAULT_COMMAND_SIZE
,
132 (unsigned long long)expiration
, value_length
,
133 ptr
->flags
.no_reply
? " noreply" : "");
136 if (ptr
->flags
.use_udp
&& ptr
->flags
.buffer_requests
)
138 size_t cmd_size
= write_length
+ value_length
+ 2;
139 if (cmd_size
> MAX_UDP_DATAGRAM_LENGTH
- UDP_DATAGRAM_HEADER_LENGTH
)
140 return MEMCACHED_WRITE_FAILURE
;
141 if (cmd_size
+ instance
->write_buffer_offset
> MAX_UDP_DATAGRAM_LENGTH
)
142 memcached_io_write(instance
, NULL
, 0, true);
145 if (write_length
>= MEMCACHED_DEFAULT_COMMAND_SIZE
)
147 rc
= MEMCACHED_WRITE_FAILURE
;
151 /* Send command header */
152 rc
= memcached_do(instance
, buffer
, write_length
, false);
153 if (rc
!= MEMCACHED_SUCCESS
)
156 if (ptr
->flags
.buffer_requests
&& verb
== SET_OP
)
165 struct __write_vector_st vector
[]=
167 { .length
= value_length
, .buffer
= value
},
168 { .length
= 2, .buffer
= "\r\n" }
171 if (memcached_io_writev(instance
, vector
, 2, to_write
) == -1)
173 rc
= MEMCACHED_WRITE_FAILURE
;
177 if (ptr
->flags
.no_reply
)
178 return (to_write
== false) ? MEMCACHED_BUFFERED
: MEMCACHED_SUCCESS
;
180 if (to_write
== false)
181 return MEMCACHED_BUFFERED
;
183 rc
= memcached_response(instance
, buffer
, MEMCACHED_DEFAULT_COMMAND_SIZE
, NULL
);
185 if (rc
== MEMCACHED_STORED
)
186 return MEMCACHED_SUCCESS
;
191 memcached_io_reset(instance
);
197 memcached_return_t
memcached_set(memcached_st
*ptr
, const char *key
, size_t key_length
,
198 const char *value
, size_t value_length
,
202 memcached_return_t rc
;
203 LIBMEMCACHED_MEMCACHED_SET_START();
204 rc
= memcached_send(ptr
, key
, key_length
,
205 key
, key_length
, value
, value_length
,
206 expiration
, flags
, 0, SET_OP
);
207 LIBMEMCACHED_MEMCACHED_SET_END();
211 memcached_return_t
memcached_add(memcached_st
*ptr
,
212 const char *key
, size_t key_length
,
213 const char *value
, size_t value_length
,
217 memcached_return_t rc
;
218 LIBMEMCACHED_MEMCACHED_ADD_START();
219 rc
= memcached_send(ptr
, key
, key_length
,
220 key
, key_length
, value
, value_length
,
221 expiration
, flags
, 0, ADD_OP
);
222 LIBMEMCACHED_MEMCACHED_ADD_END();
226 memcached_return_t
memcached_replace(memcached_st
*ptr
,
227 const char *key
, size_t key_length
,
228 const char *value
, size_t value_length
,
232 memcached_return_t rc
;
233 LIBMEMCACHED_MEMCACHED_REPLACE_START();
234 rc
= memcached_send(ptr
, key
, key_length
,
235 key
, key_length
, value
, value_length
,
236 expiration
, flags
, 0, REPLACE_OP
);
237 LIBMEMCACHED_MEMCACHED_REPLACE_END();
241 memcached_return_t
memcached_prepend(memcached_st
*ptr
,
242 const char *key
, size_t key_length
,
243 const char *value
, size_t value_length
,
247 memcached_return_t rc
;
248 rc
= memcached_send(ptr
, key
, key_length
,
249 key
, key_length
, value
, value_length
,
250 expiration
, flags
, 0, PREPEND_OP
);
254 memcached_return_t
memcached_append(memcached_st
*ptr
,
255 const char *key
, size_t key_length
,
256 const char *value
, size_t value_length
,
260 memcached_return_t rc
;
261 rc
= memcached_send(ptr
, key
, key_length
,
262 key
, key_length
, value
, value_length
,
263 expiration
, flags
, 0, APPEND_OP
);
267 memcached_return_t
memcached_cas(memcached_st
*ptr
,
268 const char *key
, size_t key_length
,
269 const char *value
, size_t value_length
,
274 memcached_return_t rc
;
275 rc
= memcached_send(ptr
, key
, key_length
,
276 key
, key_length
, value
, value_length
,
277 expiration
, flags
, cas
, CAS_OP
);
281 memcached_return_t
memcached_set_by_key(memcached_st
*ptr
,
282 const char *master_key
__attribute__((unused
)),
283 size_t master_key_length
__attribute__((unused
)),
284 const char *key
, size_t key_length
,
285 const char *value
, size_t value_length
,
289 memcached_return_t rc
;
290 LIBMEMCACHED_MEMCACHED_SET_START();
291 rc
= memcached_send(ptr
, master_key
, master_key_length
,
292 key
, key_length
, value
, value_length
,
293 expiration
, flags
, 0, SET_OP
);
294 LIBMEMCACHED_MEMCACHED_SET_END();
298 memcached_return_t
memcached_add_by_key(memcached_st
*ptr
,
299 const char *master_key
, size_t master_key_length
,
300 const char *key
, size_t key_length
,
301 const char *value
, size_t value_length
,
305 memcached_return_t rc
;
306 LIBMEMCACHED_MEMCACHED_ADD_START();
307 rc
= memcached_send(ptr
, master_key
, master_key_length
,
308 key
, key_length
, value
, value_length
,
309 expiration
, flags
, 0, ADD_OP
);
310 LIBMEMCACHED_MEMCACHED_ADD_END();
314 memcached_return_t
memcached_replace_by_key(memcached_st
*ptr
,
315 const char *master_key
, size_t master_key_length
,
316 const char *key
, size_t key_length
,
317 const char *value
, size_t value_length
,
321 memcached_return_t rc
;
322 LIBMEMCACHED_MEMCACHED_REPLACE_START();
323 rc
= memcached_send(ptr
, master_key
, master_key_length
,
324 key
, key_length
, value
, value_length
,
325 expiration
, flags
, 0, REPLACE_OP
);
326 LIBMEMCACHED_MEMCACHED_REPLACE_END();
330 memcached_return_t
memcached_prepend_by_key(memcached_st
*ptr
,
331 const char *master_key
, size_t master_key_length
,
332 const char *key
, size_t key_length
,
333 const char *value
, size_t value_length
,
337 memcached_return_t rc
;
338 rc
= memcached_send(ptr
, master_key
, master_key_length
,
339 key
, key_length
, value
, value_length
,
340 expiration
, flags
, 0, PREPEND_OP
);
344 memcached_return_t
memcached_append_by_key(memcached_st
*ptr
,
345 const char *master_key
, size_t master_key_length
,
346 const char *key
, size_t key_length
,
347 const char *value
, size_t value_length
,
351 memcached_return_t rc
;
352 rc
= memcached_send(ptr
, master_key
, master_key_length
,
353 key
, key_length
, value
, value_length
,
354 expiration
, flags
, 0, APPEND_OP
);
358 memcached_return_t
memcached_cas_by_key(memcached_st
*ptr
,
359 const char *master_key
, size_t master_key_length
,
360 const char *key
, size_t key_length
,
361 const char *value
, size_t value_length
,
366 memcached_return_t rc
;
367 rc
= memcached_send(ptr
, master_key
, master_key_length
,
368 key
, key_length
, value
, value_length
,
369 expiration
, flags
, cas
, CAS_OP
);
373 static inline uint8_t get_com_code(memcached_storage_action_t verb
, bool noreply
)
375 /* 0 isn't a value we want, but GCC 4.2 seems to think ret can otherwise
376 * be used uninitialized in this function. FAIL */
383 ret
=PROTOCOL_BINARY_CMD_SETQ
;
386 ret
=PROTOCOL_BINARY_CMD_ADDQ
;
388 case CAS_OP
: /* FALLTHROUGH */
390 ret
=PROTOCOL_BINARY_CMD_REPLACEQ
;
393 ret
=PROTOCOL_BINARY_CMD_APPENDQ
;
396 ret
=PROTOCOL_BINARY_CMD_PREPENDQ
;
399 WATCHPOINT_ASSERT(verb
);
406 ret
=PROTOCOL_BINARY_CMD_SET
;
409 ret
=PROTOCOL_BINARY_CMD_ADD
;
411 case CAS_OP
: /* FALLTHROUGH */
413 ret
=PROTOCOL_BINARY_CMD_REPLACE
;
416 ret
=PROTOCOL_BINARY_CMD_APPEND
;
419 ret
=PROTOCOL_BINARY_CMD_PREPEND
;
422 WATCHPOINT_ASSERT(verb
);
431 static memcached_return_t
memcached_send_binary(memcached_st
*ptr
,
432 const char *master_key
,
433 size_t master_key_length
,
441 memcached_storage_action_t verb
)
444 protocol_binary_request_set request
= {.bytes
= {0}};
445 size_t send_length
= sizeof(request
.bytes
);
446 uint32_t server_key
= memcached_generate_hash_with_redistribution(ptr
, master_key
,
449 memcached_server_write_instance_st server
=
450 memcached_server_instance_fetch(ptr
, server_key
);
452 bool noreply
= server
->root
->flags
.no_reply
;
454 request
.message
.header
.request
.magic
= PROTOCOL_BINARY_REQ
;
455 request
.message
.header
.request
.opcode
= get_com_code(verb
, noreply
);
456 request
.message
.header
.request
.keylen
= htons((uint16_t)(key_length
+ ptr
->prefix_key_length
));
457 request
.message
.header
.request
.datatype
= PROTOCOL_BINARY_RAW_BYTES
;
458 if (verb
== APPEND_OP
|| verb
== PREPEND_OP
)
459 send_length
-= 8; /* append & prepend does not contain extras! */
462 request
.message
.header
.request
.extlen
= 8;
463 request
.message
.body
.flags
= htonl(flags
);
464 request
.message
.body
.expiration
= htonl((uint32_t)expiration
);
467 request
.message
.header
.request
.bodylen
= htonl((uint32_t) (key_length
+ ptr
->prefix_key_length
+ value_length
+
468 request
.message
.header
.request
.extlen
));
471 request
.message
.header
.request
.cas
= htonll(cas
);
473 flush
= (bool) ((server
->root
->flags
.buffer_requests
&& verb
== SET_OP
) ? 0 : 1);
475 if (server
->root
->flags
.use_udp
&& ! flush
)
477 size_t cmd_size
= send_length
+ key_length
+ value_length
;
479 if (cmd_size
> MAX_UDP_DATAGRAM_LENGTH
- UDP_DATAGRAM_HEADER_LENGTH
)
481 return MEMCACHED_WRITE_FAILURE
;
483 if (cmd_size
+ server
->write_buffer_offset
> MAX_UDP_DATAGRAM_LENGTH
)
485 memcached_io_write(server
, NULL
, 0, true);
489 struct __write_vector_st vector
[]=
491 { .length
= ptr
->prefix_key_length
, .buffer
= ptr
->prefix_key
},
492 { .length
= key_length
, .buffer
= key
},
493 { .length
= value_length
, .buffer
= value
}
496 /* write the header */
497 memcached_return_t rc
;
498 if (((rc
= memcached_do(server
, (const char*)request
.bytes
, send_length
, false)) != MEMCACHED_SUCCESS
) ||
499 (memcached_io_writev(server
, vector
, 3, flush
) == -1))
501 memcached_io_reset(server
);
502 return (rc
== MEMCACHED_SUCCESS
) ? MEMCACHED_WRITE_FAILURE
: rc
;
505 unlikely (verb
== SET_OP
&& ptr
->number_of_replicas
> 0)
507 request
.message
.header
.request
.opcode
= PROTOCOL_BINARY_CMD_SETQ
;
509 for (uint32_t x
= 0; x
< ptr
->number_of_replicas
; x
++)
511 memcached_server_write_instance_st instance
;
514 if (server_key
== memcached_server_count(ptr
))
517 instance
= memcached_server_instance_fetch(ptr
, server_key
);
519 if ((memcached_do(instance
, (const char*)request
.bytes
, send_length
, false) != MEMCACHED_SUCCESS
) ||
520 (memcached_io_writev(instance
, vector
, 3, flush
) == -1))
522 memcached_io_reset(instance
);
526 memcached_server_response_decrement(instance
);
533 return MEMCACHED_BUFFERED
;
538 return MEMCACHED_SUCCESS
;
541 return memcached_response(server
, NULL
, 0, NULL
);