/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I s M a g i c k C o n f l i c t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % VMSIsMagickConflict() returns true if the image format conflicts with a % logical drive (.e.g. SYS$SCRATCH:). % % Contributed by Forrest Cahoon ([email protected]) % % The format of the VMSIsMagickConflict method is: % % MagickBooleanType VMSIsMagickConflict(const char *magick) % % A description of each parameter follows: % % o magick: Specifies the image format. % % */ MagickExport MagickBooleanType VMSIsMagickConflict(const char *magick) { ile3 item_list[2]; int device_class, status; struct dsc$descriptor_s device; assert(magick != (char *) NULL); device.dsc$w_length=strlen(magick); device.dsc$a_pointer=(char *) magick; device.dsc$b_class=DSC$K_CLASS_S; device.dsc$b_dtype=DSC$K_DTYPE_T; item_list[0].ile3$w_length=sizeof(device_class); item_list[0].ile3$w_code=DVI$_DEVCLASS; item_list[0].ile3$ps_bufaddr=&device_class; item_list[0].ile3$ps_retlen_addr=NULL; (void) ResetMagickMemory(&item_list[1],0,sizeof(item_list[1])); status=sys$getdviw(0,0,&device,&item_list,0,0,0,0); if ((status == SS$_NONLOCAL) || ((status & 0x01) && (device_class & (DC$_DISK | DC$_TAPE)))) return(MagickTrue); return(MagickFalse); }
int lib$getdvi(signed int * item_code, unsigned short int * channel, void * device_name, signed int * longword_integer_value, void * resultant_string, unsigned short * resultant_length) {
struct _iosb iosb;
struct item_list_3 itmlst[2];
int retlen;
int * retlenaddr;
int buflen;
void * bufaddr;
struct dsc$descriptor * dsc;
struct dsc$descriptor * devnam = device_name;
struct dsc$descriptor * res = resultant_string;
int sts;
int efn;
sts = lib$get_ef(&efn);
if ((sts&1)==0)
return sts;
// doing some approximations since I can not now decide the return type
if (longword_integer_value) {
buflen = 4;
bufaddr = longword_integer_value;
retlenaddr = &retlen;
} else {
buflen = res->dsc$w_length;
bufaddr = res->dsc$a_pointer;
if (resultant_length)
retlenaddr = resultant_length;
else
retlenaddr = &retlen;
}
itmlst[0].item_code=*item_code;
itmlst[0].buflen=buflen;
itmlst[0].retlenaddr=retlenaddr;
itmlst[0].bufaddr=bufaddr;
itmlst[1].item_code=0;
int chan = 0;
if (channel)
chan = *channel;
sts=sys$getdviw(efn,chan,devnam,itmlst,&iosb,0,0,0);
if ((sts&1)==0)
return sts;
sts = lib$free_ef(&efn);
if ((sts&1)==0)
return sts;
return sts;
}
short iott_open(io_log_name *dev_name, mval *pp, int fd, mval *mspace, int4 timeout)
{
bool ast_get_static(int); /* TODO; move to a header */
unsigned char buf[256], ch, sensemode[8];
short dummy;
int4 bufsz, devtype, buflen;
uint4 status;
unsigned int req_code;
d_tt_struct *tt_ptr;
io_desc *ioptr;
iosb dvisb;
t_cap t_mode;
int p_offset;
struct
{
item_list_3 item[1];
int4 terminator;
} item_list;
DCL_THREADGBL_ACCESS;
SETUP_THREADGBL_ACCESS;
ioptr = dev_name->iod;
if (dev_never_opened == ioptr->state)
ioptr->dev_sp = (d_tt_struct *)(malloc(SIZEOF(d_tt_struct)));
tt_ptr = (d_tt_struct *)ioptr->dev_sp;
if (dev_open != ioptr->state)
{
short channel;
$DESCRIPTOR(file_name, "");
if (FALSE == ast_get_static(TERMINAL_STATIC_ASTS))
rts_error(VARLSTCNT(1) ERR_TERMASTQUOTA);
file_name.dsc$a_pointer = dev_name->dollar_io;
file_name.dsc$w_length = (unsigned short)dev_name->len;
if (SS$_DEVALLOC == (status = sys$assign(&file_name, &channel, 0, 0))
|| (SS$_INSFMEM == status) || (SS$_NOIOCHAN == status))
{
astq_dyn_avail += TERMINAL_STATIC_ASTS;
astq_dyn_alloc += TERMINAL_STATIC_ASTS;
return FALSE;
}
if ((SS$_NORMAL != status) && (SS$_REMOTE != status))
{
astq_dyn_avail += TERMINAL_STATIC_ASTS;
rts_error(VARLSTCNT(1) status);
}
tt_ptr->channel = (int4)channel;
tt_ptr->io_pending = tt_ptr->io_inuse =
tt_ptr->io_free = tt_ptr->io_buffer = malloc(RING_BUF_SZ);
tt_ptr->io_buftop = tt_ptr->io_buffer + RING_BUF_SZ;
tt_ptr->sb_pending = tt_ptr->sb_free = tt_ptr->sb_buffer =
malloc(IOSB_BUF_SZ * SIZEOF(iosb_struct));
tt_ptr->sb_buftop = tt_ptr->sb_buffer + IOSB_BUF_SZ;
}
if (dev_never_opened == ioptr->state)
{
status = sys$qiow(EFN$C_ENF, tt_ptr->channel, IO$_SENSEMODE,
&tt_ptr->stat_blk, 0, 0, &t_mode, 12, 0, 0, 0, 0);
if (SS$_NORMAL == status)
status = tt_ptr->stat_blk.status;
if (SS$_NORMAL != status)
{
astq_dyn_avail += TERMINAL_STATIC_ASTS;
rts_error(VARLSTCNT(1) status);
}
tt_ptr->read_mask = IO_FUNC_R;
tt_ptr->write_mask = IO_FUNC_W;
tt_ptr->clock_on = FALSE;
tt_ptr->term_char = t_mode.term_char;
tt_ptr->ext_cap = t_mode.ext_cap;
ioptr->width = t_mode.pg_width;
ioptr->length = t_mode.pg_length;
tt_ptr->in_buf_sz = TTDEF_BUF_SZ;
tt_ptr->term_chars_twisted = FALSE;
tt_ptr->enbld_outofbands.x = 0;
if ((spc_inp_prc & (SHFT_MSK << CTRL_U)) && (tt_ptr->term_char & TT$M_SCOPE)
&& !(tt_ptr->ext_cap & TT2$M_PASTHRU))
tt_ptr->ctrlu_msk = (SHFT_MSK << CTRL_U);
else
tt_ptr->ctrlu_msk = 0;
if (io_std_device.in)
/* if this is the principal device, io_std_device.in is not yet set up, therefore
the resetast is done later in term_setup so that it can pick the correct handler */
iott_resetast(ioptr);
status = sys$qiow(EFN$C_ENF, tt_ptr->channel
,IO$_SENSEMODE|IO$M_RD_MODEM
,&tt_ptr->stat_blk, 0, 0
,sensemode
,0, 0, 0, 0, 0);
/* The first time this code is called is to open the principal device
* and io_root_log_name->iod will be == 0, when that is true we do
* not want to do the lat connect even if it is a lat device */
if ((SS$_NORMAL == status) && (SS$_NORMAL == tt_ptr->stat_blk.status) &&
(DT$_LAT == sensemode[0]) && (0 != io_root_log_name->iod))
{
status = sys$qiow(EFN$C_ENF, tt_ptr->channel,
IO$_TTY_PORT|IO$M_LT_CONNECT,
&tt_ptr->stat_blk, 0, 0, 0, 0, 0, 0, 0, 0);
/* If we try to open the principal device with a statement like
* open "LTA66:" we will come through here and will get the
* illegal io function error...just ignore it */
if (SS$_NORMAL == status)
status = tt_ptr->stat_blk.status;
if ((SS$_NORMAL != status) && (SS$_ILLIOFUNC != status))
{
astq_dyn_avail += TERMINAL_STATIC_ASTS;
rts_error(VARLSTCNT(1) status);
}
}
item_list.item[0].buffer_length = SIZEOF(devtype);
item_list.item[0].item_code = DVI$_DEVTYPE;
item_list.item[0].buffer_address = &devtype;
item_list.item[0].return_length_address = &dummy;
item_list.terminator = 0;
status = sys$getdviw(EFN$C_ENF, tt_ptr->channel, 0, &item_list, &dvisb, 0, 0, 0);
if (SS$_NORMAL == status)
status = dvisb.status;
if (SS$_NORMAL != status)
rts_error(VARLSTCNT(1) status);
status = smg$init_term_table_by_type(&devtype, &tt_ptr->term_tab_entry, 0);
if (!(status & 1))
{
tt_ptr->erase_to_end_line.len = 0;
tt_ptr->key_up_arrow.len = 0;
tt_ptr->key_down_arrow.len = 0;
tt_ptr->clearscreen.len = 0;
} else
{
bufsz = SIZEOF(buf);
req_code = SMG$K_ERASE_TO_END_LINE;
status = smg$get_term_data(&tt_ptr->term_tab_entry, &req_code, &bufsz, &buflen, buf, 0);
if (status & 1)
{
tt_ptr->erase_to_end_line.len = buflen;
tt_ptr->erase_to_end_line.addr = malloc(tt_ptr->erase_to_end_line.len);
memcpy(tt_ptr->erase_to_end_line.addr, buf, buflen);
} else
tt_ptr->erase_to_end_line.len = 0;
req_code = SMG$K_KEY_UP_ARROW;
status = smg$get_term_data(&tt_ptr->term_tab_entry, &req_code, &bufsz, &buflen, buf, 0);
if (status & 1)
{
tt_ptr->key_up_arrow.len = buflen;
tt_ptr->key_up_arrow.addr = malloc(tt_ptr->key_up_arrow.len);
memcpy(tt_ptr->key_up_arrow.addr, buf, buflen);
} else
tt_ptr->key_up_arrow.len = 0;
req_code = SMG$K_KEY_DOWN_ARROW;
status = smg$get_term_data(&tt_ptr->term_tab_entry, &req_code, &bufsz, &buflen, buf, 0);
if (status & 1)
{
tt_ptr->key_down_arrow.len = buflen;
tt_ptr->key_down_arrow.addr = malloc(tt_ptr->key_down_arrow.len);
memcpy(tt_ptr->key_down_arrow.addr, buf, buflen);
} else
tt_ptr->key_down_arrow.len = 0;
req_code = SMG$K_ERASE_TO_END_DISPLAY;
status = smg$get_term_data(&tt_ptr->term_tab_entry, &req_code, &bufsz, &buflen, buf, 0);
if (status & 1)
{
tt_ptr->clearscreen.len = buflen;
tt_ptr->clearscreen.addr = malloc(tt_ptr->clearscreen.len);
memcpy(tt_ptr->clearscreen.addr, buf, buflen);
} else
tt_ptr->clearscreen.len = 0;
}
tt_ptr->item_len = 3 * SIZEOF(item_list_struct);
tt_ptr->item_list[0].buf_len = 0;
tt_ptr->item_list[0].item_code = TRM$_MODIFIERS;
tt_ptr->item_list[0].addr = TRM$M_TM_TRMNOECHO;
tt_ptr->item_list[0].ret_addr = 0;
tt_ptr->item_list[1].buf_len = 0;
tt_ptr->item_list[1].item_code = TRM$_TIMEOUT;
tt_ptr->item_list[1].addr = NO_M_TIMEOUT;
tt_ptr->item_list[1].ret_addr = 0;
tt_ptr->item_list[2].buf_len = SIZEOF(io_termmask);
tt_ptr->item_list[2].item_code = TRM$_TERM;
tt_ptr->item_list[2].addr = malloc(SIZEOF(io_termmask));
memset(tt_ptr->item_list[2].addr, 0, SIZEOF(io_termmask));
((io_termmask *)tt_ptr->item_list[2].addr)->mask[0] =
(spc_inp_prc & (SHFT_MSK << CTRL_Z)) ? (TERM_MSK | (SHFT_MSK << CTRL_Z)) : TERM_MSK;
tt_ptr->item_list[2].ret_addr = 0;
tt_ptr->item_list[3].buf_len = 0;
tt_ptr->item_list[3].item_code = TRM$_ESCTRMOVR;
tt_ptr->item_list[3].addr = ESC_LEN - 1;
tt_ptr->item_list[3].ret_addr = 0;
tt_ptr->item_list[4].buf_len = (TREF(gtmprompt)).len;
tt_ptr->item_list[4].item_code = TRM$_PROMPT;
tt_ptr->item_list[4].addr = (TREF(gtmprompt)).addr;
tt_ptr->item_list[4].ret_addr = 0;
tt_ptr->item_list[5].buf_len = 0;
tt_ptr->item_list[5].item_code = TRM$_INISTRNG;
tt_ptr->item_list[5].addr = 0;
tt_ptr->item_list[5].ret_addr = 0;
if (0 != (t_mode.term_char & TT$M_WRAP))
ioptr->wrap = TRUE;
}
ioptr->state = dev_open;
p_offset = 0;
while (iop_eol != *(pp->str.addr + p_offset))
{
if (iop_exception == (ch = *(pp->str.addr + p_offset++)))
{
ioptr->error_handler.len = *(pp->str.addr + p_offset);
ioptr->error_handler.addr = pp->str.addr + p_offset + 1;
s2pool(&ioptr->error_handler);
break;
}
p_offset += ((IOP_VAR_SIZE == io_params_size[ch]) ?
(unsigned char)*(pp->str.addr + p_offset) + 1 : io_params_size[ch]);
}
return TRUE;
}
short iorm_open(io_log_name *iol, mval *pp, int fd, mval *mspace, int4 timeout)
{
int4 status;
io_desc *iod; /* local pointer to io_curr_device */
d_rm_struct *d_rm;
struct XABFHC xabfhc;
struct XABPRO xabpro;
struct RAB *r;
struct FAB *f;
struct NAM *nam;
mstr newtln;
struct dsc$descriptor_s devname, outname;
uint4 width;
uint4 acebin[128]; /* needs to be big enough for any other ACLs on file */
uint4 *acebinptr;
struct acedef *aceptr;
char *acetop;
boolean_t acefound = FALSE, created = FALSE, isdisk = FALSE, noacl = FALSE;
unsigned int devclass, devchar, devchar2, devtype, dvistat, iosb[2];
short devclassret, devcharret, devchar2ret, devtyperet;
struct
{
item_list_3 item[4];
int terminator;
} item_list;
unsigned char resultant_name[255];
unsigned char tmpfdns;
/** unsigned char resultant_name[MAX_TRANS_NAME_LEN]; THIS WOULD BE RIGHT BUT MAX_TRANS_NAME_LEN MUST BE <= 255 **/
/* while sr_unix/iorm_open.c prefixes errors with ERR_DEVOPENFAIL and it might be nice to be consistent */
/* changing VMS after all this time could break user programs */
/* An exception is being made for the extremely unlikely problem creating a GTM ACE so it stands out */
iod = iol->iod;
assert(*(pp->str.addr) < n_iops);
assert(iod);
assert(iod->state >= 0 && iod->state < n_io_dev_states);
assert(rm == iod->type);
if (dev_never_opened == iod->state)
{
iod->dev_sp = (d_rm_struct *)(malloc(SIZEOF(d_rm_struct)));
d_rm = (d_rm_struct *)iod->dev_sp;
memset(d_rm, 0, SIZEOF(*d_rm));
iod->width = DEF_RM_WIDTH;
iod->length = DEF_RM_LENGTH;
r = &d_rm->r;
f = &d_rm->f;
*r = cc$rms_rab;
*f = cc$rms_fab;
r->rab$l_fab = f;
r->rab$w_usz = d_rm->l_usz = DEF_RM_WIDTH;
f->fab$w_mrs = d_rm->l_mrs = DEF_RM_WIDTH;
f->fab$b_rfm = d_rm->b_rfm = FAB$C_VAR; /* default is variable record format */
f->fab$l_fop = FAB$M_CIF | FAB$M_SQO | FAB$M_CBT | FAB$M_NAM;
f->fab$b_fac = FAB$M_GET | FAB$M_PUT | FAB$M_TRN; /* TRN allows truncate option to be specified in RAB later */
f->fab$b_rat = FAB$M_CR;
f->fab$l_dna = DFLT_FILE_EXT;
f->fab$b_dns = SIZEOF(DFLT_FILE_EXT) - 1;
d_rm->f.fab$l_nam = nam = malloc(SIZEOF(*nam));
*nam = cc$rms_nam;
nam->nam$l_esa = resultant_name;
nam->nam$b_ess = SIZEOF(resultant_name);
nam->nam$b_nop = NAM$M_NOCONCEAL;
r->rab$l_rop = RAB$M_TMO | RAB$M_WBH | RAB$M_RAH;
d_rm->promask = 0xFFFF;
} else
{
d_rm = (d_rm_struct *)iod->dev_sp;
if (dev_closed == iod->state)
d_rm->f.fab$w_bls = 0; /* Reset the block size to pass the block-record check below.
* The FAB initialization sets the block size later so it's OK to zero it here.
*/
nam = d_rm->f.fab$l_nam;
nam->nam$l_esa = 0;
nam->nam$b_ess = 0;
nam->nam$b_esl = 0;
}
iorm_use(iod, pp);
if (dev_open != iod->state)
{
if (!d_rm->largerecord && (d_rm->f.fab$w_bls > 0) && (FAB$C_FIX != d_rm->f.fab$b_rfm)
&& (d_rm->f.fab$w_bls < (d_rm->r.rab$w_usz + VREC_HDR_LEN)))
rts_error(VARLSTCNT(1) ERR_VARRECBLKSZ);
d_rm->r.rab$l_ctx = FAB$M_GET;
d_rm->f.fab$l_fna = iol->dollar_io;
d_rm->f.fab$b_fns = iol->len;
/* smw next overrides any xab set by iorm_use */
xabpro = cc$rms_xabpro;
d_rm->f.fab$l_xab = &xabpro;
memset(acebin, 0, SIZEOF(acebin));
status = sys$parse(&d_rm->f); /* to get device for getdvi */
if ((1 & status))
{
devname.dsc$w_length = nam->nam$b_dev;
devname.dsc$a_pointer = nam->nam$l_dev;
devname.dsc$b_dtype = DSC$K_DTYPE_T;
devname.dsc$b_class = DSC$K_CLASS_S;
item_list.item[0].item_code = DVI$_DEVCLASS;
item_list.item[0].buffer_length = SIZEOF(devclass);
item_list.item[0].buffer_address = &devclass;
item_list.item[0].return_length_address = &devclassret;
item_list.item[1].item_code = DVI$_DEVCHAR;
item_list.item[1].buffer_length = SIZEOF(devchar);
item_list.item[1].buffer_address = &devchar;
item_list.item[1].return_length_address = &devcharret;
item_list.item[2].item_code = DVI$_DEVCHAR2;
item_list.item[2].buffer_length = SIZEOF(devchar2);
item_list.item[2].buffer_address = &devchar2;
item_list.item[2].return_length_address = &devchar2ret;
item_list.item[3].item_code = DVI$_DEVTYPE;
item_list.item[3].buffer_length = SIZEOF(devtype);
item_list.item[3].buffer_address = &devtype;
item_list.item[3].return_length_address = &devtyperet;
item_list.terminator = 0;
dvistat = sys$getdviw(EFN$C_ENF, NULL, &devname, &item_list, iosb, NULL, 0, 0);
if (SS$_NORMAL == dvistat)
dvistat = iosb[0];
if (SS$_NONLOCAL == dvistat || (SS$_NORMAL == dvistat &&
((DC$_DISK != devclass || (DEV$M_NET & devchar) ||
(DEV$M_DAP | DEV$M_DFS) & devchar2) || /* UCX NFS sets DFS */
(DT$_FD1 <= devtype && DT$_FD8 >= devtype) ))) /* but not tcpware so check foreign disk */
{ /* if not disk, dfs/nfs, or non local, create gets BADATTRIB in stv if acl buf and siz set */
noacl = TRUE;
}
} else /* let create/open report the problem */
noacl = TRUE;
if (DEV$M_NET & d_rm->f.fab$l_dev)
{ /* need to release sys$parse channel if DECnet */
tmpfdns = d_rm->f.fab$b_dns;
d_rm->f.fab$b_dns = 0;
assert(0 == nam->nam$l_rlf);
nam->nam$l_rlf = 0;
nam->nam$b_nop |= NAM$M_SYNCHK;
status = sys$parse(&d_rm->f); /* give up channel */
d_rm->f.fab$b_dns = tmpfdns; /* restore */
nam->nam$b_nop &= ~NAM$M_SYNCHK;
}
if (noacl)
{
if (d_rm->largerecord && MAX_RMS_RECORDSIZE < d_rm->l_mrs)
rts_error(VARLSTCNT(1) ERR_RMWIDTHTOOBIG);
d_rm->largerecord = FALSE;
}
if (d_rm->largerecord && FAB$M_GET != d_rm->f.fab$b_fac)
{ /* if readonly use format from existing file */
aceptr = acebin;
aceptr->ace$b_size = GTM_ACE_SIZE * SIZEOF(uint4);
aceptr->ace$b_type = ACE$C_INFO;
/* without NOPROPAGATE, new versions will get ACE,
PROTECTED prevents set acl /dele unless =all */
aceptr->ace$w_flags = ACE$M_NOPROPAGATE | ACE$M_PROTECTED;
/* if HIDDEN, dir/sec does not display which may make it harder to check if problems
aceptr->ace$w_flags |= ACE$M_HIDDEN;
*/
aceptr->ace$v_info_type = ACE$C_CUST; /* must be after flags */
aceptr->ace$w_application_facility = GTM_ACE_FAC; /* GTM error fac */
aceptr->ace$w_application_flags = GTM_ACE_BIGREC;
assert(SIZEOF(uint4) * GTM_ACE_LAB_OFF == (&aceptr->ace$t_info_start - (char *)aceptr));
acebin[GTM_ACE_LAB_OFF] = GTM_ACE_LABEL;
acebin[GTM_ACE_RFM_OFF] = d_rm->b_rfm;
acebin[GTM_ACE_MRS_OFF] = d_rm->l_mrs;
acebin[GTM_ACE_SIZE] = 0; /* terminate */
d_rm->f.fab$b_rfm = FAB$C_UDF;
d_rm->f.fab$w_mrs = 0;
}
if (!noacl)
{ /* tape gets BADATTRIB in stv if acl buf and siz set */
xabpro.xab$l_aclbuf = acebin;
xabpro.xab$w_aclsiz = SIZEOF(acebin);
}
if (FAB$M_GET == d_rm->f.fab$b_fac)
{
xabfhc = cc$rms_xabfhc;
xabpro.xab$l_nxt = &xabfhc;
status = sys$open(&d_rm->f);
} else
{
xabpro.xab$w_pro = d_rm->promask;
status = sys$create(&d_rm->f);
}
nam->nam$l_esa = 0;
nam->nam$b_ess = 0;
nam->nam$b_esl = 0;
d_rm->f.fab$l_xab = 0;
switch (status)
{
case RMS$_NORMAL:
if (d_rm->f.fab$l_fop & FAB$M_MXV)
created = iod->dollar.zeof = TRUE;
break;
case RMS$_CRE_STM:
case RMS$_CREATED:
case RMS$_SUPERSEDE:
case RMS$_FILEPURGED:
if (d_rm->f.fab$l_dev & DEV$M_FOD)
created = iod->dollar.zeof = TRUE;
break;
case RMS$_ACT:
case RMS$_FLK:
return(FALSE);
default:
rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv);
}
if (!noacl && (DEV$M_RND & d_rm->f.fab$l_dev) && !(DEV$M_NET & d_rm->f.fab$l_dev))
isdisk = TRUE; /* local disk */
else if (created && d_rm->largerecord && MAX_RMS_RECORDSIZE < d_rm->l_mrs)
rts_error(VARLSTCNT(1) ERR_RMWIDTHTOOBIG);
/* $create does not return the ACE: if a new file is created aclsts is IVACL */
/* if CIF and existing file has no acl aclsts ACLEMPTY */
/* if CIF and existing file has acl aclsts is NORMAL */
if (isdisk && ((created && SS$_IVACL == xabpro.xab$l_aclsts) || (0 != xabpro.xab$l_aclsts &&
(FAB$M_GET != d_rm->f.fab$b_fac && ((1 & xabpro.xab$l_aclsts) || SS$_ACLEMPTY != xabpro.xab$l_aclsts)))))
{
xabpro.xab$l_aclctx = 0; /* reset context */
d_rm->f.fab$l_xab = &xabpro;
status = sys$display(&d_rm->f);
d_rm->f.fab$l_xab = 0; /* prevent close error */
if (!(1 & status))
rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv);
if (0 != xabpro.xab$l_aclsts && !(1 & xabpro.xab$l_aclsts) && SS$_ACLEMPTY != xabpro.xab$l_aclsts)
rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts);
}
if (isdisk && (1 & status) && 0 != xabpro.xab$l_aclsts && !(1 & xabpro.xab$l_aclsts) &&
SS$_ACLEMPTY != xabpro.xab$l_aclsts)
rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts);
if (isdisk && 0 != xabpro.xab$w_acllen && (1 & status)) /* acl and success */
{
if (SIZEOF(acebin) < xabpro.xab$w_acllen)
{ /* get a new buffer big enough */
xabpro.xab$l_aclbuf = malloc(xabpro.xab$w_acllen);
xabpro.xab$w_aclsiz = xabpro.xab$w_acllen;
xabpro.xab$l_aclctx = 0; /* reset context */
d_rm->f.fab$l_xab = &xabpro;
status = sys$display(&d_rm->f);
d_rm->f.fab$l_xab = 0;
if (!(1 & status))
rts_error(VARLSTCNT(2) status, d_rm->f.fab$l_stv);
if (!(1 & xabpro.xab$l_aclsts))
rts_error(VARLSTCNT(1) xabpro.xab$l_aclsts);
}
acetop = (char *)xabpro.xab$l_aclbuf + xabpro.xab$w_acllen;
for (aceptr = xabpro.xab$l_aclbuf; aceptr < acetop; aceptr = (char *)aceptr + aceptr->ace$b_size)
{
if (0 == aceptr->ace$b_size)
break;
if (ACE$C_INFO == aceptr->ace$b_type && ACE$C_CUST == aceptr->ace$v_info_type
&& GTM_ACE_FAC == aceptr->ace$w_application_facility
&& GTM_ACE_BIGREC == aceptr->ace$w_application_flags)
{ /* info for large records */
acebinptr = aceptr;
assert(GTM_ACE_LABEL == acebinptr[GTM_ACE_LAB_OFF]);
d_rm->largerecord = TRUE;
d_rm->b_rfm = (unsigned char)acebinptr[GTM_ACE_RFM_OFF];
d_rm->l_mrs = acebinptr[GTM_ACE_MRS_OFF];
acefound = TRUE;
break;
}
}
if (acebin != xabpro.xab$l_aclbuf)
{ /* free larger buffer now */
free(xabpro.xab$l_aclbuf);
xabpro.xab$l_aclbuf = acebin;
xabpro.xab$w_aclsiz = SIZEOF(acebin);
}
}
if (!acefound)
{
if (!created)
{ /* copy from exisiting file */
if (isdisk && d_rm->largerecord && FAB$C_UDF == d_rm->f.fab$b_rfm)
rts_error(VARLSTCNT(1) ERR_BIGNOACL); /* maybe lost in copy */
d_rm->b_rfm = d_rm->f.fab$b_rfm;
d_rm->l_mrs = d_rm->f.fab$w_mrs;
} else if (isdisk && d_rm->largerecord)
rts_error(VARLSTCNT(8) ERR_DEVOPENFAIL, 2, iol->len, iol->dollar_io,
ERR_TEXT, 2, LEN_AND_LIT("GTM ACE on new file disappeared - possible VMS problem"));
d_rm->largerecord = FALSE;
}
/* smw does next overwriting of mrs make sense to RMS */
/* if not largerecord, read only, sequential, not magtape ... */
if (!d_rm->largerecord && (FAB$M_GET == d_rm->f.fab$b_fac) && (0 == d_rm->f.fab$w_mrs) && xabfhc.xab$w_lrl)
d_rm->l_mrs = d_rm->l_usz = d_rm->r.rab$w_usz = d_rm->f.fab$w_mrs = xabfhc.xab$w_lrl;
if (d_rm->largerecord)
{ /* guess at a good blocks per IO */
uint4 blocksperrec;
blocksperrec = DIVIDE_ROUND_UP(d_rm->l_mrs, RMS_DISK_BLOCK);
if (RMS_MAX_MBC <= blocksperrec * 2)
d_rm->r.rab$b_mbc = RMS_MAX_MBC;
else if (RMS_DEF_MBC < blocksperrec * 2)
d_rm->r.rab$b_mbc = blocksperrec * 2;
}
status = sys$connect(&d_rm->r);
if (RMS$_NORMAL != status)
rts_error(VARLSTCNT(2) status, d_rm->r.rab$l_stv);
if (d_rm->r.rab$l_rop & RAB$M_EOF)
iod->dollar.zeof = TRUE;
if (ESC == iod->trans_name->dollar_io[0])
{
/* process permanent file...get real name */
status = sys$display(&d_rm->f);
if (status & 1)
{
devname.dsc$w_length = nam->nam$t_dvi[0];
devname.dsc$b_dtype = DSC$K_DTYPE_T;
devname.dsc$b_class = DSC$K_CLASS_S;
devname.dsc$a_pointer = &nam->nam$t_dvi[1];
outname.dsc$w_length = SIZEOF(resultant_name);
outname.dsc$b_dtype = DSC$K_DTYPE_T;
outname.dsc$b_class = DSC$K_CLASS_S;
outname.dsc$a_pointer = resultant_name;
status = lib$fid_to_name(&devname, &nam->nam$w_fid, & outname, &newtln.len, 0, 0);
if ((status & 1) && (0 != newtln.len))
{
newtln.addr = resultant_name;
iod->trans_name = get_log_name(&newtln, INSERT);
iod->trans_name->iod = iod;
}
}
} else
{ /* smw since esl zeroed above this is dead code since early days */
if (nam->nam$b_esl && (iod->trans_name->len != nam->nam$b_esl ||
memcmp(&iod->trans_name->dollar_io[0], resultant_name, nam->nam$b_esl)))
{
newtln.addr = resultant_name;
newtln.len = nam->nam$b_esl;
iod->trans_name = get_log_name(&newtln, INSERT);
iod->trans_name->iod = iod;
}
}
if (0 == d_rm->l_mrs)
d_rm->l_mrs = iod->width;
iod->width = d_rm->l_usz = d_rm->l_mrs;
if (!d_rm->largerecord)
{
d_rm->r.rab$w_usz = d_rm->f.fab$w_mrs = d_rm->l_mrs;
if (FAB$C_VFC == d_rm->f.fab$b_rfm) /* have to leave two bytes for the fixed control */
iod->width = MIN(iod->width, VFC_MAX_RECLEN);
}
width = iod->width;
if (d_rm->largerecord)
{
width = ROUND_UP(width, SIZEOF(uint4));
if (FAB$C_VAR == d_rm->b_rfm)
width += SIZEOF(uint4); /* for count */
}
d_rm->bufsize = width + 1;
d_rm->inbuf = (char*)malloc(width + 1);
d_rm->outbuf_start = (char*)malloc(width + 1);
d_rm->inbuf_pos = d_rm->inbuf;
d_rm->inbuf_top = d_rm->inbuf + iod->width;
d_rm->outbuf_pos = d_rm->outbuf = d_rm->outbuf_start + (d_rm->largerecord && FAB$C_VAR == d_rm->b_rfm
? SIZEOF(uint4) : 0);
d_rm->outbuf_top = d_rm->outbuf + iod->width;
d_rm->promask = xabpro.xab$w_pro;
iod->state = dev_open;
}
return TRUE;
}
