void verifySerializedValue(const std::string& serializedVal,
uint64_t expectedReqId,
mc_msg_t* expectedMsg,
const char* value) {
// check if the value was serialized correctly
um_parser_t parser;
EXPECT_EQ(um_parser_init(&parser), 0);
uint64_t parsedReqId = -1;
mc_msg_t* parsedMsg = nullptr;
EXPECT_EQ(um_consume_one_message(&parser,
(uint8_t *)serializedVal.c_str(),
serializedVal.length(),
&parsedReqId,
&parsedMsg),
serializedVal.length());
EXPECT_NE(parsedMsg, nullptr);
EXPECT_EQ(parsedReqId, expectedReqId);
EXPECT_EQ(parsedMsg->op, expectedMsg->op);
EXPECT_EQ(parsedMsg->result, expectedMsg->result);
EXPECT_EQ(parsedMsg->flags, expectedMsg->flags);
EXPECT_EQ(parsedMsg->value.len, strlen(value));
EXPECT_EQ(strncmp(parsedMsg->value.str, value, strlen(value)), 0);
mc_msg_decref(parsedMsg);
}
void um_backing_msg_cleanup(um_backing_msg_t* bmsg) {
entry_list_cleanup(&bmsg->elist);
bmsg->elist.entries = bmsg->entries_array;
bmsg->elist.entries_size = BMSG_ENTRIES_ARRAY_SIZE;
if (bmsg->msg != NULL) {
mc_msg_decref(bmsg->msg);
bmsg->msg = NULL;
}
bmsg->inuse = 0;
}
folly::IOBuf makeMsgIOBufStackHelper(const McMsgRef& msgRef) {
if (!msgRef.get()) {
return {};
}
auto msg = const_cast<mc_msg_t*>(msgRef.get());
if (!(msg->*F).len) {
return {};
}
return folly::IOBuf(
folly::IOBuf::TAKE_OWNERSHIP,
(msg->*F).str, (msg->*F).len, (msg->*F).len,
[] (void* buf, void* ctx) {
auto m = reinterpret_cast<mc_msg_t*>(ctx);
mc_msg_decref(m);
},
mc_msg_incref(msg));
}
std::unique_ptr<folly::IOBuf> makeMsgIOBufHelper(const McMsgRef& msgRef,
bool returnEmpty) {
if (!msgRef.get()) {
return returnEmpty ? folly::IOBuf::create(0) : nullptr;
}
auto msg = const_cast<mc_msg_t*>(msgRef.get());
if (!(msg->*F).len) {
return returnEmpty ? folly::IOBuf::create(0) : nullptr;
}
return folly::IOBuf::takeOwnership(
(msg->*F).str, (msg->*F).len, (msg->*F).len,
[] (void* buf, void* ctx) {
auto m = reinterpret_cast<mc_msg_t*>(ctx);
mc_msg_decref(m);
},
mc_msg_incref(msg));
}
/* reallocate a mc_msg_t
* for deep/shallow copying semantics, see _msgcpy
* For more on why we do it this way, see Task #689247 and D314525
*/
mc_msg_t* mc_msg_realloc(mc_msg_t *msg, size_t new_extra_size) {
if (msg == NULL) {
// Same behavior as realloc, malloc on NULL
return mc_msg_new(new_extra_size);
}
if (new_extra_size <= msg->_extra_size) {
return msg;
}
mc_msg_t *msg_copy = mc_msg_new(new_extra_size);
if (msg_copy == NULL) {
// Same behavior as realloc, don't clean up msg
return NULL;
}
_msgcpy(msg_copy, msg);
msg_copy->_extra_size = new_extra_size;
// "free" it
mc_msg_decref(msg);
return msg_copy;
}
static mc_msg_t *_msg_create(mc_msg_t *base, entry_list_t *elist,
_parse_info_t* parse_info) {
size_t msg_size = 0;
mc_msg_t *msg = NULL;
size_t stats_offset = 0;
size_t body_offset = 0;
void *body = NULL;
// Make sure we're not screwing up alignment here
FBI_ASSERT(sizeof(mc_msg_t) % sizeof(void *) == 0);
// Construct a message of the following format
// __________________
// | |
// | mc_msg_t | <- base message
// |___________________|
// | |
// | nstring_t array | <- stats array (optional)
// |___________________|
// | |
// | key string | <- key (optional)
// |___________________|
// | |
// | value string | <- value (optional)
// |___________________|
// | |
// | stats[0] | <- stats[0] (and so on...)
// |___________________|
//
msg_size = sizeof(mc_msg_t);
if (parse_info->stats_count > 0) {
stats_offset = msg_size;
msg_size += (sizeof(nstring_t) * parse_info->stats_count);
}
body_offset = msg_size;
msg_size += elist->nbody;
FBI_ASSERT(msg_size >= sizeof(*base));
msg = mc_msg_new(msg_size - sizeof(mc_msg_t));
if (msg == NULL) {
goto error;
}
// Copy base
mc_msg_copy(msg, base);
// Copy body
memcpy((void*)msg + body_offset, elist->body, elist->nbody);
body = (void*)msg + body_offset;
if (parse_info->stats_count > 0) {
FBI_ASSERT(stats_offset > 0);
nstring_t *stats = (nstring_t*) ((void*)msg + stats_offset);
uint64_t i;
int sidx;
for (i = 0, sidx = 0;
i < elist->nentries && sidx < parse_info->stats_count; i++) {
um_elist_entry_t *entry = &elist->entries[i];
if (ntoh16(entry->tag) == msg_stats) {
_set_str(&stats[sidx], body, entry);
sidx++;
}
}
msg->stats = stats;
}
_fill_msg_strs(msg, elist, body, parse_info);
return msg;
error:
if (msg != NULL) {
mc_msg_decref(msg);
msg = NULL;
}
return NULL;
}
