static test_return_t udp_delete_test(memcached_st *memc) { unsigned int num_iters= 1025; //request id rolls over at 1024 for (size_t x= 0; x < num_iters; x++) { memcached_return_t rc; const char *key= "foo"; uint16_t *expected_ids=get_udp_request_ids(memc); unsigned int server_key= memcached_generate_hash(memc, key, strlen(key)); memcached_server_instance_st instance= memcached_server_instance_by_position(memc, server_key); size_t init_offset= instance->write_buffer_offset; rc= memcached_delete(memc, key, strlen(key), 0); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); if (rc == MEMCACHED_SUCCESS || instance->write_buffer_offset < init_offset) increment_request_id(&expected_ids[server_key]); if (rc == MEMCACHED_SUCCESS) { test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH); } else { test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH); test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH); } test_true(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS); } return TEST_SUCCESS; }
static memcached_return binary_incr_decr(memcached_st *ptr, uint8_t cmd, const char *key, size_t key_length, uint32_t offset, uint64_t *value) { unsigned int server_key; #ifndef _MSC_VER protocol_binary_request_incr request= {.bytes= {0}}; #else protocol_binary_request_incr request= {0}; #endif unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; server_key= memcached_generate_hash(ptr, key, key_length); request.message.header.request.magic= PROTOCOL_BINARY_REQ; request.message.header.request.opcode= cmd; request.message.header.request.keylen= htons((uint16_t)key_length); request.message.header.request.extlen= 20; request.message.header.request.datatype= PROTOCOL_BINARY_RAW_BYTES; request.message.header.request.bodylen= htonl(key_length + request.message.header.request.extlen); request.message.body.delta= htonll(offset); /* TODO: The binary protocol allows you to specify initial and expiry time */ if ((memcached_do(&ptr->hosts[server_key], request.bytes, sizeof(request.bytes), 0)!=MEMCACHED_SUCCESS) || (memcached_io_write(&ptr->hosts[server_key], key, key_length, 1) == -1)) { memcached_io_reset(&ptr->hosts[server_key]); return MEMCACHED_WRITE_FAILURE; } return memcached_response(&ptr->hosts[server_key], (char*)value, sizeof(*value), NULL); }
void memcached_batch_add_get(memcached_batch_st *ptr, const char* key, size_t key_length) { memcached_batch_add_get_by_hash( ptr, key, key_length, memcached_generate_hash(ptr->root, key, key_length) ); }
static memcached_return memcached_auto(memcached_st *ptr, const char *verb, const char *key, size_t key_length, unsigned int offset, uint64_t *value) { size_t send_length; memcached_return rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; unsigned int server_key; unlikely (ptr->hosts == NULL || ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) return MEMCACHED_BAD_KEY_PROVIDED; server_key= memcached_generate_hash(ptr, key, key_length); send_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %s%.*s %u\r\n", verb, ptr->prefix_key, (int)key_length, key, offset); unlikely (send_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) return MEMCACHED_WRITE_FAILURE; rc= memcached_do(&ptr->hosts[server_key], buffer, send_length, 1); if (rc != MEMCACHED_SUCCESS) return rc; rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); /* So why recheck responce? Because the protocol is brain dead :) The number returned might end up equaling one of the string values. Less chance of a mistake with strncmp() so we will use it. We still called memcached_response() though since it worked its magic for non-blocking IO. */ if (!strncmp(buffer, "ERROR\r\n", 7)) { *value= 0; rc= MEMCACHED_PROTOCOL_ERROR; } else if (!strncmp(buffer, "NOT_FOUND\r\n", 11)) { *value= 0; rc= MEMCACHED_NOTFOUND; } else { *value= strtoull(buffer, (char **)NULL, 10); rc= MEMCACHED_SUCCESS; } return rc; }
uint32_t lmc_key_hash(mcs_st *ptr, const char *key, size_t key_length, int *vbucket) { assert(ptr->kind == MCS_KIND_LIBMEMCACHED); assert(ptr->data != NULL); if (vbucket != NULL) { *vbucket = -1; } return memcached_generate_hash((memcached_st *) ptr->data, key, key_length); }
static test_return_t udp_decr_test(memcached_st *memc) { memcached_return_t rc; const char *key= "decr"; const char *value= "1"; rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); test_true(rc == MEMCACHED_SUCCESS); uint16_t *expected_ids= get_udp_request_ids(memc); unsigned int server_key= memcached_generate_hash(memc, key, strlen(key)); increment_request_id(&expected_ids[server_key]); uint64_t newvalue; rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue); test_true(rc == MEMCACHED_SUCCESS); return post_udp_op_check(memc, expected_ids); }
static test_return_t udp_set_test(memcached_st *memc) { unsigned int num_iters= 1025; //request id rolls over at 1024 for (size_t x= 0; x < num_iters; x++) { memcached_return_t rc; const char *key= "foo"; const char *value= "when we sanitize"; uint16_t *expected_ids= get_udp_request_ids(memc); unsigned int server_key= memcached_generate_hash(memc, key, strlen(key)); memcached_server_instance_st instance= memcached_server_instance_by_position(memc, server_key); size_t init_offset= instance->write_buffer_offset; rc= memcached_set(memc, key, strlen(key), value, strlen(value), (time_t)0, (uint32_t)0); test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED); /** NB, the check below assumes that if new write_ptr is less than * the original write_ptr that we have flushed. For large payloads, this * maybe an invalid assumption, but for the small payload we have it is OK */ if (rc == MEMCACHED_SUCCESS || instance->write_buffer_offset < init_offset) increment_request_id(&expected_ids[server_key]); if (rc == MEMCACHED_SUCCESS) { test_true(instance->write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH); } else { test_true(instance->write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH); test_true(instance->write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH); } test_true(post_udp_op_check(memc, expected_ids) == TEST_SUCCESS); } return TEST_SUCCESS; }
static inline memcached_return_t memcached_send(memcached_st *ptr, const char *master_key, size_t master_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas, memcached_storage_action_t verb) { bool to_write; size_t write_length; memcached_return_t rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; uint32_t server_key; memcached_server_instance_st *instance; WATCHPOINT_ASSERT(!(value == NULL && value_length > 0)); rc= memcached_validate_key_length(key_length, ptr->flags.binary_protocol); unlikely (rc != MEMCACHED_SUCCESS) return rc; unlikely (memcached_server_count(ptr) == 0) return MEMCACHED_NO_SERVERS; if (ptr->flags.verify_key && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) return MEMCACHED_BAD_KEY_PROVIDED; if (ptr->flags.binary_protocol) { return memcached_send_binary(ptr, master_key, master_key_length, key, key_length, value, value_length, expiration, flags, cas, verb); } server_key= memcached_generate_hash(ptr, master_key, master_key_length); instance= memcached_server_instance_fetch(ptr, server_key); if (cas) { write_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %.*s%.*s %u %llu %zu %llu%s\r\n", storage_op_string(verb), (int)ptr->prefix_key_length, ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (unsigned long long)cas, (ptr->flags.no_reply) ? " noreply" : ""); } else { char *buffer_ptr= buffer; const char *command= storage_op_string(verb); /* Copy in the command, no space needed, we handle that in the command function*/ memcpy(buffer_ptr, command, strlen(command)); /* Copy in the key prefix, switch to the buffer_ptr */ buffer_ptr= memcpy((buffer_ptr + strlen(command)), ptr->prefix_key, ptr->prefix_key_length); /* Copy in the key, adjust point if a key prefix was used. */ buffer_ptr= memcpy(buffer_ptr + (ptr->prefix_key_length ? ptr->prefix_key_length : 0), key, key_length); buffer_ptr+= key_length; buffer_ptr[0]= ' '; buffer_ptr++; write_length= (size_t)(buffer_ptr - buffer); write_length+= (size_t) snprintf(buffer_ptr, MEMCACHED_DEFAULT_COMMAND_SIZE, "%u %llu %zu%s\r\n", flags, (unsigned long long)expiration, value_length, ptr->flags.no_reply ? " noreply" : ""); } if (ptr->flags.use_udp && ptr->flags.buffer_requests) { size_t cmd_size= write_length + value_length + 2; if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) return MEMCACHED_WRITE_FAILURE; if (cmd_size + instance->write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) memcached_io_write(instance, NULL, 0, true); } if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) { rc= MEMCACHED_WRITE_FAILURE; goto error; } /* Send command header */ rc= memcached_do(instance, buffer, write_length, false); if (rc != MEMCACHED_SUCCESS) goto error; /* Send command body */ if (memcached_io_write(instance, value, value_length, false) == -1) { rc= MEMCACHED_WRITE_FAILURE; goto error; } if (ptr->flags.buffer_requests && verb == SET_OP) { to_write= false; } else { to_write= true; } if (memcached_io_write(instance, "\r\n", 2, to_write) == -1) { rc= MEMCACHED_WRITE_FAILURE; goto error; } if (ptr->flags.no_reply) return (to_write == false) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS; if (to_write == false) return MEMCACHED_BUFFERED; rc= memcached_response(instance, buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); if (rc == MEMCACHED_STORED) return MEMCACHED_SUCCESS; else return rc; error: memcached_io_reset(instance); return rc; }
static inline memcached_return memcached_send(memcached_st *ptr, const char *master_key, size_t master_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas, memcached_storage_action verb) { char to_write; size_t write_length; ssize_t sent_length; memcached_return rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; unsigned int server_key; WATCHPOINT_ASSERT(!(value == NULL && value_length > 0)); rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL); unlikely (rc != MEMCACHED_SUCCESS) return rc; unlikely (ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; if ((ptr->flags & MEM_VERIFY_KEY) && (memcached_key_test((const char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) return MEMCACHED_BAD_KEY_PROVIDED; if (ptr->flags & MEM_BINARY_PROTOCOL) return memcached_send_binary(ptr, master_key, master_key_length, key, key_length, value, value_length, expiration, flags, cas, verb); server_key= memcached_generate_hash(ptr, master_key, master_key_length); if (cas) write_length= (size_t) snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s%s%.*s %u %llu %zu %llu%s\r\n", storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (unsigned long long)cas, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); else { char *buffer_ptr= buffer; const char *command= storage_op_string(verb); /* Copy in the command, no space needed, we handle that in the command function*/ memcpy(buffer_ptr, command, strlen(command)); /* Copy in the key prefix, switch to the buffer_ptr */ buffer_ptr= memcpy(buffer_ptr + strlen(command) , ptr->prefix_key, strlen(ptr->prefix_key)); /* Copy in the key, adjust point if a key prefix was used. */ buffer_ptr= memcpy(buffer_ptr + (ptr->prefix_key ? strlen(ptr->prefix_key) : 0), key, key_length); buffer_ptr+= key_length; buffer_ptr[0]= ' '; buffer_ptr++; write_length= (size_t)(buffer_ptr - buffer); if (verb == DELETE_OP) { if (ptr->flags & MEM_NOREPLY) write_length+= (size_t) snprintf(buffer_ptr, MEMCACHED_DEFAULT_COMMAND_SIZE, "noreply"); } else { write_length+= (size_t) snprintf(buffer_ptr, MEMCACHED_DEFAULT_COMMAND_SIZE, "%u %llu %zu%s\r\n", flags, (unsigned long long)expiration, value_length, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); } } if (ptr->flags & MEM_USE_UDP && ptr->flags & MEM_BUFFER_REQUESTS) { size_t cmd_size= write_length + value_length + 2; if (cmd_size > MAX_UDP_DATAGRAM_LENGTH - UDP_DATAGRAM_HEADER_LENGTH) return MEMCACHED_WRITE_FAILURE; if (cmd_size + ptr->hosts[server_key].write_buffer_offset > MAX_UDP_DATAGRAM_LENGTH) memcached_io_write(&ptr->hosts[server_key], NULL, 0, 1); } if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) return MEMCACHED_WRITE_FAILURE; /* Send command header */ rc= memcached_do(&ptr->hosts[server_key], buffer, write_length, 0); if (rc != MEMCACHED_SUCCESS) return rc; /* Send command body */ if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1) return MEMCACHED_WRITE_FAILURE; if ((ptr->flags & MEM_BUFFER_REQUESTS) && (verb == SET_OP || verb == PREPEND_OP || verb == APPEND_OP || verb == DELETE_OP)) to_write= 0; else to_write= 1; if ((sent_length= memcached_io_write(&ptr->hosts[server_key], "\r\n", 2, to_write)) == -1) return MEMCACHED_WRITE_FAILURE; if (ptr->flags & MEM_NOREPLY) return (to_write == 0) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS; if (to_write == 0) return MEMCACHED_BUFFERED; rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); if (rc == MEMCACHED_STORED || rc == MEMCACHED_DELETED) return MEMCACHED_SUCCESS; return rc; }
static inline memcached_return memcached_send(memcached_st *ptr, const char *master_key, size_t master_key_length, const char *key, size_t key_length, const char *value, size_t value_length, time_t expiration, uint32_t flags, uint64_t cas, memcached_storage_action verb) { char to_write; size_t write_length; ssize_t sent_length; memcached_return rc; char buffer[MEMCACHED_DEFAULT_COMMAND_SIZE]; unsigned int server_key; WATCHPOINT_ASSERT(!(value == NULL && value_length > 0)); rc= memcached_validate_key_length(key_length, ptr->flags & MEM_BINARY_PROTOCOL); unlikely (rc != MEMCACHED_SUCCESS) return rc; unlikely (ptr->number_of_hosts == 0) return MEMCACHED_NO_SERVERS; if ((ptr->flags & MEM_VERIFY_KEY) && (memcachd_key_test((char **)&key, &key_length, 1) == MEMCACHED_BAD_KEY_PROVIDED)) return MEMCACHED_BAD_KEY_PROVIDED; server_key= memcached_generate_hash(ptr, master_key, master_key_length); if (ptr->flags & MEM_BINARY_PROTOCOL) return memcached_send_binary(&ptr->hosts[server_key], key, key_length, value, value_length, expiration, flags, cas, verb); #ifndef _WIN32 if (cas) write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %s%.*s %u %llu %zu %llu%s\r\n", storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (unsigned long long)cas, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); else write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %s%.*s %u %llu %zu%s\r\n", storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); #else if (cas) write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %s%.*s %u %llu %u %llu%s\r\n", storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (unsigned long long)cas, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); else write_length= snprintf(buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, "%s %s%.*s %u %llu %u%s\r\n", storage_op_string(verb), ptr->prefix_key, (int)key_length, key, flags, (unsigned long long)expiration, value_length, (ptr->flags & MEM_NOREPLY) ? " noreply" : ""); #endif if (write_length >= MEMCACHED_DEFAULT_COMMAND_SIZE) { rc= MEMCACHED_WRITE_FAILURE; goto error; } /* Send command header */ rc= memcached_do(&ptr->hosts[server_key], buffer, write_length, 0); if (rc != MEMCACHED_SUCCESS) goto error; /* Send command body */ if ((sent_length= memcached_io_write(&ptr->hosts[server_key], value, value_length, 0)) == -1) { rc= MEMCACHED_WRITE_FAILURE; goto error; } if ((ptr->flags & MEM_BUFFER_REQUESTS) && verb == SET_OP) to_write= 0; else to_write= 1; if ((sent_length= memcached_io_write(&ptr->hosts[server_key], "\r\n", 2, to_write)) == -1) { rc= MEMCACHED_WRITE_FAILURE; goto error; } if (ptr->flags & MEM_NOREPLY) { memcached_server_response_decrement(&ptr->hosts[server_key]); return (to_write == 0) ? MEMCACHED_BUFFERED : MEMCACHED_SUCCESS; } if (to_write == 0) return MEMCACHED_BUFFERED; rc= memcached_response(&ptr->hosts[server_key], buffer, MEMCACHED_DEFAULT_COMMAND_SIZE, NULL); if (rc == MEMCACHED_STORED) return MEMCACHED_SUCCESS; else return rc; error: memcached_io_reset(&ptr->hosts[server_key]); return rc; }