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; }