static void
init_resp3(lcb_t instance, const packet_info *mc_resp, const mc_PACKET *req,
lcb_error_t immerr, lcb_RESPBASE *resp)
{
MK_ERROR(instance, resp, mc_resp, immerr);
resp->cas = PACKET_CAS(mc_resp);
resp->cookie = (void *)MCREQ_PKT_COOKIE(req);
mcreq_get_key(req, &resp->key, &resp->nkey);
}
static void
dispatch_ufwd_error(mc_PIPELINE *pipeline, mc_PACKET *req, lcb_error_t immerr)
{
lcb_PKTFWDRESP resp = { 0 };
lcb_t instance = ((mc_SERVER*)pipeline)->instance;
assert(immerr != LCB_SUCCESS);
resp.version = 0;
instance->callbacks.pktfwd(instance, MCREQ_PKT_COOKIE(req), immerr, &resp);
}
static void
invoke_callback3(const mc_PACKET *pkt,
lcb_t instance,lcb_CALLBACKTYPE cbtype, lcb_RESPBASE * resp)
{
if (!(pkt->flags & MCREQ_F_INVOKED)) {
resp->cookie = (void *)MCREQ_PKT_COOKIE(pkt);
if ((pkt->flags & MCREQ_F_PRIVCALLBACK) == 0) {
find_callback(instance, cbtype)(instance, cbtype, resp);
} else {
(*(lcb_RESPCALLBACK*)resp->cookie)(instance, cbtype, resp);
}
}
}
static void
H_delete(mc_PIPELINE *pipeline, mc_PACKET *packet, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_error_t rc;
lcb_remove_resp_t resp;
resp.version = 0;
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
MK_RESPKEY(&resp, 0, packet);
MK_ERROR(root, rc, response, immerr);
INVOKE_CALLBACK(packet, root->callbacks.remove,
(root, MCREQ_PKT_COOKIE(packet), rc, &resp));
}
static void
H_arithmetic(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_error_t rc;
lcb_arithmetic_resp_t resp;
MK_ERROR(root, rc, response, immerr);
if (rc == LCB_SUCCESS) {
memcpy(&resp.v.v0.value, response->payload, sizeof(resp.v.v0.value));
resp.v.v0.value = ntohll(resp.v.v0.value);
}
MK_RESPKEY(&resp, 0, request);
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
INVOKE_CALLBACK(request, root->callbacks.arithmetic,
(root, MCREQ_PKT_COOKIE(request), rc, &resp));
}
static void
H_store(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_t root = pipeline->parent->instance;
lcb_storage_t op;
lcb_error_t rc;
lcb_store_resp_t resp;
MK_ERROR(root, rc, response, immerr);
switch (PACKET_OPCODE(response)) {
case PROTOCOL_BINARY_CMD_ADD:
op = LCB_ADD;
break;
case PROTOCOL_BINARY_CMD_REPLACE:
op = LCB_REPLACE;
break;
case PROTOCOL_BINARY_CMD_SET:
op = LCB_SET;
break;
case PROTOCOL_BINARY_CMD_APPEND:
op = LCB_APPEND;
break;
case PROTOCOL_BINARY_CMD_PREPEND:
op = LCB_PREPEND;
break;
default:
abort();
break;
}
resp.version = 0;
MK_RESPKEY(&resp, 0, request);
SET_RESP_CAS(&resp, 0, PACKET_CAS(response));
INVOKE_CALLBACK(request, root->callbacks.store,
(root, MCREQ_PKT_COOKIE(request), op, rc, &resp));
}
static void
H_get(mc_PIPELINE *pipeline, mc_PACKET *request, packet_info *response,
lcb_error_t immerr)
{
lcb_error_t rc;
lcb_t o;
lcb_get_resp_t resp;
void *freeptr = NULL;
o = pipeline->parent->instance;
MK_RESPKEY(&resp, 0, request);
MK_ERROR(o, rc, response, immerr);
resp.version = 0;
if (rc == LCB_SUCCESS) {
const protocol_binary_response_getq *getq =
PACKET_EPHEMERAL_START(response);
resp.v.v0.cas = PACKET_CAS(response);
resp.v.v0.datatype = PACKET_DATATYPE(response);
resp.v.v0.flags = ntohl(getq->message.body.flags);
resp.v.v0.bytes = PACKET_VALUE(response);
resp.v.v0.nbytes = PACKET_NVALUE(response);
rc = LCB_SUCCESS;
} else {
resp.v.v0.cas = 0;
resp.v.v0.nbytes = 0;
resp.v.v0.bytes = NULL;
resp.v.v0.flags = 0;
}
maybe_decompress(o, response, &resp, &freeptr);
INVOKE_CALLBACK(request, o->callbacks.get,
(o, MCREQ_PKT_COOKIE(request), rc, &resp));
free(freeptr);
}
static void
handle_observe_callback(mc_PIPELINE *pl,
mc_PACKET *pkt, lcb_error_t err, const void *arg)
{
OBSERVECTX *oc = (void *)pkt->u_rdata.exdata;
lcb_RESPOBSERVE *resp = (void *)arg;
lcb_t instance = oc->instance;
(void)pl;
if (resp == NULL) {
int nfailed = 0;
/** We need to fail the request manually.. */
const char *ptr = SPAN_BUFFER(&pkt->u_value.single);
const char *end = ptr + pkt->u_value.single.size;
while (ptr < end) {
lcb_uint16_t nkey;
lcb_RESPOBSERVE cur = { 0 };
cur.rflags = LCB_RESP_F_CLIENTGEN;
ptr += 2;
memcpy(&nkey, ptr, sizeof(nkey));
nkey = ntohs(nkey);
ptr += 2;
memset(&cur, 0, sizeof(cur));
cur.key = ptr;
cur.nkey = nkey;
cur.cookie = (void *)oc->base.cookie;
cur.rc = err;
handle_observe_callback(NULL, pkt, err, &cur);
ptr += nkey;
nfailed++;
}
lcb_assert(nfailed);
return;
}
resp->cookie = (void *)oc->base.cookie;
resp->rc = err;
if (oc->oflags & F_DURABILITY) {
lcb_durability_dset_update( instance,
(lcb_DURSET *)MCREQ_PKT_COOKIE(pkt), err, resp);
} else if ((oc->oflags & F_SCHEDFAILED) == 0) {
lcb_RESPCALLBACK callback = lcb_find_callback(instance, LCB_CALLBACK_OBSERVE);
callback(instance, LCB_CALLBACK_OBSERVE, (lcb_RESPBASE *)resp);
}
if (oc->oflags & F_DESTROY) {
return;
}
if (--oc->remaining) {
return;
} else {
lcb_RESPOBSERVE resp2 = { 0 };
resp2.rc = err;
resp2.rflags = LCB_RESP_F_CLIENTGEN|LCB_RESP_F_FINAL;
oc->oflags |= F_DESTROY;
handle_observe_callback(NULL, pkt, err, &resp2);
free(oc);
}
}
