gboolean mcap_mdl_abort(struct mcap_mdl *mdl, mcap_mdl_notify_cb abort_cb,
gpointer user_data,
GDestroyNotify destroy,
GError **err)
{
struct mcap_mdl_op_cb *con;
struct mcap_mcl *mcl = mdl->mcl;
mcap_md_req *cmd;
if (mdl->state != MDL_WAITING) {
g_set_error(err, MCAP_ERROR, MCAP_ERROR_FAILED,
"Mdl in invalid state");
return FALSE;
}
cmd = create_req(MCAP_MD_ABORT_MDL_REQ, mdl->mdlid);
if (!mcap_send_std_opcode(mcl, cmd, sizeof(mcap_md_req), err)) {
g_free(cmd);
return FALSE;
}
con = g_new0(struct mcap_mdl_op_cb, 1);
con->mdl = mcap_mdl_ref(mdl);
con->cb.notify = abort_cb;
con->destroy = destroy;
con->user_data = user_data;
mcl->priv_data = con;
mcl->tid = g_timeout_add_seconds(RESPONSE_TIMER, wait_response_timer,
mcl);
return TRUE;
}
h2o_memcached_req_t *h2o_memcached_get(h2o_memcached_context_t *ctx, h2o_multithread_receiver_t *receiver, h2o_iovec_t key,
h2o_memcached_get_cb cb, void *cb_data, int flags)
{
h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_GET, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0);
req->data.get.receiver = receiver;
req->data.get.cb = cb;
req->data.get.cb_data = cb_data;
req->data.get.value_is_encoded = (flags & H2O_MEMCACHED_ENCODE_VALUE) != 0;
dispatch(ctx, req);
return req;
}
void h2o_memcached_set(h2o_memcached_context_t *ctx, h2o_iovec_t key, h2o_iovec_t value, uint32_t expiration, int flags)
{
h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_SET, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0);
if ((flags & H2O_MEMCACHED_ENCODE_VALUE) != 0) {
req->data.set.value.base = h2o_mem_alloc((value.len + 2) / 3 * 4 + 1);
req->data.set.value.len = h2o_base64_encode(req->data.set.value.base, value.base, value.len, 1);
} else {
req->data.set.value = h2o_iovec_init(h2o_mem_alloc(value.len), value.len);
memcpy(req->data.set.value.base, value.base, value.len);
}
req->data.set.expiration = expiration;
dispatch(ctx, req);
}
static gboolean send_delete_req(struct mcap_mcl *mcl,
struct mcap_mdl_op_cb *con,
uint16_t mdlid,
GError **err)
{
mcap_md_req *cmd;
cmd = create_req(MCAP_MD_DELETE_MDL_REQ, mdlid);
if (!mcap_send_std_opcode(mcl, cmd, sizeof(mcap_md_req), err)) {
g_free(cmd);
return FALSE;
}
mcl->priv_data = con;
mcl->tid = g_timeout_add_seconds(RESPONSE_TIMER, wait_response_timer,
mcl);
return TRUE;
}
gboolean mcap_reconnect_mdl(struct mcap_mdl *mdl,
mcap_mdl_operation_cb reconnect_cb,
gpointer user_data,
GDestroyNotify destroy,
GError **err)
{
struct mcap_mdl_op_cb *con;
struct mcap_mcl *mcl = mdl->mcl;
mcap_md_req *cmd;
if (mdl->state != MDL_CLOSED) {
g_set_error(err, MCAP_ERROR, MCAP_ERROR_FAILED,
"MDL is not closed");
return FALSE;
}
cmd = create_req(MCAP_MD_RECONNECT_MDL_REQ, mdl->mdlid);
if (!mcap_send_std_opcode(mcl, cmd, sizeof(mcap_md_req), err)) {
g_free(cmd);
return FALSE;
}
mdl->state = MDL_WAITING;
con = g_new0(struct mcap_mdl_op_cb, 1);
con->mdl = mcap_mdl_ref(mdl);
con->cb.op = reconnect_cb;
con->destroy = destroy;
con->user_data = user_data;
mcl->state = MCL_ACTIVE;
mcl->priv_data = con;
mcl->tid = g_timeout_add_seconds(RESPONSE_TIMER, wait_response_timer,
mcl);
return TRUE;
}
void h2o_memcached_delete(h2o_memcached_context_t *ctx, h2o_iovec_t key, int flags)
{
h2o_memcached_req_t *req = create_req(ctx, REQ_TYPE_DELETE, key, (flags & H2O_MEMCACHED_ENCODE_KEY) != 0);
dispatch(ctx, req);
}
void process_client(client_arg_t *args)
{
/* The thread responsible for accepting a client connection
* and processing the request.
* The QUERY cmd is processed entirely by this thread.
* The MONITOR and CONNECT cmds are setup and then placed
* in the conf->objs list to be handled by mux_io().
*/
int sd;
server_conf_t *conf;
req_t *req;
/* Free the tmp struct that was created by accept_client()
* in order to pass multiple args to this thread.
*/
assert(args != NULL);
sd = args->sd;
conf = args->conf;
free(args);
DPRINTF((5, "Processing new client.\n"));
x_pthread_detach(pthread_self());
req = create_req();
if (resolve_addr(conf, req, sd) < 0)
goto err;
if (recv_greeting(req) < 0)
goto err;
if (recv_req(req) < 0)
goto err;
if (query_consoles(conf, req) < 0)
goto err;
if (validate_req(req) < 0)
goto err;
/* send_rsp() needs to know if the reset command is supported.
* Since it cannot check resetCmd in the server_conf struct,
* we set a flag in the request struct instead.
*/
if (conf->resetCmd)
req->enableReset = 1;
switch(req->command) {
case CONMAN_CMD_CONNECT:
if (perform_connect_cmd(req, conf) < 0)
goto err;
break;
case CONMAN_CMD_MONITOR:
if (perform_monitor_cmd(req, conf) < 0)
goto err;
break;
case CONMAN_CMD_QUERY:
if (perform_query_cmd(req) < 0)
goto err;
break;
default:
log_msg(LOG_WARNING, "Received invalid command=%d from <%s@%s:%d>",
req->command, req->user, req->fqdn, req->port);
goto err;
}
return;
err:
destroy_req(req);
return;
}
