gop_op_generic_t *ibp_merge_alloc_gop(ibp_context_t *ic, ibp_cap_t *mcap, ibp_cap_t *ccap, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char host[MAX_HOST_SIZE];
char chost[MAX_HOST_SIZE];
ibp_op_merge_alloc_t *cmd;
int port, cport;
log_printf(15, "set_ibp_merge_op: start. ic=%p\n", op->ic);
init_ibp_base_op(op, "rename", timeout, op->ic->other_new_command, NULL, 1, IBP_RENAME, IBP_NOP);
cmd = &(op->ops.merge_op);
parse_cap(op->ic, mcap, host, &port, cmd->mkey, cmd->mtypekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_MERGE_ALLOCATE]));
op->dop.cmd.hostport = strdup(hoststr);
parse_cap(op->ic, ccap, chost, &cport, cmd->ckey, cmd->ctypekey);
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = merge_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = status_get_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_alloc_gop(ibp_context_t *ic, ibp_capset_t *caps, ibp_off_t size, ibp_depot_t *depot, ibp_attributes_t *attr,
int disk_cs_type, ibp_off_t disk_blocksize, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char pchost[MAX_HOST_SIZE];
ibp_op_alloc_t *cmd;
ibppc_form_host(op->ic, pchost, sizeof(pchost), depot->host, depot->rid);
set_hostport(hoststr, sizeof(hoststr), pchost, depot->port, &(op->ic->cc[IBP_ALLOCATE]));
init_ibp_base_op(op, "alloc", timeout, op->ic->other_new_command, strdup(hoststr), 1, IBP_ALLOCATE, IBP_NOP);
cmd = &(op->ops.alloc_op);
cmd->caps = caps;
cmd->depot = depot;
cmd->attr = attr;
cmd->duration = cmd->attr->duration - time(NULL); //** This is in sec NOT APR time
if (cmd->duration < 0) cmd->duration = cmd->attr->duration;
cmd->size = size;
cmd->disk_chksum_type = disk_cs_type;
cmd->disk_blocksize = disk_blocksize;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = allocate_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = allocate_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_query_resources_gop(ibp_context_t *ic, ibp_depot_t *depot, ibp_ridlist_t *rlist, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
char hoststr[MAX_HOST_SIZE];
char pchoststr[MAX_HOST_SIZE];
ibp_op_rid_inq_t *cmd = &(op->ops.rid_op);
ibppc_form_host(op->ic, pchoststr, sizeof(pchoststr), depot->host, depot->rid);
set_hostport(hoststr, sizeof(hoststr), pchoststr, depot->port, &(op->ic->cc[IBP_STATUS]));
init_ibp_base_op(op, "query_resources", timeout, op->ic->other_new_command, strdup(hoststr),
op->ic->other_new_command, IBP_STATUS, IBP_ST_RES);
cmd->depot = depot;
cmd->rlist = rlist;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = query_res_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = query_res_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_depot_inq_gop(ibp_context_t *ic, ibp_depot_t *depot, char *password, ibp_depotinfo_t *di, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
char hoststr[MAX_HOST_SIZE];
char pchost[MAX_HOST_SIZE];
ibp_op_depot_inq_t *cmd = &(op->ops.depot_inq_op);
ibppc_form_host(op->ic, pchost, sizeof(pchost), depot->host, depot->rid);
set_hostport(hoststr, sizeof(hoststr), pchost, depot->port, &(op->ic->cc[IBP_STATUS]));
init_ibp_base_op(op, "depot_inq", timeout, op->ic->other_new_command, strdup(hoststr),
op->ic->other_new_command, IBP_STATUS, IBP_ST_INQ);
cmd->depot = depot;
cmd->password = password;
cmd->di = di;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = depot_inq_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = depot_inq_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_version_gop(ibp_context_t *ic, ibp_depot_t *depot, char *buffer, int buffer_size, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
char hoststr[MAX_HOST_SIZE];
char pchoststr[MAX_HOST_SIZE];
ibp_op_version_t *cmd = &(op->ops.ver_op);
ibppc_form_host(op->ic, pchoststr, sizeof(pchoststr), depot->host, depot->rid);
set_hostport(hoststr, sizeof(hoststr), pchoststr, depot->port, &(op->ic->cc[IBP_STATUS]));
init_ibp_base_op(op, "depot_version", timeout, op->ic->other_new_command, strdup(hoststr),
op->ic->other_new_command, IBP_STATUS, IBP_ST_VERSION);
cmd->depot = depot;
cmd->buffer = buffer;
cmd->buffer_size = buffer_size;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = depot_version_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = depot_version_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_truncate_gop(ibp_context_t *ic, ibp_cap_t *cap, ibp_off_t size, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
int port;
char host[MAX_HOST_SIZE];
ibp_op_modify_alloc_t *cmd;
init_ibp_base_op(op, "truncate_alloc", timeout, op->ic->other_new_command, NULL, 1, IBP_MANAGE, IBP_CHNG);
cmd = &(op->ops.mod_alloc_op);
parse_cap(op->ic, cap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_MANAGE]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->cap = cap;
cmd->size = size;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = truncate_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = status_get_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_proxy_probe_gop(ibp_context_t *ic, ibp_cap_t *cap, ibp_proxy_capstatus_t *probe, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
int port;
char host[MAX_HOST_SIZE];
ibp_op_probe_t *cmd;
init_ibp_base_op(op, "proxy_probe", timeout, op->ic->other_new_command, NULL, 1, IBP_PROXY_MANAGE, IBP_PROBE);
cmd = &(op->ops.probe_op);
parse_cap(op->ic, cap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_PROXY_MANAGE]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->cap = cap;
cmd->proxy_probe = probe;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = proxy_probe_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = proxy_probe_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_validate_chksum_gop(ibp_context_t *ic, ibp_cap_t *mcap, int correct_errors, int *n_bad_blocks,
int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char host[MAX_HOST_SIZE];
ibp_op_validate_chksum_t *cmd;
int port;
init_ibp_base_op(op, "validate_chksum", timeout, op->ic->other_new_command, NULL, 1, IBP_VALIDATE_CHKSUM, IBP_NOP);
gop_op_generic_t *gop = ibp_get_gop(op);
cmd = &(op->ops.validate_op);
parse_cap(op->ic, mcap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_VALIDATE_CHKSUM]));
op->dop.cmd.hostport = strdup(hoststr);
cmd = &(op->ops.validate_op);
cmd->correct_errors = correct_errors;
cmd->n_bad_blocks = n_bad_blocks;
gop->op->cmd.send_command = validate_chksum_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = validate_chksum_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_copy_gop(ibp_context_t *ic, int mode, int ns_type,
char *path, ibp_cap_t *srccap, ibp_cap_t *destcap,
ibp_off_t src_offset, ibp_off_t dest_offset,
ibp_off_t size, int src_timeout,
int dest_timeout, int dest_client_timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
char hoststr[MAX_HOST_SIZE];
int port;
char host[MAX_HOST_SIZE];
ibp_op_copy_t *cmd;
init_ibp_base_op(op, "copy", src_timeout, op->ic->rw_new_command + size, NULL, size, IBP_SEND, IBP_NOP);
cmd = &(op->ops.copy_op);
parse_cap(op->ic, srccap, host, &port, cmd->src_key, cmd->src_typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_SEND]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->ibp_command = mode;
if (ns_type == NS_TYPE_PHOEBUS) {
cmd->ctype = IBP_PHOEBUS;
cmd->path = path;
if (cmd->path == NULL) cmd->path = "auto"; //** If NULL default to auto
} else { //** All other ns types don't use the path
cmd->ctype = IBP_TCP;
cmd->path = "\0";
}
//** Want chksumming so tweak the command
if (tbx_ns_chksum_is_valid(&(op->ncs)) == 1) {
if (cmd->ibp_command == IBP_PUSH) {
cmd->ibp_command = IBP_PUSH_CHKSUM;
} else {
cmd->ibp_command = IBP_PULL_CHKSUM;
}
}
cmd->srccap = srccap;
cmd->destcap = destcap;
cmd->len = size;
cmd->src_offset = src_offset;
cmd->dest_offset = dest_offset;
cmd->dest_timeout = dest_timeout;
cmd->dest_client_timeout = dest_client_timeout;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = pushpull_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = copy_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_vec_write_gop(ibp_context_t *ic, ibp_cap_t *cap, int n_iovec, ibp_tbx_iovec_t *iovec, tbx_tbuf_t *buffer, ibp_off_t bpos, ibp_off_t len, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
gop_op_generic_t *gop = ibp_get_gop(op);
set_ibp_rw_gop(op, IBP_WRITE, cap, 0, buffer, bpos, len, timeout);
op->ops.rw_op.n_ops = 1;
op->ops.rw_op.n_tbx_iovec_total = n_iovec;
op->ops.rw_op.buf_single.n_iovec = n_iovec;
op->ops.rw_op.buf_single.iovec = iovec;
gop->op->cmd.send_command = vec_write_command;
return(ibp_get_gop(op));
}
int ibp_sync_command(ibp_op_t *iop)
{
op_generic_t *gop = ibp_get_gop(iop);
op_status_t status;
//** Submit if for execution
// gop->base.started_execution = 1; //** Mark it as being submitted
// submit_hportal_sync(gop->op->pc, gop);
gop_set_exec_mode(gop, OP_EXEC_DIRECT);
gop_start_execution(gop);
//** and Wait for completion
gop_waitany(gop);
status = gop_get_status(gop);
IBP_errno = status.error_code;
if (gop->op->cmd.hostport != NULL) {
free(gop->op->cmd.hostport);
gop->op->cmd.hostport = NULL;
}
log_printf(10, "ibp_sync_command: IBP_errno=%d\n", IBP_errno); //tbx_log_flush();
return(IBP_errno);
}
ibp_depotinfo_t *IBP_status(ibp_depot_t *depot, int cmd, ibp_timer_t *timer, char *password,
unsigned long int hard, unsigned long int soft, long duration)
{
int err;
ibp_op_t op;
ibp_depotinfo_t *di = NULL;
make_ibp_sync_context();
init_ibp_op(_ibp_sync, &op);
if (cmd == IBP_ST_INQ) {
di = (ibp_depotinfo_t *)malloc(sizeof(ibp_depotinfo_t));
assert(di != NULL);
set_ibp_depot_inq_op(&op, depot, password, di, timer->ClientTimeout);
} else {
set_ibp_depot_modify_op(&op, depot, password, hard, soft, duration, timer->ClientTimeout);
}
err = ibp_sync_command(&op);
gop_free(ibp_get_gop(&op), OP_FINALIZE);
if (err != IBP_OK) {
free(di);
return(NULL);
}
return(di);
}
gop_op_generic_t *ibp_proxy_modify_count_gop(ibp_context_t *ic, ibp_cap_t *cap, ibp_cap_t *mcap, int mode, int captype, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
set_ibp_generic_modify_count_op(IBP_PROXY_MANAGE, op, cap, mcap, mode, captype, timeout);
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_rw_gop(ibp_context_t *ic, int rw_type, ibp_cap_t *cap, ibp_off_t offset, tbx_tbuf_t *buffer, ibp_off_t bpos, ibp_off_t len, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
set_ibp_rw_gop(op, rw_type, cap, offset, buffer, bpos, len, timeout);
return(ibp_get_gop(op));
}
void set_ibp_rw_gop(ibp_op_t *op, int rw_type, ibp_cap_t *cap, ibp_off_t offset, tbx_tbuf_t *buffer, ibp_off_t bpos, ibp_off_t len, int timeout)
{
char hoststr[MAX_HOST_SIZE];
int port;
char host[MAX_HOST_SIZE];
ibp_op_rw_t *cmd;
ibp_rw_buf_t *rwbuf;
cmd = &(op->ops.rw_op);
init_ibp_base_op(op, "rw", timeout, op->ic->rw_new_command + len, NULL, len, rw_type, IBP_NOP);
gop_op_generic_t *gop = ibp_get_gop(op);
parse_cap(op->ic, cap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[rw_type]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->cap = cap;
cmd->size = len; //** This is the total size
rwbuf = &(cmd->buf_single);
cmd->bs_ptr = rwbuf;
cmd->rwbuf = &(cmd->bs_ptr);
cmd->n_ops = 1;
cmd->n_tbx_iovec_total = 1;
cmd->rw_mode = rw_type;
rwbuf->iovec = &(rwbuf->iovec_single);
rwbuf->n_iovec = 1;
rwbuf->iovec->offset = offset;
rwbuf->iovec->len = len;
rwbuf->buffer = buffer;
rwbuf->boff = bpos;
rwbuf->size = len;
if (rw_type == IBP_WRITE) {
gop->op->cmd.send_command = write_command;
gop->op->cmd.send_phase = write_send;
gop->op->cmd.recv_phase = write_recv;
gop->op->cmd.on_submit = ibp_rw_submit_coalesce;
gop->op->cmd.before_exec = ibp_rw_coalesce;
} else {
gop->op->cmd.send_command = read_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = read_recv;
gop->op->cmd.on_submit = ibp_rw_submit_coalesce;
gop->op->cmd.before_exec = ibp_rw_coalesce;
}
op->ncs = op->ic->ncs; //** Copy the default network chksum
}
gop_op_generic_t *ibp_proxy_alloc_gop(ibp_context_t *ic, ibp_capset_t *caps, ibp_cap_t *mcap, ibp_off_t offset, ibp_off_t size,
int duration, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char host[MAX_HOST_SIZE];
ibp_op_alloc_t *cmd;
int port;
log_printf(15, "set_ibp_proxy_alloc_gop: start. ic=%p\n", op->ic);
init_ibp_base_op(op, "rename", timeout, op->ic->other_new_command, NULL, 1, IBP_PROXY_ALLOCATE, IBP_NOP);
cmd = &(op->ops.alloc_op);
parse_cap(op->ic, mcap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_PROXY_ALLOCATE]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->offset = offset;
cmd->size = size;
if (duration == 0) {
cmd->duration = 0;
} else {
cmd->duration = duration - time(NULL); //** This is in sec NOT APR time
}
cmd->caps = caps;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = proxy_allocate_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = allocate_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_depot_modify_gop(ibp_context_t *ic, ibp_depot_t *depot, char *password, ibp_off_t hard, ibp_off_t soft,
int duration, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
if (op == NULL) return(NULL);
ibp_op_depot_modify_t *cmd = &(op->ops.depot_modify_op);
init_ibp_base_op(op, "depot_modify", timeout, op->ic->other_new_command, NULL,
op->ic->other_new_command, IBP_STATUS, IBP_ST_CHANGE);
cmd->depot = depot;
cmd->password = password;
cmd->max_hard = hard;
cmd->max_soft = soft;
cmd->max_duration = duration;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = depot_modify_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = status_get_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_split_alloc_gop(ibp_context_t *ic, ibp_cap_t *mcap, ibp_capset_t *caps, ibp_off_t size,
ibp_attributes_t *attr, int disk_cs_type, ibp_off_t disk_blocksize, int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char host[MAX_HOST_SIZE];
ibp_op_alloc_t *cmd;
int port;
init_ibp_base_op(op, "split_allocate", timeout, op->ic->other_new_command, NULL, 1, IBP_SPLIT_ALLOCATE, IBP_NOP);
cmd = &(op->ops.alloc_op);
parse_cap(op->ic, mcap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_SPLIT_ALLOCATE]));
op->dop.cmd.hostport = strdup(hoststr);
cmd = &(op->ops.alloc_op);
cmd->caps = caps;
cmd->attr = attr;
cmd->duration = cmd->attr->duration - time(NULL); //** This is in sec NOT APR time
if (cmd->duration < 0) cmd->duration = cmd->attr->duration;
cmd->size = size;
cmd->disk_chksum_type = disk_cs_type;
cmd->disk_blocksize = disk_blocksize;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = split_allocate_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = allocate_recv;
return(ibp_get_gop(op));
}
gop_op_generic_t *ibp_context_chksum_get_gop(ibp_context_t *ic, ibp_cap_t *mcap,
int chksum_info_only, int *cs_type, int *cs_size, ibp_off_t *blocksize,
ibp_off_t *nblocks, ibp_off_t *nbytes, char *buffer, ibp_off_t bufsize,
int timeout)
{
ibp_op_t *op = new_ibp_op(ic);
char hoststr[MAX_HOST_SIZE];
char host[MAX_HOST_SIZE];
ibp_op_get_chksum_t *cmd;
int port;
init_ibp_base_op(op, "get_chksum", timeout, op->ic->other_new_command, NULL, 1, IBP_VALIDATE_CHKSUM, IBP_NOP);
gop_op_generic_t *gop = ibp_get_gop(op);
cmd = &(op->ops.get_chksum_op);
parse_cap(op->ic, mcap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[IBP_VALIDATE_CHKSUM]));
op->dop.cmd.hostport = strdup(hoststr);
cmd->cap = mcap;
cmd = &(op->ops.get_chksum_op);
cmd->chksum_info_only = chksum_info_only;
cmd->cs_type = cs_type;
cmd->cs_size = cs_size;
cmd->blocksize = blocksize;
cmd->nblocks = nblocks;
cmd->n_chksumbytes = nbytes;
gop->op->cmd.send_command = get_chksum_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = get_chksum_recv;
return(ibp_get_gop(op));
}
unsigned long int IBP_phoebus_copy(char *path, ibp_cap_t *srccap, ibp_cap_t *destcap, ibp_timer_t *src_timer, ibp_timer_t *dest_timer,
ibp_off_t size, ibp_off_t offset)
{
ibp_op_t op;
int err;
make_ibp_sync_context();
init_ibp_op(_ibp_sync, &op);
set_ibp_copyappend_op(&op, NS_TYPE_PHOEBUS, path, srccap, destcap, offset, size, src_timer->ClientTimeout,
dest_timer->ServerSync, dest_timer->ClientTimeout);
err = ibp_sync_command(&op);
gop_free(ibp_get_gop(&op), OP_FINALIZE);
if (err != IBP_OK) return(0);
return(size);
}
int IBP_manage(ibp_cap_t *cap, ibp_timer_t *timer, int cmd, int captype, ibp_capstatus_t *cs)
{
ibp_op_t op;
int err;
make_ibp_sync_context();
init_ibp_op(_ibp_sync, &op);
log_printf(15, "IBP_manage: cmd=%d cap=%s cctype=%d\n", cmd, cap, op.ic->cc[IBP_MANAGE].type);
fflush(stdout);
err = 0;
switch (cmd) {
case IBP_INCR:
case IBP_DECR:
set_ibp_modify_count_op(&op, cap, cmd, captype, timer->ClientTimeout);
break;
case IBP_PROBE:
set_ibp_probe_op(&op, cap, cs, timer->ClientTimeout);
break;
case IBP_CHNG:
set_ibp_modify_alloc_op(&op, cap, cs->maxSize, cs->attrib.duration, cs->attrib.reliability, timer->ClientTimeout);
break;
default:
err = 1;
log_printf(0, "IBP_manage: Invalid command: %d\n", cmd);
}
log_printf(15, "AFTER IBP_manage: cmd=%d cap=%s cctype=%d\n", cmd, cap, op.ic->cc[IBP_MANAGE].type);
fflush(stdout);
if (err == 0) {
ibp_sync_command(&op);
} else {
IBP_errno = IBP_E_INVALID_PARAMETER;
}
gop_free(ibp_get_gop(&op), OP_FINALIZE);
if (IBP_errno != IBP_OK) return(-1);
return(0);
}
unsigned long int IBP_load(ibp_cap_t *cap, ibp_timer_t *timer, char *data,
unsigned long int size, unsigned long int offset)
{
ibp_op_t op;
int err;
tbx_tbuf_t buf;
tbx_tbuf_single(&buf, size, data);
make_ibp_sync_context();
init_ibp_op(_ibp_sync, &op);
set_ibp_read_op(&op, cap, offset, &buf, 0, size, timer->ClientTimeout);
err = ibp_sync_command(&op);
gop_free(ibp_get_gop(&op), OP_FINALIZE);
if (err != IBP_OK) return(0);
return(size);
}
void set_ibp_generic_modify_count_op(int command, ibp_op_t *op, ibp_cap_t *cap, ibp_cap_t *mcap, int mode, int captype, int timeout)
{
char hoststr[MAX_HOST_SIZE];
int port;
char host[MAX_HOST_SIZE];
ibp_op_probe_t *cmd;
if ((command != IBP_MANAGE) && (command != IBP_PROXY_MANAGE)) {
log_printf(0, "set_ibp_generic_modify_count_op: Invalid command! should be IBP_MANAGE or IBP_PROXY_MANAGE. Got %d\n", command);
return;
}
if ((mode != IBP_INCR) && (mode != IBP_DECR)) {
log_printf(0, "ibp_modify_count_gop: Invalid mode! should be IBP_INCR or IBP_DECR\n");
return;
}
if ((captype != IBP_WRITECAP) && (captype != IBP_READCAP)) {
log_printf(0, "ibp_modify_count_gop: Invalid captype! should be IBP_READCAP or IBP_WRITECAP\n");
return;
}
init_ibp_base_op(op, "modify_count", timeout, op->ic->other_new_command, NULL, 1, command, mode);
cmd = &(op->ops.probe_op);
parse_cap(op->ic, cap, host, &port, cmd->key, cmd->typekey);
set_hostport(hoststr, sizeof(hoststr), host, port, &(op->ic->cc[command]));
op->dop.cmd.hostport = strdup(hoststr);
if (command == IBP_PROXY_MANAGE) parse_cap(op->ic, mcap, host, &port, cmd->mkey, cmd->mtypekey);
cmd->cmd = command;
cmd->cap = cap;
cmd->mode = mode;
cmd->captype = captype;
gop_op_generic_t *gop = ibp_get_gop(op);
gop->op->cmd.send_command = modify_count_command;
if (command == IBP_PROXY_MANAGE) gop->op->cmd.send_command = proxy_modify_count_command;
gop->op->cmd.send_phase = NULL;
gop->op->cmd.recv_phase = status_get_recv;
}
ibp_capset_t *IBP_allocate(ibp_depot_t *depot, ibp_timer_t *timer, unsigned long int size, ibp_attributes_t *attr)
{
ibp_op_t op;
int err;
make_ibp_sync_context();
ibp_capset_t *cs = (ibp_capset_t *)malloc(sizeof(ibp_capset_t));
assert(cs != NULL);
init_ibp_op(_ibp_sync, &op);
set_ibp_alloc_op(&op, cs, size, depot, attr, CHKSUM_DEFAULT, 0, timer->ClientTimeout);
err = ibp_sync_command(&op);
gop_free(ibp_get_gop(&op), OP_FINALIZE);
if (err != IBP_OK) {
free(cs);
cs = NULL;
}
return(cs);
}
