void la_getdat(uint4 kid, int4 code, date *date_ptr, uint4 lo, uint4 hi)
/* kid - virt. keyb. ID */
/* code - promt msg code */
/* date_ptr - date/time returned */
/* lo - min value of date */
/* hi - max value of date */
{
int status;
bool valid;
char pro[64], res[64];
unsigned short length; /* res. string length */
int4 mlen = 32; /* max length of result */
int smg$read_string(), sys$getmsg();
int sys$asctim();
$DESCRIPTOR(dini, res); /* initial string */
$DESCRIPTOR(dres, res); /* resuting string */
$DESCRIPTOR(dprm, pro); /* prompt string */
error_def(LA_INVAL);
dprm.dsc$w_length = 64;
status = sys$getmsg(code, &length, &dprm, 1, 0);
if (SS$_NORMAL != status)
lib$signal(status);
dprm.dsc$w_length = length;
dres.dsc$w_length = 12;
if (0 == (*date_ptr)[1])
{ /* no initial date */
res[0] = 0;
length = 0;
} else
{
status = sys$asctim(&length, &dres, date_ptr, 0);
if (SS$_NORMAL != status)
lib$signal(status);
}
dres.dsc$w_length = 64;
valid = FALSE;
while ((SS$_NORMAL != status) || !valid)
{
res[length] = ' ';
dini.dsc$w_length = length;
status = smg$read_string(&kid, &dres, &dprm, &mlen, 0, 0, 0, &length, 0, 0, &dini);
if (SS$_NORMAL != status)
lib$signal(status);
else if (0 == length)
{ /* no datstatus/time */
(*date_ptr)[0] = (*date_ptr)[1] = lo = 0;
hi = 1;
} else if (0 != length)
{ /* date/time entered */
status = lib$convert_date_string(&dres, date_ptr);
if (SS$_NORMAL != status)
la_putmsgs(status);
}
valid = ((*date_ptr)[1] >= lo || (*date_ptr)[1] < hi);
if (!valid)
la_putmsgu(LA_INVAL, 0, 0);
}
}
static void
waitTime (
pwr_tTime *t
)
{
pwr_tStatus sts;
pwr_tTime now;
pwr_tTime then = *t;
char tims[24];
short len;
struct dsc$descriptor_s tims_desc = {
sizeof(tims)-1, DSC$K_DTYPE_T, DSC$K_CLASS_S,};
#if 0
subTime(&then, nowTime(&now));
#endif
if ((int)then.tv_sec > 0 || ((int)then.tv_sec == 0 && then.tv_nsec > 0)) {
#if defined OS_VMS || defined OS_ELN
int tv_nsec;
int vmstime[2];
int multiplier = -10000000; /* Used to convert 1 s to 100 ns, delta time. */
static pwr_tTime tick = {0, 10000000};
addTime(&then, &tick);
tv_nsec = -then.tv_nsec/100; /* Convert to 100 ns. */
sts = lib$emul(&then.tv_sec, &multiplier, &tv_nsec, vmstime);
#if defined OS_VMS
tims_desc.dsc$a_pointer = tims;
sys$asctim( &len, &tims_desc, vmstime, 0);
tims[len] = '\0';
printf(" %s\n", tims);
#if 0
sts = sys$clref(timerFlag);
sts = sys$setimr(timerFlag, vmstime, 0, 0, 0);
sts = sys$waitfr(timerFlag);
#endif
#elif defined OS_ELN
eln$time_string(tims, vmstime);
tims[23] = '\0';
printf(" %s\n", tims);
#if 0
ker$wait_any(&sts, NULL, vmstime);
#endif
#endif
#elif defined OS_LYNX
pwr_tTime rmt;
nanosleep(&then, &rmt);
#endif
}
}
static void asctim( /* convert 64-bit binval to string, put in time */
char *time,
long int binval[2] )
{
static struct dsc$descriptor date_str={23,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
/* dsc$w_length, dsc$b_dtype, dsc$b_class, dsc$a_pointer */
date_str.dsc$a_pointer = time;
sys$asctim(0, &date_str, binval, 0);
time[23] = '\0';
}
int main()
{
struct dsc$descriptor_s return_date;
char date_buffer[64];
unsigned long status;
return_date.dsc$w_length = sizeof(date_buffer);
return_date.dsc$b_dtype = DSC$K_DTYPE_T;
return_date.dsc$b_class = DSC$K_CLASS_S;
return_date.dsc$a_pointer = date_buffer;
status = sys$asctim(&return_date.dsc$w_length, &return_date, 0, 0);
printf("Todays date: Status %ld: Text: %-32.32s\n",
status, date_buffer);
return EXIT_SUCCESS;
}
/***************************************************************
* MdsDatime:
***************************************************************/
static char *MdsDatime( /* Return: ptr to date+time string */
int time[] /* <r> date/time to display: quadword */
)
{
int flags = 0;
int sts;
short len;
static char datime[24];
static DESCRIPTOR(dsc_datime,datime);
#ifdef vms
sts = sys$asctim(&len,&dsc_datime,time,flags);
#else
sts = LibSysAscTim(&len,&dsc_datime,time,flags);
#endif
datime[len] = '\0';
return(datime);
}
main () {
/* Find my group and member IDs for $getjpi */
status = sys$getjpiw(0,0,0,getjpi_items,&jpi_iosb,0,0);
if (!(status & 1)) lib$signal(status);
if (!(jpi_iosb.iosb_status & 1)) lib$signal(jpi_iosb.iosb_status);
/* Build the pscan stuff */
assert (psitems[1].code == PSCAN$_GRP);
psitems[1].val = mygrp;
assert (psitems[2].code == PSCAN$_MEM);
psitems[2].val = mymem;
/* Build the context for $getjpi */
status = sys$process_scan(&ps_ctx, &psitems);
if (!(status & 1)) lib$signal(status);
status = lib$date_time(&time_desc);
printf("\n Checking uptime agent status at: %s\n",timestring);
printf("\n Image Node Pid CPUsec ppgcnt gpgcnt\n");
printf("----------------------------------------------------------------------------------\n");
/* Run the context until all processes found */
while (TRUE) {
status = sys$getjpiw (EFN$C_ENF, &ps_ctx, 0, getjpi_items, &jpi_iosb, 0, 0);
if (jpi_iosb.iosb_status == SS$_NOMOREPROC) {
printf("----------------------------------------------------------------------------------\n");
break;
}else{
if (!(jpi_iosb.iosb_status & 1)) lib$signal(jpi_iosb.iosb_status);
total_mem = pages + gblpages;
lib$trim_filespec(&img_desc,&short_desc,&sizeof(shortname)); /* Just the filename */
if (strstr(shortname,"UPTIME-AGENT") != NULL) {
status = sys$asctim(&timlen,&time_desc,&logintime,timeflag); /* Convert binary time */
printf ("%20s %6s %x %8.1f %6d %6d\n",
shortname,nodename,mypid,(float)cputime/100,pages,gblpages);
}
}
}
}
i4
TMtostr (i4 secs, char* op_str)
{
i4 j;
i4 sts;
GENERIC_64 vms_time;
struct dsc$descriptor_s timdsc = {20, DSC$K_DTYPE_T, DSC$K_CLASS_S, op_str};
/*
** clear output string in case of errors
** you will note that there is an implicit assumption that the
** the caller provided an output buffer of at least 21 characters
*/
op_str[0] = 0;
/* convert time in secs to VMS 100nSec units */
sts = lib$emul(&secs, &10000000, &0, (int64 *)&vms_time);
if (!(sts & STS$M_SUCCESS))
return 0;
sts = lib$addx ((u_i8 *)&vms_time, (u_i8 *)&unix_epoch, (u_i8 *)&vms_time);
if (!(sts & STS$M_SUCCESS))
return 0;
/*
** restrict the o/p buffer length to a max of 20 chars
** i.e. lose the trailing ".nn" millisecs of the string
*/
sts = sys$asctim (&timdsc.dsc$w_length, &timdsc, &vms_time, 0);
j = (sts & STS$M_SUCCESS) ? timdsc.dsc$w_length : 0;
op_str[j] = 0;
return ((sts & STS$M_SUCCESS) ? j : 0);
}
bool open_source_file(void)
{
static readonly char inprompt[] = "\015\012>";
struct NAM nam;
struct XABDAT xab;
char exp_name[255];
char *p;
int n;
int rms_status;
struct dsc$descriptor_s t_desc
= {REV_TIME_BUFF_LEN, DSC$K_DTYPE_T, DSC$K_CLASS_S, rev_time_buf};
fab = cc$rms_fab;
fab.fab$l_fna = source_file_name;
fab.fab$b_fns = source_name_len;
fab.fab$w_mrs = MAX_SRCLINE;
fab.fab$l_xab = &xab;
fab.fab$l_nam = &nam;
nam = cc$rms_nam;
nam.nam$l_esa = exp_name;
nam.nam$b_ess = SIZEOF(exp_name);
xab = cc$rms_xabdat;
rms_status = sys$open(&fab);
fab.fab$l_xab = 0;
fab.fab$l_nam = 0;
if (RMS$_NORMAL != rms_status)
{
dec_err(VARLSTCNT(4) ERR_SRCFILERR, 2, source_name_len, source_file_name);
dec_err(VARLSTCNT(1) rms_status);
return FALSE;
}
assert(tt_so_do_once || (source_name_len == nam.nam$b_esl && !memcmp(source_file_name, exp_name, nam.nam$b_esl)));
rab = cc$rms_rab;
rab.rab$l_fab = &fab;
rab.rab$l_pbf = inprompt;
rab.rab$b_psz = SIZEOF(inprompt) - 1;
rab.rab$l_rop = RAB$M_PMT;
rab.rab$l_ubf = source_buffer;
rab.rab$w_usz = MAX_SRCLINE;
rms_status = sys$connect(&rab);
if (RMS$_NORMAL != rms_status)
{
dec_err(VARLSTCNT(4) ERR_SRCFILERR, 2, source_name_len, source_file_name);
dec_err(VARLSTCNT(1) rms_status);
return FALSE;
}
sys$asctim(0,&t_desc,&xab.xab$q_rdt,0);
p = nam.nam$l_name ;
n = nam.nam$b_name ;
if (n > MAX_MIDENT_LEN)
n = MAX_MIDENT_LEN;
else if (!n)
{
p = "MDEFAULT";
n = STR_LIT_LEN("MDEFAULT");
}
memcpy(routine_name.addr, p, n);
memcpy(module_name.addr, p, n);
routine_name.len = module_name.len = n;
if ('_' == *p)
routine_name.addr[0] = '%';
return TRUE;
}
asmlinkage int exe$faol(void * ctrstr , short int * outlen , void * outbuf , int * prmlst) {
long * argv=prmlst;
struct dsc$descriptor * in=ctrstr;
struct dsc$descriptor * out=outbuf;
int in_dex=0,out_dex=0;
char * in_p=in->dsc$a_pointer;
char * out_p=out->dsc$a_pointer;
signed int argv_num=0;
while (in_dex<in->dsc$w_length) {
char c;
c=in_p[in_dex++];
switch (c) {
case '!':
c=in_p[in_dex++];
switch (c) {
case 'A':
c=in_p[in_dex++];
switch (c) {
case 'C':
{
char * bufc=argv[argv_num++];
char len=*bufc++;
memcpy(&out_p[out_dex],bufc,len);
out_dex+=len;
}
break;
case 'F':
// not quite implemented yet
case 'D':
{
char len=argv[argv_num++];
char * bufc=argv[argv_num++];
memcpy(&out_p[out_dex],bufc,len);
out_dex+=len;
}
break;
case 'S':
{
struct dsc$descriptor * d=argv[argv_num++];
char len=d->dsc$w_length;
char * bufc=d->dsc$a_pointer;
memcpy(&out_p[out_dex],bufc,len);
out_dex+=len;
}
break;
case 'Z':
{
// do overflow check later
char * bufc=argv[argv_num++];
char len=strlen(bufc);
memcpy(&out_p[out_dex],bufc,len);
out_dex+=len;
}
break;
default:
printk("fao !A%c stuff not recognized\n",c);
}
break;
case 'O':
case 'X':
case 'Z':
case 'S':
case 'U':
case 'I':
{
char type=0;
long mask=0;
int num=0;
switch (c) {
case 'O':
type='o';
break;
case 'X':
type='x';
break;
case 'Z':
case 'I':
case 'S':
case 'U':
type='d';
break;
}
c=in_p[in_dex++];
switch (c) {
case 'B':
mask=0xff;
break;
case 'W':
mask=0xffff;
break;
case 'A':
case 'L':
mask=0xffffffff;
break;
default:
printk("fao !O/X/Z%c stuff not recognized\n",c);
break;
}
num=mask&argv[argv_num++];
char * format="% ";
format[1]=type;
out_dex+=sprintf(&out_p[out_dex],format,num);
}
break;
case '/':
out_p[out_dex++]='\n';
break;
case '_':
out_p[out_dex++]='\t';
break;
case '^':
// not quite right
out_p[out_dex++]='\t';
break;
case '!':
out_p[out_dex++]='!';
break;
case '%':
c=in_p[in_dex++];
switch (c) {
case 'T':
{
long long * l=argv[argv_num++];
if (l==0)
l=&exe$gq_systime;
struct dsc$descriptor d;
char chr[32];
d.dsc$w_length=32;
d.dsc$a_pointer=chr;
short int len;
exe$asctim(&len,&d,l,0);
memcpy(&out_p[out_dex],d.dsc$a_pointer,len);
out_dex+=len;
}
break;
default:
printk("fao !percent %c not recognized\n",c);
}
break;
default:
printk("fao !%c not recognized\n",c);
break;
}
break;
default:
out_p[out_dex++]=c;
}
}
#if 0
sprintf(out->dsc$w_apointer,format,argv[0],argv[1],argv[2],argv[3],argv[4],argv[5],argv[6],argv[7],argv[8],argv[9],argv[10],argv[11],argv[12],argv[13],argv[14],argv[15],argv[16]);
#endif
if (outlen) (*outlen)=out_dex;
return SS$_NORMAL;
}
show_system(){
int i;
struct item_list_3 lst[14], syilst[4];
char scsnode[16];
char procname[15];
char proclen;
char version[16];
int versionlen;
unsigned long long boottime;
int boottimelen;
unsigned long upid,epid;
unsigned long upidlen,epidlen;
unsigned long state,statelen;
unsigned long pri,prilen;
unsigned long pagep, pageplen;
unsigned long pageg, pageglen;
unsigned long pagef, pageflen;
unsigned int dirio, diriolen, bufio, bufiolen;
int jpistatus;
int sts;
int retscsnodelen;
unsigned long long now;
char timestr[23];
$DESCRIPTOR(atimenow, timestr);
char timestr2[23];
$DESCRIPTOR(atimenow2, timestr2);
sys$gettim(&now);
sys$asctim(0,&atimenow,&now,0);
syilst[0].buflen=16;
syilst[0].item_code=SYI$_VERSION;
syilst[0].bufaddr=version;
syilst[0].retlenaddr=&versionlen;
syilst[1].buflen=16;
syilst[1].item_code=SYI$_BOOTTIME;
syilst[1].bufaddr=&boottime;
syilst[1].retlenaddr=&boottimelen;
syilst[2].buflen=16;
syilst[2].item_code=SYI$_SCSNODE;
syilst[2].bufaddr=scsnode;
syilst[2].retlenaddr=&retscsnodelen;
syilst[3].buflen=0;
syilst[3].item_code=0;
sts=sys$getsyi(0,0,0,syilst,0,0,0);
long long delta = boottime - now;
int deltalen;
sys$asctim(0,&atimenow2,&delta,0);
lst[0].buflen=15;
lst[0].item_code=JPI$_PRCNAM;
lst[0].bufaddr=procname;
lst[0].retlenaddr=&proclen;
lst[1].buflen=4;
lst[1].item_code=JPI$_PID;
lst[1].bufaddr=&epid;
lst[1].retlenaddr=&epidlen;
lst[2].buflen=4;
lst[2].item_code=JPI$_MASTER_PID;
lst[2].bufaddr=&upid;
lst[2].retlenaddr=&upidlen;
lst[3].buflen=4;
lst[3].item_code=JPI$_STATE;
lst[3].bufaddr=&state;
lst[3].retlenaddr=&statelen;
lst[4].buflen=4;
lst[4].item_code=JPI$_PAGEFLTS;
lst[4].bufaddr=&pagef;
lst[4].retlenaddr=&pageflen;
lst[5].buflen=4;
lst[5].item_code=JPI$_PRI;
lst[5].bufaddr=&pri;
lst[5].retlenaddr=&prilen;
lst[6].buflen=4;
lst[6].item_code=JPI$_PPGCNT;
lst[6].bufaddr=&pagep;
lst[6].retlenaddr=&pageplen;
lst[7].buflen=4;
lst[7].item_code=JPI$_GPGCNT;
lst[7].bufaddr=&pageg;
lst[7].retlenaddr=&pageglen;
lst[8].buflen=4;
lst[8].item_code=JPI$_DIRIO;
lst[8].bufaddr=&dirio;
lst[8].retlenaddr=&diriolen;
lst[9].buflen=4;
lst[9].item_code=JPI$_BUFIO;
lst[9].bufaddr=&bufio;
lst[9].retlenaddr=&diriolen;
lst[10].buflen=4;
lst[10].item_code=JPI$_CPUTIM;
lst[10].bufaddr=δ
lst[10].retlenaddr=&deltalen;
lst[11].buflen=0;
lst[11].item_code=0;
// printf(" FreeVMS V0.0 on node %6s NN-OOO-2003 PP:QQ:RR.SS Uptime TT XX:YY:ZZ\n",scsnode);
#ifdef __x86_64__
int bits = 64;
#endif
#ifdef __i386__
int bits = 32;
#endif
#ifndef FREEVMS_BUILD
#define FREEVMS_BUILD 1
#endif
printf(" FreeVMS %d V%s build %d on node %6s %s Uptime %s\n", bits,version, FREEVMS_BUILD, scsnode, timestr, timestr2);
printf(" Pid Process Name State Pri I/O CPU Page flts Pages\n");
do {
jpistatus=sys$getjpi(0,0,0,lst,0,0,0);
if (jpistatus == SS$_NORMAL)
delta = -delta * 100000; // check multiplication
sys$asctim(0,&atimenow2,&delta,0);
printf("%8x %-15s %-6s %3x %9x %17s %6x %6x\n",epid,procname,states[state],31-pri,dirio+bufio,atimenow2.dsc$a_pointer,pagef,pagep+pageg);
} while (jpistatus == SS$_NORMAL);
//} while (jpistatus != SS$_NOMOREPROC);
}
static int varg_convert_date(char *date_string, char *pattern)
{
char date_text[30];
int bin_time[2], flags, length, status, i, from, to;
char year_4[5], year_2[4], month_name[4];
char month_2[2], month_1[2], date_2[3], date_1[2];
char hour_2[3], hour_1[2], minute[3], second[3];
char *months[] = {"", "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
$DESCRIPTOR(date_desc, "");
static int context;
/* First convert the date string into internal VMS format
*/
date_desc.dsc$w_length = strlen(date_string);
date_desc.dsc$a_pointer = date_string;
context = 0;
flags = 0X7F;
status = lib$convert_date_string(&date_desc, &bin_time, &context, &flags);
if ((status & 1) != 1) return status;
/* Now convert it back to string form. This ensures that delta times
and keywords like TODAY get translated into a consistent format.
*/
date_desc.dsc$w_length = 30;
/* date_desc.dsc$a_pointer = &date_text;*/
date_desc.dsc$a_pointer = date_text;
length = 0;
status = sys$asctim(&length, &date_desc, &bin_time, 0);
if ((status & 1) != 1) return status;
date_text[length] = 0; /* add NULL terminator */
date_string[0] = 0; /* start with empty string */
/* Break the date/time string up into the constituent fields. Fields
such as date have two instances - one with leading zero and one without
e.g. "05" and "5".
*/
if (date_text[0] == ' ') {
date_2[0] = '0';
date_2[1] = date_text[1];
date_2[2] = 0;
date_1[0] = date_text[1];
date_1[1] = 0;
} else {
date_2[0] = date_text[0];
date_2[1] = date_text[1];
date_2[2] = 0;
strcpy(date_1, date_2);
}
/* Extract the month name and lowercase the 2nd and 3rd characters.
*/
month_name[0] = date_text [3];
month_name[1] = tolower(date_text [4]);
month_name[2] = tolower(date_text [5]);
month_name[3] = 0;
/* Calculate the month number by looking up the month name in a
character array.
*/
for (i = 1; i <= 12; i++) {
if (strcmp(month_name, months[i]) == 0) {
sprintf(month_2, "%02d", i);
sprintf(month_1, "%d", i);
break;
}
}
/* Extract the year field (both 4 digit and 2 digit forms).
*/
year_2[0] = date_text[9];
year_2[1] = date_text[10];
year_2[3] = 0;
for (i = 0; i <= 3; i++) {
year_4[i] = date_text[i+7];
}
year_4[4] = 0;
/* Extract hour field.
*/
hour_2[0] = date_text[12];
hour_2[1] = date_text[13];
hour_2[2] = 0;
if (date_text[12] == '0') {
hour_1[0] = date_text[13];
hour_1[1] = 0;
} else strcpy(hour_1, hour_2);
/* Lastly copy the minutes and seconds.
*/
for (i = 0; i <= 1; i++) {
minute[i] = date_text[i+15];
second[i] = date_text[i+18];
}
minute[2] = 0;
second[2] = 0;
/* Now start building up the output string by copying characters from
'pattern' to 'date_string' substituting the various fields when we
encounter an escape pair.
*/
from = 0;
to = 0;
while (pattern[from] != 0) {
if (pattern[from] == '$') {
switch (pattern[from+1]) {
case 'Y':
strcat(date_string, year_4);
to = to + 4;
break;
case 'y':
strcat(date_string, year_2);
to = to + 2;
break;
case 'M':
strcat(date_string, month_name);
to = to + 3;
break;
case 'N':
strcat(date_string, month_2);
to = to + 2;
break;
case 'n':
strcat(date_string, month_1);
to = to + strlen(month_1);
break;
case 'D':
strcat(date_string, date_2);
to = to + 2;
break;
case 'd':
strcat(date_string, date_1);
to = to + strlen(date_1);
break;
case 'H':
strcat(date_string, hour_2);
to = to + 2;
break;
case 'h':
strcat(date_string, hour_1);
to = to + strlen(hour_1);
break;
case 'm':
strcat(date_string, minute);
to = to + 2;
break;
case 'S':
case 's':
strcat(date_string, second);
to = to + 2;
break;
case '$':
date_string[to] = '$';
date_string[to+1] = 0;
to = to + 1;
break;
}
from = from + 2;
} else {
date_string[to] = pattern[from];
date_string[to+1] = 0;
from = from + 1;
to = to + 1;
}
}
}
int VMSmunch(
char *filename,
int action,
char *ptr )
{
/* original file.c variables */
static struct FAB Fab;
static struct NAM Nam;
static struct fibdef Fib; /* short fib */
static struct dsc$descriptor FibDesc =
{sizeof(Fib),DSC$K_DTYPE_Z,DSC$K_CLASS_S,(char *)&Fib};
static struct dsc$descriptor_s DevDesc =
{0,DSC$K_DTYPE_T,DSC$K_CLASS_S,&Nam.nam$t_dvi[1]};
static struct fatdef Fat;
static union {
struct fchdef fch;
long int dummy;
} uchar;
static struct fjndef jnl;
static long int Cdate[2],Rdate[2],Edate[2],Bdate[2];
static short int revisions;
static unsigned long uic;
#if defined(__DECC) || defined(__DECCXX)
#pragma __member_alignment __save
#pragma __nomember_alignment
#endif /* __DECC || __DECCXX */
static union {
unsigned short int value;
struct {
unsigned system : 4;
unsigned owner : 4;
unsigned group : 4;
unsigned world : 4;
} bits;
} prot;
#if defined(__DECC) || defined(__DECCXX)
#pragma __member_alignment __restore
#endif /* __DECC || __DECCXX */
static struct atrdef Atr[] = {
{sizeof(Fat),ATR$C_RECATTR,&Fat}, /* record attributes */
{sizeof(uchar),ATR$C_UCHAR,&uchar}, /* File characteristics */
{sizeof(Cdate),ATR$C_CREDATE,&Cdate[0]}, /* Creation date */
{sizeof(Rdate),ATR$C_REVDATE,&Rdate[0]}, /* Revision date */
{sizeof(Edate),ATR$C_EXPDATE,&Edate[0]}, /* Expiration date */
{sizeof(Bdate),ATR$C_BAKDATE,&Bdate[0]}, /* Backup date */
{sizeof(revisions),ATR$C_ASCDATES,&revisions}, /* number of revisions */
{sizeof(prot),ATR$C_FPRO,&prot}, /* file protection */
{sizeof(uic),ATR$C_UIC,&uic}, /* file owner */
{sizeof(jnl),ATR$C_JOURNAL,&jnl}, /* journal flags */
{0,0,0}
} ;
static char EName[NAM$C_MAXRSS];
static char RName[NAM$C_MAXRSS];
static struct dsc$descriptor_s FileName =
{0,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
static struct dsc$descriptor_s string = {0,DSC$K_DTYPE_T,DSC$K_CLASS_S,0};
static short int DevChan;
static short int iosb[4];
static long int i,status;
/* static char *retval; */
/* new VMSmunch variables */
static int old_rtype=FAT$C_FIXED; /* storage for record type */
/*---------------------------------------------------------------------------
Initialize attribute blocks, parse filename, resolve any wildcards, and
get the file info.
---------------------------------------------------------------------------*/
/* initialize RMS structures, we need a NAM to retrieve the FID */
Fab = cc$rms_fab;
Fab.fab$l_fna = filename;
Fab.fab$b_fns = strlen(filename);
Fab.fab$l_nam = &Nam; /* FAB has an associated NAM */
Nam = cc$rms_nam;
Nam.nam$l_esa = EName; /* expanded filename */
Nam.nam$b_ess = sizeof(EName);
Nam.nam$l_rsa = RName; /* resultant filename */
Nam.nam$b_rss = sizeof(RName);
/* do $PARSE and $SEARCH here */
status = sys$parse(&Fab);
if (!(status & 1)) return(status);
/* search for the first file.. If none signal error */
status = sys$search(&Fab);
if (!(status & 1)) return(status);
while (status & 1) {
/* initialize Device name length, note that this points into the NAM
to get the device name filled in by the $PARSE, $SEARCH services */
DevDesc.dsc$w_length = Nam.nam$t_dvi[0];
status = sys$assign(&DevDesc,&DevChan,0,0);
if (!(status & 1)) return(status);
FileName.dsc$a_pointer = Nam.nam$l_name;
FileName.dsc$w_length = Nam.nam$b_name+Nam.nam$b_type+Nam.nam$b_ver;
/* Initialize the FIB */
for (i=0;i<3;i++)
Fib.FIB$W_FID[i]=Nam.nam$w_fid[i];
for (i=0;i<3;i++)
Fib.FIB$W_DID[i]=Nam.nam$w_did[i];
/* Use the IO$_ACCESS function to return info about the file */
/* Note, used this way, the file is not opened, and the expiration */
/* and revision dates are not modified */
status = sys$qiow(0,DevChan,IO$_ACCESS,&iosb,0,0,
&FibDesc,&FileName,0,0,&Atr,0);
if (!(status & 1)) return(status);
status = iosb[0];
if (!(status & 1)) return(status);
/*-----------------------------------------------------------------------
We have the current information from the file: now see what user
wants done with it.
-----------------------------------------------------------------------*/
switch (action) {
case GET_TIMES:
asctim(((struct VMStimbuf *)ptr)->modtime, Cdate);
asctim(((struct VMStimbuf *)ptr)->actime, Rdate);
break;
case SET_TIMES:
bintim(((struct VMStimbuf *)ptr)->modtime, Cdate);
bintim(((struct VMStimbuf *)ptr)->actime, Rdate);
break;
case GET_RTYPE: /* non-modifying */
*(int *)ptr = Fat.fat$v_rtype;
return RMS$_NORMAL; /* return to user */
break;
case CHANGE_RTYPE:
old_rtype = Fat.fat$v_rtype; /* save current one */
if ((*(int *)ptr < FAT$C_UNDEFINED) ||
(*(int *)ptr > FAT$C_STREAMCR))
Fat.fat$v_rtype = FAT$C_STREAMLF; /* Unix I/O happy */
else
Fat.fat$v_rtype = *(int *)ptr;
break;
case RESTORE_RTYPE:
Fat.fat$v_rtype = old_rtype;
break;
default:
return SS$_BADPARAM; /* anything better? */
}
/*-----------------------------------------------------------------------
Go back and write modified data to the file header.
-----------------------------------------------------------------------*/
/* note, part of the FIB was cleared by earlier QIOW, so reset it */
Fib.FIB$L_ACCTL = FIB$M_NORECORD;
for (i=0;i<3;i++)
Fib.FIB$W_FID[i]=Nam.nam$w_fid[i];
for (i=0;i<3;i++)
Fib.FIB$W_DID[i]=Nam.nam$w_did[i];
/* Use the IO$_MODIFY function to change info about the file */
/* Note, used this way, the file is not opened, however this would */
/* normally cause the expiration and revision dates to be modified. */
/* Using FIB$M_NORECORD prohibits this from happening. */
status = sys$qiow(0,DevChan,IO$_MODIFY,&iosb,0,0,
&FibDesc,&FileName,0,0,&Atr,0);
if (!(status & 1)) return(status);
status = iosb[0];
if (!(status & 1)) return(status);
status = sys$dassgn(DevChan);
if (!(status & 1)) return(status);
/* look for next file, if none, no big deal.. */
status = sys$search(&Fab);
}
return(status);
} /* end function VMSmunch() */
