/*
PROGRAM = iijobdef
**
NEEDLIBS = UTILLIB MALLOCLIB COMPATLIB GLLIB
**
UNDEFS = II_copyright
**
DEST = utility
*/
# endif /* VMS */
main( i4 argc, char **argv)
{
# ifdef VMS
char *host;
i4 i;
PM_SCAN_REC state;
STATUS status;
char *lnm_table_name;
struct dsc$descriptor lnm_table;
char *regexp;
char *name, *value;
PM_CONTEXT *config;
struct dsc$descriptor lnm_name;
ILE3 item_list[ 2 ];
long access_mode = PSL$C_SUPER;
bool failed_once = FALSE; /* lib$set_logical works? */
const match_1 = LIB$_NOCLI; /* Process has no CLI. */
const match_2 = LIB$_UNECLIERR; /* Unexpected CLI error
* (non-standard CLI?).
*/
const match_3 = SS$_NORMAL; /* Normal return. */
const match_4 = SS$_SUPERSEDE; /* Replaced old value. */
const match_5 = SS$_NOLOGNAM; /* Not currently defined. */
bool delete_logs = FALSE; /* What are we doing? */
char *act_str; /* String for action. */
char *err_str; /* String for error exit. */
char *log_str; /* String to log action. */
char tmp_buf[BIG_ENOUGH];
MEadvise( ME_INGRES_ALLOC );
if( argc != 1 )
delete_logs = TRUE;
(void) PMmInit( &config );
if( PMmLoad( config, NULL, PMerror ) != OK )
PCexit( FAIL );
host = PMmHost( config );
PMmSetDefault( config, HOST_PM_IDX, host );
/* get logical table name */
STprintf (tmp_buf , ERx( "%s.$.lnm.table.id" ), SystemCfgPrefix);
if( PMmGet( config, tmp_buf , &lnm_table_name )
!= OK )
{
F_ERROR( "%s not found.", PMmExpandRequest( config,
tmp_buf ) );
}
/* set logical name table */
lnm_table_name = ERx( "LNM$JOB" );
/* compose string descriptor for logical table name */
lnm_table.dsc$w_length = STlength( lnm_table_name );
lnm_table.dsc$a_pointer = lnm_table_name;
lnm_table.dsc$b_class = DSC$K_CLASS_S;
lnm_table.dsc$b_dtype = DSC$K_DTYPE_T;
if ( delete_logs ) {
act_str = ERx( "\nDeleting %s logicals...\n\n(%s)\n\n" );
err_str = ERx( "Unable to deassign %s.\n\n" );
log_str = ERx( "" );
} else {
act_str = ERx( "\nDeleting %s logicals...\n\n(%s)\n\n" );
err_str = ERx( "Unable to set %s to \"%s\".\n\n" );
log_str = ERx( "\"%s\" = \"%s\"\n" );
}
F_PRINT2( act_str, SystemDBMSName, lnm_table_name );
/* scan and set node-specific logicals */
regexp = PMmExpToRegExp( config, ERx( "ii.$.lnm.%") );
for(
status = PMmScan( config, regexp, &state, NULL, &name,
&value ); status == OK; status = PMmScan( config,
NULL, &state, NULL, &name, &value ) )
{
name = PMmGetElem( config, 3, name );
lnm_name.dsc$w_length = STlength( name );
lnm_name.dsc$a_pointer = name;
lnm_name.dsc$b_class = DSC$K_CLASS_S;
lnm_name.dsc$b_dtype = DSC$K_DTYPE_T;
item_list[ 0 ].ile3$w_length = STlength( value );
item_list[ 0 ].ile3$w_code = LNM$_STRING;
item_list[ 0 ].ile3$ps_bufaddr = value;
item_list[ 0 ].ile3$ps_retlen_addr = NULL;
item_list[ 1 ].ile3$w_length = 0;
item_list[ 1 ].ile3$w_code = 0;
if ( !failed_once ) {
if ( delete_logs )
status = lib$delete_logical( &lnm_name, &lnm_table );
else
status = lib$set_logical( &lnm_name, NULL, &lnm_table,
NULL, item_list );
if ( lib$match_cond( &status, &match_1, &match_2 ))
failed_once = TRUE;
}
if ( failed_once ) {
if ( delete_logs )
status = sys$dellnm( &lnm_table, &lnm_name,
&access_mode );
else
status = sys$crelnm( NULL, &lnm_table, &lnm_name,
&access_mode, item_list );
}
if ( !lib$match_cond( &status, &match_3, &match_4, &match_5 ))
{
SIfprintf( stderr, err_str, name, value );
PCexit( FAIL );
}
SIprintf( log_str, name, value );
}
PCexit( OK );
# else /* VMS */
SIprintf( "\nThis doesn't do much.\n\n" );
# endif /* VMS */
}
main()
{
struct FAB fab;
header_struct *header;
gd_addr *addr, *addr1, *addr2, *addr3;
gd_region *region;
gd_segment *segment;
int4 *long_ptr, ret_addr;
short iosb[4];
mval v;
char file_name1[] = "dtgbld01.gld", file_name2[] = "dtgbld02.gld", file_name3[] = "dtgbld03.gld";
char label[] = GDE_LABEL_LITERAL;
char file_name4[]="dtlog1";
uint4 status, size;
$DESCRIPTOR(proc_tab, "LNM$PROCESS");
$DESCRIPTOR(gbldir, "GTM$GBLDIR");
$DESCRIPTOR(dtlog, "DTLOG1");
typedef struct
{ short buf_len;
short item;
int4 buf_addr;
int4 ret_addr;
int4 term;
} item_list;
item_list ilist;
char acmo=PSL$C_USER;
/************************* Create logical names for tests **********************************************************/
ilist.item = LNM$_STRING;
ilist.buf_len = SIZEOF(file_name1) - 1;
ilist.buf_addr = file_name1;
ilist.term = 0;
ilist.ret_addr = &ret_addr;
status = sys$crelnm(0, &proc_tab, &gbldir, &acmo, &ilist);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
ilist.buf_len = SIZEOF(file_name2) - 1;
ilist.buf_addr = file_name2;
status = sys$crelnm(0, &proc_tab, &dtlog, &acmo, &ilist);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
/************************* Create global directory files for tests *************************************************/
fab = cc$rms_fab;
fab.fab$l_alq = 5;
fab.fab$l_fna = file_name1;
fab.fab$b_fns = SIZEOF(file_name1) - 1;
fab.fab$l_fop = (FAB$M_UFO | FAB$M_CBT);
fab.fab$b_fac = (FAB$M_PUT | FAB$M_GET | FAB$M_BIO);
fab.fab$b_shr = (FAB$M_SHRPUT | FAB$M_SHRGET | FAB$M_UPI);
status = sys$create(&fab);
if (status != RMS$_CREATED && status != RMS$_FILEPURGED && status != RMS$_NORMAL)
sys$exit(status);
size = SIZEOF(header_struct) + SIZEOF(gd_addr) + 3 * SIZEOF(gd_binding) + SIZEOF(gd_region) + SIZEOF(gd_segment);
header = malloc(((size + 511) / 512) * 512);
header->filesize = size;
size = ((size + 511) / 512) * 512;
memcpy(header->label, label, SIZEOF(label)-1);
addr = (char*)header + SIZEOF(header_struct);
addr->maps = SIZEOF(gd_addr);
addr->n_maps = 3;
addr->regions = (int4)(addr->maps) + 3 * SIZEOF(gd_binding);
addr->n_regions = 1;
addr->segments = (int4)(addr->regions) + SIZEOF(gd_region);
addr->n_segments = 1;
addr->link = addr->tab_ptr = addr->id = addr->local_locks = 0;
addr->max_rec_size = 100;
addr->end = addr->segments + SIZEOF(gd_segment);
long_ptr = (char*)addr + (int4)(addr->maps);
*long_ptr++ = 0xFFFF2F23;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = addr->regions;
*long_ptr++ = 0xFFFFFF24;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = addr->regions;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = 0xFFFFFFFF;
*long_ptr++ = addr->regions;
region = (char*)addr + (int4)(addr->regions);
segment = (char*)addr + (int4)(addr->segments);
memset(region, 0, SIZEOF(gd_region));
region->rname_len = 5;
memcpy(region->rname,"TEMP1",5);
region->dyn.offset = addr->segments;
region->max_rec_size = 100;
region->max_key_size = 64;
segment->sname_len = 5;
memcpy(segment->sname, "TEMP1", 5);
memcpy(segment->fname, "MUMPS1.DAT", 10);
segment->fname_len = 10;
segment->blk_size = 2 * DISK_BLOCK_SIZE;
segment->allocation = 100;
segment->ext_blk_count = 100;
segment->cm_blk = 0;
segment->lock_space = 20;
memcpy(segment->defext, ".DAT", 4);
segment->global_buffers = 64;
segment->buckets = 0;
segment->windows = 0;
segment->acc_meth = dba_bg;
segment->defer_time = 0;
segment->file_cntl = 0;
status = sys$qiow(EFN$C_ENF, fab.fab$l_stv, IO$_WRITEVBLK, &iosb[0], 0, 0, header, size, 1, 0, 0, 0);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
if (!(iosb[0] & 1))
rts_error(VARLSTCNT(1) status);
sys$dassgn(fab.fab$l_stv);
region->rname_len = 5;
memcpy(region->rname,"TEMP2",5);
segment->sname_len = 5;
memcpy(segment->sname,"TEMP2",5);
memcpy(segment->fname,"MUMPS2.DAT",10);
segment->fname_len = 10;
fab.fab$l_fna = file_name2;
fab.fab$b_fns = SIZEOF(file_name3) - 1;
status = sys$create(&fab);
if (status != RMS$_CREATED && status != RMS$_FILEPURGED && status != RMS$_NORMAL)
sys$exit(status);
status = sys$qiow(EFN$C_ENF, fab.fab$l_stv, IO$_WRITEVBLK, &iosb[0], 0, 0, header, size, 1, 0, 0, 0);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
if (!(iosb[0] & 1))
rts_error(VARLSTCNT(1) status);
sys$dassgn(fab.fab$l_stv);
region->rname_len = 5;
memcpy(region->rname, "TEMP3", 5);
segment->sname_len = 5;
memcpy(segment->sname, "TEMP3", 5);
memcpy(segment->fname, "MUMPS3.DAT", 10);
segment->fname_len = 10;
fab.fab$l_fna = file_name3;
fab.fab$b_fns = SIZEOF(file_name3) - 1;
status = sys$create(&fab);
if (status != RMS$_CREATED && status != RMS$_FILEPURGED && status != RMS$_NORMAL)
sys$exit(status);
status = sys$qiow(EFN$C_ENF, fab.fab$l_stv, IO$_WRITEVBLK, &iosb[0], 0, 0, header, size, 1, 0, 0, 0);
if (!(status & 1))
rts_error(VARLSTCNT(1) status);
if (!(iosb[0] & 1))
rts_error(VARLSTCNT(1) status);
sys$dassgn(fab.fab$l_stv);
/*************************** Run tests********************************************/
v.str.len = SIZEOF(file_name1) - 1;
v.str.addr = file_name1;
PRINTF("Open first global directory: dtgbld01.gld\n");
addr1 = zgbldir(&v);
PRINTF("Region name is %s, expected TEMP1\n", addr1->regions->rname);
PRINTF("Segment name is %s, expected TEMP1\n", addr1->regions->dyn.addr->sname);
PRINTF("File name is %s, expected MUMPS1.DAT\n", addr1->regions->dyn.addr->fname);
v.str.len = SIZEOF(file_name2) - 1;
v.str.addr = file_name2;
PRINTF("Open second global directory: dtgbld02.gld\n");
addr2 = zgbldir(&v);
PRINTF("Region name is %s, expected TEMP2\n", addr2->regions->rname);
PRINTF("Segment name is %s, expected TEMP2\n", addr2->regions->dyn.addr->sname);
PRINTF("File name is %s, expected MUMPS2.DAT\n", addr2->regions->dyn.addr->fname);
v.str.len = SIZEOF(file_name3) - 1;
v.str.addr = file_name3;
PRINTF("Open third global directory: dtgbld03.gld\n");
addr3 = zgbldir(&v);
PRINTF("Region name is %s, expected TEMP3\n", addr3->regions->rname);
PRINTF("Segment name is %s, expected TEMP3\n", addr3->regions->dyn.addr->sname);
PRINTF("File name is %s, expected MUMPS3.DAT\n", addr3->regions->dyn.addr->fname);
PRINTF("Open null string global directory: dtgbld01.gld\n");
v.str.len = 0;
addr = zgbldir(&v);
if (addr != addr1)
PRINTF("Expected pointer to previous struct, got new structure\n");
else
PRINTF("Got same pointer as expected.\n");
PRINTF("Open dtlog1 global directory: dtgbld02.gld\n");
v.str.len = SIZEOF(file_name4) - 1;
v.str.addr = file_name4;
addr = zgbldir(&v);
if (addr != addr2)
PRINTF("Expected pointer to previous struct, got new structure\n");
else
PRINTF("Got same pointer as expected.\n");
v.str.len = SIZEOF(file_name3) - 1;
v.str.addr = file_name3;
PRINTF("Reopen third global directory: dtgbld03.gld\n");
addr = zgbldir(&v);
if (addr != addr3)
PRINTF("Expected pointer to previous struct, got new structure\n");
else
PRINTF("Got same pointer as expected.\n");
return;
}
int
osPutEnv(String eqn)
{
unsigned long int status;
String end_buffer;
static unsigned long int lnm_attr;
static String equiv_buffer; /* xlation of logical name */
struct dsc$descriptor_s lognam; /* logical name */
$DESCRIPTOR(tabnam, "LNM$PROCESS_TABLE"); /* logical name table */
struct item_list_3 itmlst[] = {
{sizeof lnm_attr, LNM$_ATTRIBUTES, (String) & lnm_attr, 0},
{0, LNM$_STRING, 0, 0},
{0, 0, 0, 0}
};
for (equiv_buffer = eqn;
*equiv_buffer && *equiv_buffer != '=';
equiv_buffer++);
for (end_buffer = ++equiv_buffer; *end_buffer; end_buffer++);
lognam.dsc$a_pointer = eqn; /* logical name string */
lognam.dsc$w_length = (equiv_buffer - eqn) - 1; /* string length */
lognam.dsc$b_class = DSC$K_CLASS_S; /* string descriptor */
lognam.dsc$b_dtype = DSC$K_DTYPE_T; /* ASCII string */
lnm_attr = 0; /* use default attributes */
/* LNM$M_CONCEALED|LNM$M_TERMINAL */
itmlst[1].buffer_address = equiv_buffer;
itmlst[1].buffer_length = end_buffer - equiv_buffer;
/*
* A little explanation is required here. The system service routine
* $CRELNM creates a new logical name and assigns it a value and
* miscellaneous properties. Among the properties is the access mode,
* which specifies whether the logical name has USER, SUPERVISOR,
* EXECUTIVE, or KERNEL mode. Unfortunately, it cannot define a
* logical name with an access mode higher than that of the process
* it is running in, and for USER mode processes this means that the
* logical name can only be defined with USER mode. This, in turn,
* means that the logical name will vanish when the image exits. To
* cirumvent this, we may use the RTL routine LIB$SET_LOGICAL, which
* requests the shell under which the process is running to define
* the logical name for it at SUPERVISOR access mode, which survives
* the exit of the current image.
*/
#ifdef SUPERVISOR_LNM
status = lib$set_logical(
&lognam, /* LNM to be defined */
NULL, /* value (specified in itmlst) */
&tabnam, /* LNM table to contain new name */
NULL, /* attr: default attributes */
&itmlst); /* what to do */
#else /* SUPERVISOR_LNM */
status = sys$crelnm(
NULL, /* attr: default attributes */
&tabnam, /* LNM table to contain new name */
&lognam, /* LNM to be defined */
NULL, /* acmode: access mode of LNM */
&itmlst); /* what to do */
#endif /* SUPERVISOR_LNM */
if (!(status & 1))
lib$signal(status, NULL); /* report unexpected errors */
return (status & 1) ? 0 : -1; /* UNIX-like return code */
}
