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