static void
H_store(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPSTORE resp = { 0 };
lcb_U8 opcode;
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&resp);
if (!immerr) {
opcode = PACKET_OPCODE(response);
} else {
protocol_binary_request_header hdr;
mcreq_read_hdr(request, &hdr);
opcode = hdr.request.opcode;
}
if (opcode == PROTOCOL_BINARY_CMD_ADD) {
resp.op = LCB_ADD;
} else if (opcode == PROTOCOL_BINARY_CMD_REPLACE) {
resp.op = LCB_REPLACE;
} else if (opcode == PROTOCOL_BINARY_CMD_APPEND) {
resp.op = LCB_APPEND;
} else if (opcode == PROTOCOL_BINARY_CMD_PREPEND) {
resp.op = LCB_PREPEND;
} else if (opcode == PROTOCOL_BINARY_CMD_SET) {
resp.op = LCB_SET;
}
handle_synctoken(root, response, request, &resp.synctoken);
TRACE_STORE_END(response, &resp);
if (request->flags & MCREQ_F_REQEXT) {
request->u_rdata.exdata->procs->handler(pipeline, request, immerr, &resp);
} else {
INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_STORE);
}
}
static void
H_get(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t o;
lcb_RESPGET resp = { 0 };
void *freeptr = NULL;
o = pipeline->parent->cqdata;
init_resp3(o, response, request, immerr, (lcb_RESPBASE *)&resp);
if (resp.rc == LCB_SUCCESS) {
const protocol_binary_response_getq *getq =
PACKET_EPHEMERAL_START(response);
resp.datatype = PACKET_DATATYPE(response);
resp.itmflags = ntohl(getq->message.body.flags);
resp.value = PACKET_VALUE(response);
resp.nvalue = PACKET_NVALUE(response);
resp.bufh = response->bufh;
}
maybe_decompress(o, response, &resp, &freeptr);
TRACE_GET_END(response, &resp);
INVOKE_CALLBACK3(request, &resp, o, LCB_CALLBACK_GET);
free(freeptr);
}
static void
H_observe_seqno(mc_PIPELINE *pipeline, mc_PACKET *request,
packet_info *response, lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPOBSEQNO resp = { 0 };
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&resp);
resp.server_index = pipeline->index;
if (resp.rc == LCB_SUCCESS) {
const lcb_U8 *data = PACKET_BODY(response);
int is_failover = *data != 0;
data++;
#define COPY_ADV(dstfld, n, conv_fn) \
memcpy(&resp.dstfld, data, n); \
data += n; \
resp.dstfld = conv_fn(resp.dstfld);
COPY_ADV(vbid, 2, ntohs);
COPY_ADV(cur_uuid, 8, lcb_ntohll);
COPY_ADV(persisted_seqno, 8, lcb_ntohll);
COPY_ADV(mem_seqno, 8, lcb_ntohll);
if (is_failover) {
COPY_ADV(old_uuid, 8, lcb_ntohll);
COPY_ADV(old_seqno, 8, lcb_ntohll);
}
#undef COPY_ADV
/* Get the server for this command. Note that since this is a successful
* operation, the server is never a dummy */
}
INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_OBSEQNO);
}
static void
H_unlock(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPUNLOCK resp = { 0 };
init_resp3(root, response, request, immerr, &resp);
TRACE_UNLOCK_END(response, &resp);
INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_UNLOCK);
}
static void
H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPREMOVE resp = { 0 };
init_resp3(root, response, packet, immerr, (lcb_RESPBASE *)&resp);
handle_synctoken(root, response, packet, &resp.synctoken);
TRACE_REMOVE_END(response, &resp);
INVOKE_CALLBACK3(packet, &resp, root, LCB_CALLBACK_REMOVE);
}
static void
H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
respack_REMOVE w = { { 0 } };
w.resp.rflags |= LCB_RESP_F_EXTDATA;
init_resp3(root, response, packet, immerr, (lcb_RESPBASE *)&w.resp);
handle_mutation_token(root, response, packet, &w.mt);
TRACE_REMOVE_END(response, &w.resp);
INVOKE_CALLBACK3(packet, &w.resp, root, LCB_CALLBACK_REMOVE);
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
lcb_RESPCOUNTER resp = { 0 };
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&resp);
if (resp.rc == LCB_SUCCESS) {
memcpy(&resp.value, PACKET_VALUE(response), sizeof(resp.value));
resp.value = lcb_ntohll(resp.value);
handle_synctoken(root, response, request, &resp.synctoken);
}
resp.cas = PACKET_CAS(response);
TRACE_ARITHMETIC_END(response, &resp);
INVOKE_CALLBACK3(request, &resp, root, LCB_CALLBACK_COUNTER);
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->cqdata;
respack_COUNTER w = { { 0 } };
init_resp3(root, response, request, immerr, (lcb_RESPBASE*)&w.resp);
if (w.resp.rc == LCB_SUCCESS) {
memcpy(&w.resp.value, PACKET_VALUE(response), sizeof(w.resp.value));
w.resp.value = lcb_ntohll(w.resp.value);
w.resp.rflags |= LCB_RESP_F_EXTDATA;
handle_mutation_token(root, response, request, &w.mt);
}
w.resp.cas = PACKET_CAS(response);
TRACE_ARITHMETIC_END(response, &w.resp);
INVOKE_CALLBACK3(request, &w.resp, root, LCB_CALLBACK_COUNTER);
}
static void
H_subdoc(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t o;
respack_SUBDOC w = { { 0 } };
int cbtype;
o = pipeline->parent->cqdata;
init_resp3(o, response, request, immerr, (lcb_RESPBASE *)&w.resp);
/* For mutations, add the mutation token */
switch (PACKET_OPCODE(response)) {
case PROTOCOL_BINARY_CMD_SUBDOC_GET:
case PROTOCOL_BINARY_CMD_SUBDOC_EXISTS:
case PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP:
cbtype = LCB_CALLBACK_SDLOOKUP;
break;
default:
handle_mutation_token(o, response, request, &w.mt);
w.resp.rflags |= LCB_RESP_F_EXTDATA;
cbtype = LCB_CALLBACK_SDMUTATE;
break;
}
if (PACKET_OPCODE(response) == PROTOCOL_BINARY_CMD_SUBDOC_MULTI_LOOKUP ||
PACKET_OPCODE(response) == PROTOCOL_BINARY_CMD_SUBDOC_MULTI_MUTATION) {
if (w.resp.rc == LCB_SUCCESS || w.resp.rc == LCB_SUBDOC_MULTI_FAILURE) {
w.resp.responses = response;
}
} else {
/* Single response */
w.resp.rflags |= LCB_RESP_F_SDSINGLE;
if (w.resp.rc == LCB_SUCCESS) {
w.resp.responses = response;
} else if (LCB_EIFSUBDOC(w.resp.rc)) {
w.resp.responses = response;
w.resp.rc = LCB_SUBDOC_MULTI_FAILURE;
}
}
INVOKE_CALLBACK3(request, &w.resp, o, cbtype);
}
static void
H_getreplica(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_RESPGET resp = { 0 };
lcb_t instance = pipeline->parent->cqdata;
void *freeptr = NULL;
mc_REQDATAEX *rd = request->u_rdata.exdata;
init_resp3(instance, response, request, immerr, (lcb_RESPBASE *)&resp);
if (resp.rc == LCB_SUCCESS) {
const protocol_binary_response_get *get = PACKET_EPHEMERAL_START(response);
resp.itmflags = ntohl(get->message.body.flags);
resp.datatype = PACKET_DATATYPE(response);
resp.value = PACKET_VALUE(response);
resp.nvalue = PACKET_NVALUE(response);
resp.bufh = response->bufh;
}
maybe_decompress(instance, response, &resp, &freeptr);
rd->procs->handler(pipeline, request, resp.rc, &resp);
free(freeptr);
}
