int
ndmos_scsi_initialize (struct ndm_session *sess)
{
struct ndm_robot_agent * ra = &sess->robot_acb;
NDMOS_MACRO_ZEROFILL(&ra->sim_dir);
NDMOS_MACRO_ZEROFILL(&ra->scsi_state);
ra->scsi_state.error = NDMP9_DEV_NOT_OPEN_ERR;
ra->scsi_state.target_controller = ROBOT_CONTROLLER;
ra->scsi_state.target_id = ROBOT_ID;
ra->scsi_state.target_lun = ROBOT_LUN;
return 0;
}
int
main (int ac, char *av[])
{
int rc;
int port;
NDMOS_MACRO_ZEROFILL(&the_session);
d_debug = -1;
/* ready the_param early so logging works during process_args() */
NDMOS_MACRO_ZEROFILL (&the_param);
the_param.log.deliver = ndmjob_log_deliver;
the_param.log_level = d_debug;
the_param.log_tag = "SESS";
the_param.config_file_name = g_strdup_printf("%s/ndmjob.conf", amdatadir);
#ifndef NDMOS_OPTION_NO_CONTROL_AGENT
b_bsize = 20;
index_fp = stderr;
o_tape_addr = -1;
o_from_addr = -1;
o_to_addr = -1;
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */
log_fp = stderr;
if (ac != 3)
proxy_usage();
/* (config arg is ignored for now) */
port = atoi(av[2]);
if (!port)
proxy_usage();
the_session.param = the_param;
ndma_proxy_session (&the_session, port);
/* run until all open connections have closed; note that
* ndma_dispatch_proxy in ndma_comm_proxy.c will be called in each
* quantum */
while (the_session.proxy_starting || the_session.proxy_connections > 0) {
ndma_session_quantum(&the_session, 10000);
}
g_fprintf(stderr, "DONE\n");
/* NOTREACHED */
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmis_initialize (struct ndm_session *sess)
{
struct ndm_image_stream *is = &sess->plumb.image_stream;
NDMOS_MACRO_ZEROFILL(is);
NDMOS_MACRO_ZEROFILL (&is->chan);
ndmis_reinit_remote (sess);
is->data_ep.name = "DATA";
is->tape_ep.name = "TAPE";
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmis_initialize (struct ndm_session *sess)
{
sess->plumb.image_stream = NDMOS_API_MALLOC (sizeof(struct ndm_image_stream));
if (!sess->plumb.image_stream)
return -1;
NDMOS_MACRO_ZEROFILL (sess->plumb.image_stream);
NDMOS_MACRO_ZEROFILL (&sess->plumb.image_stream->chan);
ndmis_reinit_remote (sess);
sess->plumb.image_stream->data_ep.name = "DATA";
sess->plumb.image_stream->tape_ep.name = "TAPE";
return 0;
}
END ========== LOCAL ============ END
POINT POINT
REMOTE
#endif
#include "ndmagents.h"
int
ndmis_reinit_remote (struct ndm_session *sess)
{
struct ndm_image_stream *is = sess->plumb.image_stream;
struct ndm_tape_agent * ta = sess->tape_acb;
NDMOS_MACRO_ZEROFILL (&is->remote);
ndmchan_initialize (&is->remote.listen_chan, "image-stream-listen");
ndmchan_initialize (&is->remote.sanity_chan, "image-stream-sanity");
ndmchan_initialize (&is->chan, "image-stream");
if (!is->buf) {
is->buflen = ta->mover_state.record_size;
is->buf = NDMOS_API_MALLOC (is->buflen);
if (!is->buf) {
return -1;
}
NDMOS_MACRO_ZEROFILL_SIZE (is->buf, is->buflen);
}
ndmchan_setbuf (&is->chan, is->buf, is->buflen);
return 0;
}
void ndmda_fh_flush(struct ndm_session* sess)
{
struct ndm_data_agent* da = sess->data_acb;
struct ndmfhheap* fhh = &da->fhh;
int rc;
int fhtype;
void* table;
unsigned n_entry;
rc = ndmfhh_get_table(fhh, &fhtype, &table, &n_entry);
if (rc == NDMFHH_RET_OK && n_entry > 0) {
struct ndmp_xa_buf xa;
struct ndmfhh_generic_table* request;
request = (void*)&xa.request.body;
NDMOS_MACRO_ZEROFILL(&xa);
xa.request.protocol_version = fhtype >> 16;
xa.request.header.message = fhtype & 0xFFFF;
request->table_len = n_entry;
request->table_val = table;
ndma_send_to_control(sess, &xa, sess->plumb.data);
}
ndmfhh_reset(fhh);
}
int
ndmfhh_initialize (struct ndmfhheap *fhh)
{
NDMOS_MACRO_ZEROFILL (fhh);
return NDMFHH_RET_OK;
}
int
build_job (void)
{
struct ndm_job_param * job = &the_job;
int i, rc, n_err;
char errbuf[100];
NDMOS_MACRO_ZEROFILL(job);
args_to_job ();
ndma_job_auto_adjust (job);
if (o_rules)
apply_rules (job, o_rules);
i = n_err = 0;
do {
rc = ndma_job_audit (job, errbuf, i);
if (rc > n_err || rc < 0) {
ndmjob_log (0, "error: %s", errbuf);
}
n_err = rc;
} while (i++ < n_err);
if (n_err) {
error_byebye ("can't proceed");
/* no return */
}
return 0;
}
/*
* Media list mgmt.
*
* Create a new media entry and add it to the Media Table.
* Return entry if caller want to modify it.
*/
struct ndmmedia *
ndma_store_media (struct ndm_media_table *mtab, uint16_t element_address)
{
struct ndmmedia * me;
if (mtab->n_media >= NDM_MAX_MEDIA)
return NULL;
me = NDMOS_API_MALLOC (sizeof(struct ndmmedia));
if (!me) {
return NULL;
}
NDMOS_MACRO_ZEROFILL (me);
me->valid_slot = 1;
me->slot_addr = element_address;
me->index = mtab->n_media + 1;
me->next = NULL;
if (mtab->tail) {
mtab->tail->next = me;
mtab->tail = me;
} else {
mtab->head = me;
mtab->tail = me;
}
mtab->n_media++;
return me;
}
END ========== LOCAL ============ END
POINT POINT
REMOTE
#endif
#include "ndmagents.h"
int
ndmis_reinit_remote (struct ndm_session *sess)
{
struct ndm_image_stream *is = &sess->plumb.image_stream;
NDMOS_MACRO_ZEROFILL(&is->remote);
ndmchan_initialize (&is->remote.listen_chan, "image-stream-listen");
ndmchan_initialize (&is->remote.sanity_chan, "image-stream-sanity");
ndmchan_initialize (&is->chan, "image-stream");
ndmchan_setbuf (&is->chan, is->buf, sizeof is->buf);
return 0;
}
int
ndmmedia_from_str (struct ndmmedia *me, char *str)
{
char * p;
char * q;
int c;
NDMOS_MACRO_ZEROFILL (me);
p = str;
q = me->label;
for (; *p; p++) {
c = *p;
if (c == '+' || c == '@' || c == '/')
break;
if (q < &me->label[NDMMEDIA_LABEL_MAX])
*q++ = c;
}
*q = 0;
if (q > me->label)
me->valid_label = 1;
while (*p) {
c = *p;
switch (c) {
default:
return -1; /* what is this? */
case '@':
if (me->valid_slot)
return -2;
me->slot_addr = strtol (p+1, &p, 0);
me->valid_slot = 1;
break;
case '+':
if (me->valid_filemark)
return -3;
me->file_mark_offset = strtol (p+1, &p, 0);
me->valid_filemark = 1;
break;
case '/':
if (me->valid_n_bytes)
return -4;
me->n_bytes = ndmmedia_strtoll (p+1, &p, 0);
me->valid_n_bytes = 1;
break;
}
}
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int ndmca_initialize(struct ndm_session* sess)
{
sess->control_acb = NDMOS_API_MALLOC(sizeof(struct ndm_control_agent));
if (!sess->control_acb) { return -1; }
NDMOS_MACRO_ZEROFILL(sess->control_acb);
return 0;
}
/*
* Initialize a channel. Make sure it won't be confused for active.
*/
void
ndmchan_initialize (struct ndmchan *ch, char *name)
{
NDMOS_MACRO_ZEROFILL(ch);
ch->name = name ? name : "???";
ch->fd = -1;
ch->mode = NDMCHAN_MODE_IDLE;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmra_initialize (struct ndm_session *sess)
{
struct ndm_robot_agent *ra = &sess->robot_acb;
NDMOS_MACRO_ZEROFILL(ra);
ra->scsi_state.error = NDMP9_DEV_NOT_OPEN_ERR;
return 0;
}
ndmp9_error
ndmis_ep_listen (
struct ndm_session *sess,
ndmp9_addr_type addr_type,
ndmp9_addr *ret_addr,
char *reason,
struct ndmis_end_point *mine_ep,
struct ndmis_end_point *peer_ep)
{
struct ndm_image_stream *is = &sess->plumb.image_stream;
char * reason_end;
ndmp9_error error;
error = ndmis_audit_ep_listen (sess, addr_type, reason,
mine_ep, peer_ep);
if (error != NDMP9_NO_ERR)
return error;
reason_end = reason;
while (*reason_end && *reason_end != ':') reason_end++;
*reason_end++ = ':'; *reason_end++ = ' '; *reason_end = 0;
NDMOS_MACRO_ZEROFILL (ret_addr);
ret_addr->addr_type = addr_type;
switch (addr_type) {
case NDMP9_ADDR_LOCAL:
mine_ep->addr_type = NDMP9_ADDR_LOCAL;
mine_ep->connect_status = NDMIS_CONN_LISTEN;
is->remote.connect_status = NDMIS_CONN_EXCLUDE;
break;
case NDMP9_ADDR_TCP:
if (ndmis_tcp_listen (sess, ret_addr) != 0) {
strcpy (reason_end, "TCP listen() failed");
error = NDMP9_CONNECT_ERR;
goto out;
}
mine_ep->addr_type = NDMP9_ADDR_TCP;
mine_ep->connect_status = NDMIS_CONN_LISTEN;
peer_ep->connect_status = NDMIS_CONN_REMOTE;
break;
default:
reason = "unknown addr_type (bad)";
error = NDMP9_ILLEGAL_ARGS_ERR;
goto out;
}
out:
if (error == NDMP9_NO_ERR)
strcpy (reason_end, "OK");
return error;
}
int
ndmos_tape_initialize (struct ndm_session *sess)
{
struct ndm_tape_agent * ta = &sess->tape_acb;
ta->tape_fd = -1;
NDMOS_MACRO_ZEROFILL (&ta->tape_state);
ta->tape_state.error = NDMP9_DEV_NOT_OPEN_ERR;
ta->tape_state.state = NDMP9_TAPE_STATE_IDLE;
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmta_initialize (struct ndm_session *sess)
{
struct ndm_tape_agent * ta = &sess->tape_acb;
int rc;
NDMOS_MACRO_ZEROFILL(ta);
ndmta_commission (sess);
rc = ndmos_tape_initialize (sess);
if (rc) return rc;
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmda_initialize (struct ndm_session *sess)
{
sess->data_acb = NDMOS_API_MALLOC (sizeof(struct ndm_data_agent));
if (!sess->data_acb)
return -1;
NDMOS_MACRO_ZEROFILL (sess->data_acb);
sess->data_acb->data_state.state = NDMP9_DATA_STATE_IDLE;
ndmchan_initialize (&sess->data_acb->formatter_error, "dfp-error");
ndmchan_initialize (&sess->data_acb->formatter_wrap, "dfp-wrap");
ndmchan_initialize (&sess->data_acb->formatter_image, "dfp-image");
ndmda_fh_initialize (sess);
return 0;
}
/* Initialize -- Set data structure to know value, ignore current value */
int
ndmta_initialize (struct ndm_session *sess)
{
int rc;
sess->tape_acb = NDMOS_API_MALLOC (sizeof(struct ndm_tape_agent));
if (!sess->tape_acb)
return -1;
NDMOS_MACRO_ZEROFILL (sess->tape_acb);
ndmta_commission (sess);
rc = ndmos_tape_initialize (sess);
if (rc) return rc;
return 0;
}
/* helper for mover state */
int
ndmta_init_mover_state (struct ndm_session *sess)
{
struct ndm_tape_agent * ta = &sess->tape_acb;
NDMOS_MACRO_ZEROFILL (&ta->mover_state);
ta->mover_state.state = NDMP9_MOVER_STATE_IDLE;
ta->mover_state.window_offset = 0;
ta->mover_state.record_size = 20*512; /* traditional tar default */
ta->mover_state.window_length = NDMP_LENGTH_INFINITY;
ta->mover_window_end = NDMP_LENGTH_INFINITY;
ta->mover_want_pos = 0;
ta->tb_blockno = -1;
return 0;
}
int
ndmca_mover_get_state (struct ndm_session *sess)
{
struct ndmconn * conn = sess->plumb.tape;
struct ndm_control_agent *ca = &sess->control_acb;
struct ndmp9_mover_get_state_reply *state = &ca->mover_state;
int rc;
NDMC_WITH_VOID_REQUEST(ndmp9_mover_get_state, NDMP9VER)
rc = NDMC_CALL(conn);
if (rc) {
NDMOS_MACRO_ZEROFILL (state);
ca->mover_state.state = -1;
} else {
*state = *reply;
}
NDMC_ENDWITH
return rc;
}
int ndmfhdb_open(FILE* fp, struct ndmfhdb* fhcb)
{
int rc;
NDMOS_MACRO_ZEROFILL(fhcb);
fhcb->fp = fp;
rc = ndmfhdb_dirnode_root(fhcb);
if (rc > 0) {
fhcb->use_dir_node = 1;
return 0;
}
rc = ndmfhdb_file_root(fhcb);
if (rc > 0) {
fhcb->use_dir_node = 0;
return 0;
}
return -1;
}
int
ndmos_chan_poll (struct ndmchan *chtab[], unsigned n_chtab, int milli_timo)
{
struct ndmchan * ch;
struct pollfd pfdtab[20];
int n_pfdtab = 0;
int rc, i;
NDMOS_MACRO_ZEROFILL (pfdtab);
for (i = 0; i < n_chtab; i++) {
ch = chtab[i];
if (!ch->check)
continue;
switch (ch->mode) {
case NDMCHAN_MODE_LISTEN:
case NDMCHAN_MODE_READCHK:
case NDMCHAN_MODE_READ:
pfdtab[n_pfdtab].fd = ch->fd;
pfdtab[n_pfdtab].events = POLLIN;
break;
case NDMCHAN_MODE_WRITE:
pfdtab[n_pfdtab].fd = ch->fd;
pfdtab[n_pfdtab].events = POLLOUT;
break;
}
n_pfdtab++;
}
rc = poll (pfdtab, n_pfdtab, milli_timo);
@@@ TODO: post them back. Not easy @@@
return rc;
}
int
ndmca_tape_get_state_no_tattle (struct ndm_session *sess)
{
struct ndmconn * conn = sess->plumb.tape;
struct ndm_control_agent *ca = &sess->control_acb;
struct ndmp9_tape_get_state_reply *state = &ca->tape_state;
int rc;
NDMC_WITH_VOID_REQUEST(ndmp9_tape_get_state, NDMP9VER)
rc = ndma_call_no_tattle (conn, xa);
if (rc) {
NDMOS_MACRO_ZEROFILL (state);
/* tape_state.state = -1; */
} else {
*state = *reply;
}
if (rc < 0
|| (reply->error != NDMP9_DEV_NOT_OPEN_ERR
&& reply->error != NDMP9_NO_ERR))
ndma_tattle (sess->plumb.tape, xa, rc);
NDMC_ENDWITH
return rc;
}
int ndm_fstat_from_str(ndmp9_file_stat* fstat, char* buf)
{
char* scan = buf;
ndmp9_validity* valid_p;
NDMOS_MACRO_ZEROFILL(fstat);
while (*scan) {
char* p = scan + 1;
switch (*scan) {
case ' ':
scan++;
continue;
case '@': /* fh_info */
fstat->fh_info.value = NDMOS_API_STRTOLL(p, &scan, 0);
valid_p = &fstat->fh_info.valid;
break;
case 's': /* size */
fstat->size.value = NDMOS_API_STRTOLL(p, &scan, 0);
valid_p = &fstat->size.valid;
break;
case 'i': /* fileno (inum) */
fstat->node.value = NDMOS_API_STRTOLL(p, &scan, 0);
valid_p = &fstat->node.valid;
break;
case 'm': /* mode low twelve bits */
fstat->mode.value = strtol(p, &scan, 8);
valid_p = &fstat->mode.valid;
break;
case 'l': /* link count */
fstat->links.value = strtol(p, &scan, 0);
valid_p = &fstat->links.valid;
break;
case 'u': /* uid */
fstat->uid.value = strtol(p, &scan, 0);
valid_p = &fstat->uid.valid;
break;
case 'g': /* gid */
fstat->gid.value = strtol(p, &scan, 0);
valid_p = &fstat->gid.valid;
break;
case 't': /* one of the times */
p = scan + 2;
switch (scan[1]) {
case 'm': /* mtime */
fstat->mtime.value = strtol(p, &scan, 0);
valid_p = &fstat->mtime.valid;
break;
case 'a': /* atime */
fstat->atime.value = strtol(p, &scan, 0);
valid_p = &fstat->atime.valid;
break;
case 'c': /* ctime */
fstat->ctime.value = strtol(p, &scan, 0);
valid_p = &fstat->ctime.valid;
break;
default:
return -13;
}
break;
case 'f': /* ftype (file type) */
switch (scan[1]) {
case 'd':
fstat->ftype = NDMP9_FILE_DIR;
break;
case 'p':
fstat->ftype = NDMP9_FILE_FIFO;
break;
case 'c':
fstat->ftype = NDMP9_FILE_CSPEC;
break;
case 'b':
fstat->ftype = NDMP9_FILE_BSPEC;
break;
case '-':
fstat->ftype = NDMP9_FILE_REG;
break;
case 'l':
fstat->ftype = NDMP9_FILE_SLINK;
break;
case 's':
fstat->ftype = NDMP9_FILE_SOCK;
break;
case 'R':
fstat->ftype = NDMP9_FILE_REGISTRY;
break;
case 'o':
fstat->ftype = NDMP9_FILE_OTHER;
break;
default:
fstat->ftype = NDMP9_FILE_OTHER;
return -15;
}
scan += 2;
valid_p = 0;
break;
default:
return -13;
}
if (*scan != ' ' && *scan != 0) return -11;
if (valid_p) *valid_p = NDMP9_VALIDITY_VALID;
}
return 0;
}
ndmp9_error
ndmos_scsi_execute_cdb (struct ndm_session *sess,
ndmp9_execute_cdb_request *request,
ndmp9_execute_cdb_reply *reply)
{
struct ndm_robot_agent *robot = sess->robot_acb;
struct cam_device * camdev = robot->camdev;
union ccb * ccb;
u_int32_t flags;
u_int8_t * data_ptr = 0;
u_int8_t * data_in_ptr = 0;
u_int32_t data_len = 0;
u_int32_t data_done;
int rc;
NDMOS_MACRO_ZEROFILL (reply);
reply->error = NDMP9_IO_ERR; /* pessimistic */
ccb = cam_getccb(camdev);
if (!ccb) {
reply->error = NDMP9_NO_MEM_ERR;
return reply->error;
}
switch (request->data_dir) {
case NDMP9_SCSI_DATA_DIR_NONE:
flags = CAM_DIR_NONE;
break;
case NDMP9_SCSI_DATA_DIR_IN:
if (data_len > 1024*1024) {
reply->error = NDMP9_ILLEGAL_ARGS_ERR;
goto out;
}
data_len = request->datain_len;
data_in_ptr = malloc (data_len);
if (!data_in_ptr) {
reply->error = NDMP9_NO_MEM_ERR;
goto out;
}
data_ptr = data_in_ptr;
flags = CAM_DIR_IN;
break;
case NDMP9_SCSI_DATA_DIR_OUT:
data_len = request->dataout.dataout_len;
data_ptr = request->dataout.dataout_val;
flags = CAM_DIR_OUT;
break;
default:
return NDMP9_ILLEGAL_ARGS_ERR;
break;
}
bcopy(request->cdb.cdb_val, &ccb->csio.cdb_io.cdb_bytes,
request->cdb.cdb_len);
cam_fill_csio(&ccb->csio,
/*retries*/ 1,
/*cbfcnp*/ NULL,
/*flags*/ flags,
/*tag_action*/ MSG_SIMPLE_Q_TAG,
/*data_ptr*/ data_ptr,
/*dxfer_len*/ data_len,
/*sense_len*/ SSD_FULL_SIZE,
/*cdb_len*/ request->cdb.cdb_len,
/*timeout*/ request->timeout);
rc = cam_send_ccb (camdev, ccb);
if (rc != 0) {
reply->error = NDMP9_IO_ERR;
goto out;
}
switch (ccb->csio.ccb_h.status & CAM_STATUS_MASK) {
case CAM_REQ_CMP: /* completed */
reply->error = NDMP9_NO_ERR;
break;
case CAM_SEL_TIMEOUT:
case CAM_CMD_TIMEOUT:
reply->error = NDMP9_TIMEOUT_ERR;
break;
case CAM_SCSI_STATUS_ERROR:
if (ccb->csio.ccb_h.status & CAM_AUTOSNS_VALID) {
int n_sense;
n_sense = ccb->csio.sense_len - ccb->csio.sense_resid;
reply->ext_sense.ext_sense_val = malloc (n_sense);
if (reply->ext_sense.ext_sense_val) {
bcopy (&ccb->csio.sense_data,
reply->ext_sense.ext_sense_val,
n_sense);
reply->ext_sense.ext_sense_len = n_sense;
}
}
reply->error = NDMP9_NO_ERR;
break;
default:
reply->error = NDMP9_IO_ERR;
break;
}
out:
if (reply->error == NDMP9_NO_ERR) {
reply->status = ccb->csio.scsi_status;
data_done = data_len - ccb->csio.resid;
switch (request->data_dir) {
case NDMP9_SCSI_DATA_DIR_NONE:
break;
case NDMP9_SCSI_DATA_DIR_IN:
reply->datain.datain_val = data_in_ptr;
reply->datain.datain_len = data_len;
break;
case NDMP9_SCSI_DATA_DIR_OUT:
reply->dataout_len = data_len;
break;
default:
break;
}
} else {
if (data_in_ptr) {
free (data_in_ptr);
data_in_ptr = 0;
}
}
cam_freeccb (ccb);
return reply->error;
}
int
main (int ac, char *av[])
{
int rc;
set_pname("ndmjob");
dbopen(DBG_SUBDIR_CLIENT);
config_init(0, NULL);
NDMOS_MACRO_ZEROFILL(&the_session);
d_debug = -1;
/* ready the_param early so logging works during process_args() */
NDMOS_MACRO_ZEROFILL (&the_param);
the_param.log.deliver = ndmjob_log_deliver;
the_param.log_level = 0;
the_param.log_tag = "SESS";
#ifndef NDMOS_OPTION_NO_CONTROL_AGENT
b_bsize = 20;
index_fp = stderr;
o_tape_addr = -1;
o_from_addr = -1;
o_to_addr = -1;
p_ndmp_port = NDMPPORT;
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */
process_args (ac, av);
if (the_param.log_level < d_debug)
the_param.log_level = d_debug;
if (the_param.log_level < v_verbose)
the_param.log_level = v_verbose;
the_param.config_file_name = o_config_file;
if (the_mode == NDM_JOB_OP_DAEMON || the_mode == NDM_JOB_OP_TEST_DAEMON) {
the_session.param = the_param;
if (n_noop) {
dump_settings();
return 0;
}
ndma_daemon_session (&the_session, p_ndmp_port, the_mode == NDM_JOB_OP_TEST_DAEMON);
return 0;
}
#ifndef NDMOS_OPTION_NO_CONTROL_AGENT
the_session.control_acb.swap_connect = (o_swap_connect != 0);
build_job(); /* might not return */
the_session.param = the_param;
the_session.control_acb.job = the_job;
if (n_noop) {
dump_settings();
return 0;
}
start_index_file ();
rc = ndma_client_session (&the_session);
sort_index_file ();
if (rc == 0)
ndmjob_log (1, "Operation complete");
else
ndmjob_log (1, "Operation complete but had problems.");
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */
dbclose();
return 0;
}
int
ndmis_ep_close (struct ndm_session *sess,
struct ndmis_end_point *mine_ep, struct ndmis_end_point *peer_ep)
{
struct ndm_image_stream *is = &sess->plumb.image_stream;
char * save_name = mine_ep->name;
switch (mine_ep->connect_status) {
case NDMIS_CONN_IDLE:
return 0;
case NDMIS_CONN_BOTCHED:
case NDMIS_CONN_REMOTE:
case NDMIS_CONN_EXCLUDE:
goto messy;
case NDMIS_CONN_LISTEN:
switch (mine_ep->addr_type) {
default:
goto messy;
case NDMP9_ADDR_LOCAL:
ndmis_reinit_remote (sess);
if (peer_ep->connect_status != NDMIS_CONN_IDLE)
goto messy;
break;
case NDMP9_ADDR_TCP:
ndmis_tcp_close (sess);
if (peer_ep->connect_status != NDMIS_CONN_REMOTE)
goto messy;
peer_ep->connect_status = NDMIS_CONN_IDLE;
break;
}
break;
case NDMIS_CONN_ACCEPTED:
switch (mine_ep->addr_type) {
default:
goto messy;
case NDMP9_ADDR_LOCAL:
if (peer_ep->connect_status != NDMIS_CONN_CONNECTED)
goto messy;
peer_ep->connect_status = NDMIS_CONN_DISCONNECTED;
is->chan.eof = 1;
if (mine_ep->transfer_mode == NDMCHAN_MODE_READ)
is->chan.error = 1; /* EPIPE */
break;
case NDMP9_ADDR_TCP:
ndmis_tcp_close (sess);
if (peer_ep->connect_status != NDMIS_CONN_REMOTE)
goto messy;
peer_ep->connect_status = NDMIS_CONN_IDLE;
break;
}
break;
case NDMIS_CONN_CONNECTED:
switch (mine_ep->addr_type) {
default:
goto messy;
case NDMP9_ADDR_LOCAL:
if (peer_ep->connect_status != NDMIS_CONN_ACCEPTED)
goto messy;
peer_ep->connect_status = NDMIS_CONN_DISCONNECTED;
is->chan.eof = 1;
if (mine_ep->transfer_mode == NDMCHAN_MODE_READ)
is->chan.error = 1; /* EPIPE */
break;
case NDMP9_ADDR_TCP:
ndmis_tcp_close (sess);
if (peer_ep->connect_status != NDMIS_CONN_REMOTE)
goto messy;
peer_ep->connect_status = NDMIS_CONN_IDLE;
break;
}
break;
case NDMIS_CONN_DISCONNECTED: /* peer close()d first */
ndmis_reinit_remote (sess);
break;
case NDMIS_CONN_CLOSED:
goto messy;
}
NDMOS_MACRO_ZEROFILL (mine_ep);
mine_ep->name = save_name;
return 0;
messy:
ndmalogf (sess, 0, 2, "close %s messy mcs=%d pcs=%d",
mine_ep->name,
mine_ep->connect_status,
peer_ep->connect_status);
NDMOS_MACRO_ZEROFILL (mine_ep);
mine_ep->name = save_name;
return -1;
}
int
main (int ac, char *av[])
{
int rc;
NDMOS_MACRO_ZEROFILL (&E_environment);
NDMOS_MACRO_ZEROFILL (&ji_environment);
NDMOS_MACRO_ZEROFILL (&m_media);
NDMOS_MACRO_ZEROFILL (&ji_media);
NDMOS_MACRO_ZEROFILL (&the_session);
d_debug = -1;
/* ready the_param early so logging works during process_args() */
NDMOS_MACRO_ZEROFILL (&the_param);
the_param.log.deliver = ndmjob_log_deliver;
the_param.log_level = 0;
the_param.log_tag = "SESS";
#ifndef NDMOS_OPTION_NO_CONTROL_AGENT
b_bsize = 20;
index_fp = stderr;
o_tape_addr = -1;
o_from_addr = -1;
o_to_addr = -1;
p_ndmp_port = NDMPPORT;
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */
log_fp = stderr;
process_args (ac, av);
if (the_param.log_level < d_debug)
the_param.log_level = d_debug;
if (the_param.log_level < v_verbose)
the_param.log_level = v_verbose;
the_param.config_file_name = o_config_file;
if (the_mode == NDM_JOB_OP_DAEMON) {
the_session.param = &the_param;
if (n_noop) {
dump_settings ();
exit_program ();
}
ndma_daemon_session (&the_session, p_ndmp_port);
exit_program ();
}
ndmjob_register_callbacks (&the_session, &the_param.log);
#ifndef NDMOS_OPTION_NO_CONTROL_AGENT
build_job(); /* might not return */
the_session.param = &the_param;
if (n_noop) {
dump_settings ();
exit_program ();
}
start_index_file ();
rc = ndma_client_session (&the_session, &the_job, (o_swap_connect != 0));
sort_index_file ();
if (rc == 0)
ndmjob_log (1, "Operation complete");
else
ndmjob_log (1, "Operation complete but had problems.");
#endif /* !NDMOS_OPTION_NO_CONTROL_AGENT */
exit_program ();
}
void
ndmp9_fstat_from_wrap_fstat (ndmp9_file_stat *fstat9,
struct wrap_fstat *fstatw)
{
NDMOS_MACRO_ZEROFILL (fstat9);
switch (fstatw->ftype) {
default:
case WRAP_FTYPE_INVALID:fstat9->ftype = NDMP9_FILE_OTHER; break;
case WRAP_FTYPE_DIR: fstat9->ftype = NDMP9_FILE_DIR; break;
case WRAP_FTYPE_FIFO: fstat9->ftype = NDMP9_FILE_FIFO; break;
case WRAP_FTYPE_CSPEC: fstat9->ftype = NDMP9_FILE_CSPEC; break;
case WRAP_FTYPE_BSPEC: fstat9->ftype = NDMP9_FILE_BSPEC; break;
case WRAP_FTYPE_REG: fstat9->ftype = NDMP9_FILE_REG; break;
case WRAP_FTYPE_SLINK: fstat9->ftype = NDMP9_FILE_SLINK; break;
case WRAP_FTYPE_SOCK: fstat9->ftype = NDMP9_FILE_SOCK; break;
case WRAP_FTYPE_REGISTRY:fstat9->ftype = NDMP9_FILE_REGISTRY; break;
case WRAP_FTYPE_OTHER: fstat9->ftype = NDMP9_FILE_OTHER; break;
}
if (fstatw->valid & WRAP_FSTAT_VALID_FTYPE) {
}
if (fstatw->valid & WRAP_FSTAT_VALID_MODE) {
fstat9->mode.valid = NDMP9_VALIDITY_VALID;
fstat9->mode.value = fstatw->mode;
}
if (fstatw->valid & WRAP_FSTAT_VALID_SIZE) {
fstat9->size.valid = NDMP9_VALIDITY_VALID;
fstat9->size.value = fstatw->size;
}
if (fstatw->valid & WRAP_FSTAT_VALID_LINKS) {
fstat9->links.valid = NDMP9_VALIDITY_VALID;
fstat9->links.value = fstatw->size;
}
if (fstatw->valid & WRAP_FSTAT_VALID_UID) {
fstat9->uid.valid = NDMP9_VALIDITY_VALID;
fstat9->uid.value = fstatw->uid;
}
if (fstatw->valid & WRAP_FSTAT_VALID_GID) {
fstat9->gid.valid = NDMP9_VALIDITY_VALID;
fstat9->gid.value = fstatw->gid;
}
if (fstatw->valid & WRAP_FSTAT_VALID_ATIME) {
fstat9->atime.valid = NDMP9_VALIDITY_VALID;
fstat9->atime.value = fstatw->atime;
}
if (fstatw->valid & WRAP_FSTAT_VALID_MTIME) {
fstat9->mtime.valid = NDMP9_VALIDITY_VALID;
fstat9->mtime.value = fstatw->mtime;
}
if (fstatw->valid & WRAP_FSTAT_VALID_CTIME) {
fstat9->ctime.valid = NDMP9_VALIDITY_VALID;
fstat9->ctime.value = fstatw->ctime;
}
if (fstatw->valid & WRAP_FSTAT_VALID_FILENO) {
fstat9->node.valid = NDMP9_VALIDITY_VALID;
fstat9->node.value = fstatw->fileno;
}
}
