void mup_bak_mag(void)
{
int4 item_code;
$DESCRIPTOR(dir,"");
uint4 devbufsiz;
item_code = DVI$_DEVBUFSIZ;
dir.dsc$a_pointer = directory.addr;
dir.dsc$w_length = directory.len;
devbufsiz = 0;
lib$getdvi(&item_code, 0, &dir, &devbufsiz, 0, 0);
if (devbufsiz < mubmaxblk + 8)
{
util_out_print("!/Buffer size !UL may not accomodate maximum GDS block size of !UL.", FALSE,
devbufsiz, mubmaxblk - 4);
util_out_print("!/4 bytes/GDS block + 8 bytes/tape block in overhead required for device.", FALSE);
util_out_print("!/MUPIP cannot start backup with above errors!/",TRUE);
error_mupip = TRUE;
}
return;
}
void cmj_mbx_ast(struct NTD *tsk)
{
struct CLB *cmu_makclb();
struct dsc$descriptor_s ncb_desc;
uint4 status, unit;
cm_mbx *mp;
struct CLB *lnk;
bool newclb;
void cmj_ast();
status = 0;
mp = tsk->mbx.dsc$a_pointer;
assert(mp->netnum == 3 && mp->netnam[0] == 'N' && mp->netnam[1] == 'E' && mp->netnam[2] == 'T');
switch(mp->msg)
{
case MSG$_CONNECT:
lnk = cmj_unit2clb(tsk, mp->unit);
if (lnk == 0)
{
newclb = TRUE;
lnk = cmu_makclb();
lnk->dch = tsk->dch;
lnk->ntd = tsk;
}else
{
newclb = FALSE;
assert(lnk->sta == CM_CLB_IDLE);
}
ncb_desc.dsc$w_length = mp->len;
ncb_desc.dsc$b_dtype = DSC$K_DTYPE_T;
ncb_desc.dsc$b_class = DSC$K_CLASS_S;
ncb_desc.dsc$a_pointer = mp->text;
lnk->mbf = 0;
/* the statement below and the 3 qio's emulate cmj_iostart which could be used if lnk->clb were a int4 */
lnk->sta = CM_CLB_WRITE;
if (tsk->crq == 0)
{
lnk->ast = cmj_reject_ast;
status = sys$qio(efn_ignore, lnk->dch, IO$_ACCESS | IO$M_ABORT,
&lnk->ios, cmj_ast, lnk,
lnk->mbf, &ncb_desc, 0, 0, 0, 0);
} else
{ if (tsk->acc && !(*tsk->acc)(lnk))
{
lnk->ast = cmj_reject_ast;
status = sys$qio(efn_ignore, lnk->dch, IO$_ACCESS | IO$M_ABORT,
&lnk->ios, cmj_ast, lnk,
lnk->mbf, &ncb_desc, 0, 0, 0, 0);
}else
{
status = sys$assign(&cm_netname, &lnk->dch, 0, &tsk->mnm);
if (status & 1)
{
status = lib$getdvi(&DVI$_UNIT, &lnk->dch, 0, &unit, 0, 0);
if (status & 1)
{
lnk->mun = (unsigned short)unit;
lnk->ast = cmj_accept_ast;
status = sys$qio(efn_ignore, lnk->dch, IO$_ACCESS,
&lnk->ios, cmj_ast, lnk,
lnk->mbf, &ncb_desc, 0, 0, 0, 0);
}
}
}
}
if ((status & 1) == 0)
{
if (newclb)
{
lib$free_vm(&SIZEOF(*lnk), &lnk, 0);
lnk = 0;
}
cmj_mbx_err(status, tsk, lnk);
break;
}
return;
case MSG$_INTMSG:
if (tsk->mbx_ast != 0)
{ (*tsk->mbx_ast)(tsk);
break;
}
/* CAUTION: FALLTHROUGH */
case MSG$_DISCON:
case MSG$_ABORT:
case MSG$_EXIT:
case MSG$_PATHLOST:
case MSG$_PROTOCOL:
case MSG$_THIRDPARTY:
case MSG$_TIMEOUT:
case MSG$_NETSHUT:
case MSG$_REJECT:
case MSG$_CONFIRM:
if (tsk->err)
{
lnk = cmj_unit2clb(tsk, mp->unit);
(*tsk->err)(tsk, lnk, mp->msg);
}else
rts_error(CMI_NETFAIL,0,status); /* condition handler would need to close the connection */
/* CAUTION: FALLTHROUGH */
default:
break;
}
status = cmj_mbx_read_start(tsk);
if ((status & 1) == 0)
{
lnk = cmj_unit2clb(tsk, mp->unit);
cmj_mbx_err(status, tsk, lnk);
}
}
/*
**++
** ROUTINE: sp_open
**
** FUNCTIONAL DESCRIPTION:
**
** Spawns a subprocess, possibly passing it an initial command.
**
** RETURNS: cond_value, longword (unsigned), write only, by value
**
** PROTOTYPE:
**
** sp_open(SPHANDLE *ctxpp, struct dsc$descriptor *inicmd,
** unsigned int (*rcvast)(void *), void *rcvastprm);
**
** IMPLICIT INPUTS: None.
**
** IMPLICIT OUTPUTS: None.
**
** COMPLETION CODES:
** SS$_NORMAL: Normal successful completion.
**
** SIDE EFFECTS: None.
**
**--
*/
unsigned int sp_open (SPHANDLE *ctxpp, void *inicmd, unsigned int (*rcvast)(void *), void *rcvastprm) {
SPHANDLE ctx;
unsigned int dvi_devnam = DVI$_DEVNAM, dvi_devbufsiz = DVI$_DEVBUFSIZ;
unsigned int spawn_flags = CLI$M_NOWAIT|CLI$M_NOKEYPAD;
unsigned int status;
struct dsc$descriptor inbox, outbox;
status = lib$get_vm(&spb_size, &ctx);
if (!OK(status)) return status;
/*
** Assign the SPHANDLE address for the caller immediately to avoid timing issues with
** WRTATTN AST that passes the ctx as rcvastprm (which sp_once does).
*/
*ctxpp = ctx;
ctx->sendque.head = ctx->sendque.tail = &ctx->sendque;
ctx->ok_to_send = 0;
/*
** Create the mailboxes we'll be using for I/O with the subprocess
*/
status = sys$crembx(0, &ctx->inchn, 1024, 1024, 0xff00, 0, 0, 0);
if (!OK(status)) {
lib$free_vm(&spb_size, &ctx);
return status;
}
status = sys$crembx(0, &ctx->outchn, 1024, 1024, 0xff00, 0, 0, 0);
if (!OK(status)) {
sys$dassgn(ctx->inchn);
lib$free_vm(&spb_size, &ctx);
return status;
}
/*
** Now that they're created, let's find out what they're called so we
** can tell LIB$SPAWN
*/
INIT_DYNDESC(inbox);
INIT_DYNDESC(outbox);
lib$getdvi(&dvi_devnam, &ctx->inchn, 0, 0, &inbox);
lib$getdvi(&dvi_devnam, &ctx->outchn, 0, 0, &outbox);
lib$getdvi(&dvi_devbufsiz, &ctx->outchn, 0, &ctx->bufsiz);
/*
** Create the output buffer for the subprocess.
*/
status = lib$get_vm(&ctx->bufsiz, &ctx->bufptr);
if (!OK(status)) {
sys$dassgn(ctx->outchn);
sys$dassgn(ctx->inchn);
str$free1_dx(&inbox);
str$free1_dx(&outbox);
lib$free_vm(&spb_size, &ctx);
return status;
}
/*
** Set the "receive AST" routine to be invoked by SP_WRTATTN_AST
*/
ctx->rcvast = rcvast;
ctx->astprm = rcvastprm;
sys$qiow(0, ctx->outchn, IO$_SETMODE|IO$M_WRTATTN, 0, 0, 0,
sp_wrtattn_ast, ctx, 0, 0, 0, 0);
sys$qiow(0, ctx->inchn, IO$_SETMODE|IO$M_READATTN, 0, 0, 0,
sp_readattn_ast, ctx, 0, 0, 0, 0);
/*
** Get us a termination event flag
*/
status = lib$get_ef(&ctx->termefn);
if (OK(status)) lib$get_ef(&ctx->inefn);
if (OK(status)) lib$get_ef(&ctx->outefn);
if (!OK(status)) {
sys$dassgn(ctx->outchn);
sys$dassgn(ctx->inchn);
str$free1_dx(&inbox);
str$free1_dx(&outbox);
lib$free_vm(&ctx->bufsiz, &ctx->bufptr);
lib$free_vm(&spb_size, &ctx);
return status;
}
/*
** Now create the subprocess
*/
status = lib$spawn(inicmd, &inbox, &outbox, &spawn_flags, 0, &ctx->pid,
0, &ctx->termefn);
if (!OK(status)) {
lib$free_ef(&ctx->termefn);
lib$free_ef(&ctx->outefn);
lib$free_ef(&ctx->inefn);
sys$dassgn(ctx->outchn);
sys$dassgn(ctx->inchn);
str$free1_dx(&inbox);
str$free1_dx(&outbox);
lib$free_vm(&ctx->bufsiz, &ctx->bufptr);
lib$free_vm(&spb_size, &ctx);
return status;
}
/*
** Set up the exit handler, if we haven't done so already
*/
status = sys$setast(0);
if (!exh_declared) {
sys$dclexh(&exhblk);
exh_declared = 1;
}
if (status == SS$_WASSET) sys$setast(1);
/*
** Save the SPB in our private queue
*/
queue_insert(ctx, spque.tail);
/*
** Clean up and return
*/
str$free1_dx(&inbox);
str$free1_dx(&outbox);
return SS$_NORMAL;
} /* sp_open */
void op_fngetdvi(mval *device, mval *keyword, mval *ret)
{
itmlist_struct item_list;
short out_len, iosb[4];
uint4 status;
char index, slot, last_slot;
int4 item_code, out_value;
unsigned char buff[MAX_KEY_LENGTH], *upper_case;
bool want_secondary;
$DESCRIPTOR(device_name,"");
error_def(ERR_DVIKEYBAD);
error_def(ERR_INVSTRLEN);
MV_FORCE_STR(device);
MV_FORCE_STR(keyword);
if (MAX_DEV_LENGTH < device->str.len)
rts_error(VARLSTCNT(1) SS$_IVLOGNAM);
if (keyword->str.len > MAX_KEY_LENGTH)
rts_error(VARLSTCNT(4) ERR_INVSTRLEN, 2, keyword->str.len, MAX_KEY_LENGTH);
if (!keyword->str.len)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, 4, "NULL");
}
lower_to_upper(&buff[0], keyword->str.addr, keyword->str.len);
upper_case = buff;
if ( device->str.len == 0 || (device->str.len == 1 && *device->str.addr == '0'))
{ device_name.dsc$a_pointer = "SYS$INPUT";
device_name.dsc$w_length = SIZEOF("SYS$INPUT")-1;
}
else
{ device_name.dsc$a_pointer = device->str.addr;
device_name.dsc$w_length = device->str.len;
}
item_list.bufflen = VAL_LENGTH;
item_list.itmcode = SPL_CODE;
item_list.buffaddr = &out_value;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) status ) ;
}
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) iosb[0] );
}
if (out_value != NULL)
{ want_secondary = TRUE;
}
else
{ want_secondary = FALSE;
}
if ((index = *upper_case - 'A') < MIN_INDEX || index > MAX_INDEX)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, keyword->str.len, keyword->str.addr);
}
item_code = 0;
if ( dvi_index[ index ].len)
{
slot = dvi_index[ index ].index;
last_slot = dvi_index[ index ].len;
for ( ; slot < last_slot ; slot++ )
{ if (keyword->str.len == dvi_table[ slot ].len &&
!memcmp(dvi_table[ slot ].name, upper_case, keyword->str.len))
{ item_code = dvi_table[ slot ].item_code;
break;
}
}
}
if (!item_code)
{ rts_error(VARLSTCNT(6) ERR_DVIKEYBAD, 4, device->str.len, device->str.addr, keyword->str.len, keyword->str.addr);
}
switch( item_code )
{
/* **** the following item codes require a string be returned **** */
case DVI$_ALLDEVNAM:
case DVI$_DEVLOCKNAM:
case DVI$_DEVNAM:
case DVI$_FULLDEVNAM:
case DVI$_LOGVOLNAM:
case DVI$_NEXTDEVNAM:
case DVI$_ROOTDEVNAM:
case DVI$_TT_ACCPORNAM:
case DVI$_TT_PHYDEVNAM:
case DVI$_VOLNAM:
if (want_secondary)
{
if (!((item_code == DVI$_DEVNAM) && (keyword->str.len == 9)))
{ item_code |= DVI$C_SECONDARY;
}
}
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(MAX_DVI_STRLEN);
item_list.bufflen = MAX_DVI_STRLEN;
item_list.itmcode = item_code;
item_list.buffaddr = stringpool.free;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) status );
}
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
{ rts_error(VARLSTCNT(1) iosb[0] ) ;
}
ret->str.addr = stringpool.free;
ret->str.len = out_len;
ret->mvtype = MV_STR;
stringpool.free += out_len;
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
return;
default:
if (want_secondary)
item_code |= DVI$C_SECONDARY;
item_list.itmcode = item_code;
item_list.bufflen = VAL_LENGTH;
item_list.buffaddr = &out_value;
item_list.retlen = &out_len;
item_list.end = NULL;
status = sys$getdvi( efn_immed_wait, 0, &device_name, &item_list, &iosb[0], 0, 0, 0 );
if (status != SS$_NORMAL && status != SS$_NONLOCAL)
rts_error(VARLSTCNT(1) status );
sys$synch(efn_immed_wait, &iosb[0]);
if (iosb[0] != SS$_NORMAL && iosb[0] != SS$_NONLOCAL)
rts_error(VARLSTCNT(1) iosb[0] );
if (want_secondary)
item_code = item_code - 1;
switch(item_code)
{ case DVI$_LOCKID:
case DVI$_ACPPID:
case DVI$_OWNUIC:
if (out_value)
{ assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
ENSURE_STP_FREE_SPACE(HEX_LEN);
i2hex(out_value, stringpool.free, HEX_LEN);
ret->str.addr = stringpool.free;
ret->str.len = HEX_LEN;
stringpool.free += HEX_LEN;
assert(stringpool.free >= stringpool.base);
assert(stringpool.top >= stringpool.free);
}
else
{ ret->str.addr = "";
ret->str.len = 0;
}
ret->mvtype = MV_STR;
break;
case DVI$_ACPTYPE:
switch(out_value)
{
case 0: ret->str.addr = "ILLEGAL";
ret->str.len = 7;
break;
case 1: ret->str.addr = "F11V1";
ret->str.len = 5;
break;
case 2: ret->str.addr = "F11V2";
ret->str.len = 5;
break;
case 3: ret->str.addr = "MTA";
ret->str.len = 3;
break;
case 4: ret->str.addr = "NET";
ret->str.len = 3;
break;
case 5: ret->str.addr = "REM";
ret->str.len = 3;
}
ret->mvtype = MV_STR;
break;
default:
i2mval(ret,out_value) ;
}
return;
}
}
