Пример #1
0
void rlTime::getLocalTime()
{
#ifdef RLUNIX
  time_t t;
  struct tm       *tms;
  struct timeval  tv;
  struct timezone tz;

  time(&t);
  tms = localtime(&t);
  gettimeofday(&tv, &tz);

  /* adjust year and month */
  tms->tm_year += 1900;
  tms->tm_mon  += 1;

  millisecond = (int)tv.tv_usec / 1000;
  second      = (int)tms->tm_sec;
  minute      = (int)tms->tm_min;
  hour        = (int)tms->tm_hour;
  day         = (int)tms->tm_mday;
  month       = (int)tms->tm_mon;
  year        = (int)tms->tm_year;
#endif

#ifdef __VMS
  TDS    tds;
  sys$numtim(&tds, 0);
  millisecond  = (int)tds.hth * 10;
  second       = (int)tds.sec;
  minute       = (int)tds.min;
  hour         = (int)tds.hour;
  day          = (int)tds.day;
  month        = (int)tds.month;
  year         = (int)tds.year;
#endif

#ifdef RLWIN32
  SYSTEMTIME st;
  GetLocalTime(&st);
  millisecond  = st.wMilliseconds;
  second       = st.wSecond;
  minute       = st.wMinute;
  hour         = st.wHour;
  day          = st.wDay;
  month        = st.wMonth;
  year         = st.wYear;
#endif
}
Пример #2
0
struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result)
{
    struct tm *ts = NULL;

#if defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32) && (!defined(OPENSSL_SYS_VMS) || defined(gmtime_r)) && !defined(OPENSSL_SYS_MACOSX)
    /*
     * should return &data, but doesn't on some systems, so we don't even
     * look at the return value
     */
    gmtime_r(timer, result);
    ts = result;
#elif !defined(OPENSSL_SYS_VMS) || defined(VMS_GMTIME_OK)
    ts = gmtime(timer);
    if (ts == NULL)
        return NULL;

    memcpy(result, ts, sizeof(struct tm));
    ts = result;
#endif
#if defined( OPENSSL_SYS_VMS) && !defined( VMS_GMTIME_OK)
    if (ts == NULL) {
        static $DESCRIPTOR(tabnam, "LNM$DCL_LOGICAL");
        static $DESCRIPTOR(lognam, "SYS$TIMEZONE_DIFFERENTIAL");
        char logvalue[256];
        unsigned int reslen = 0;
        struct {
            short buflen;
            short code;
            void *bufaddr;
            unsigned int *reslen;
        } itemlist[] = {
            {
                0, LNM$_STRING, 0, 0
            },
            {
                0, 0, 0, 0
            },
        };
        int status;
        time_t t;

        /* Get the value for SYS$TIMEZONE_DIFFERENTIAL */
        itemlist[0].buflen = sizeof(logvalue);
        itemlist[0].bufaddr = logvalue;
        itemlist[0].reslen = &reslen;
        status = sys$trnlnm(0, &tabnam, &lognam, 0, itemlist);
        if (!(status & 1))
            return NULL;
        logvalue[reslen] = '\0';

        t = *timer;

/* The following is extracted from the DEC C header time.h */
        /*
         **  Beginning in OpenVMS Version 7.0 mktime, time, ctime, strftime
         **  have two implementations.  One implementation is provided
         **  for compatibility and deals with time in terms of local time,
         **  the other __utc_* deals with time in terms of UTC.
         */
        /*
         * We use the same conditions as in said time.h to check if we should
         * assume that t contains local time (and should therefore be
         * adjusted) or UTC (and should therefore be left untouched).
         */
# if __CRTL_VER < 70000000 || defined _VMS_V6_SOURCE
        /* Get the numerical value of the equivalence string */
        status = atoi(logvalue);

        /* and use it to move time to GMT */
        t -= status;
# endif

        /* then convert the result to the time structure */

        /*
         * Since there was no gmtime_r() to do this stuff for us, we have to
         * do it the hard way.
         */
        {
            /*-
             * The VMS epoch is the astronomical Smithsonian date,
               if I remember correctly, which is November 17, 1858.
               Furthermore, time is measure in tenths of microseconds
               and stored in quadwords (64 bit integers).  unix_epoch
               below is January 1st 1970 expressed as a VMS time.  The
               following code was used to get this number:

               #include <stdio.h>
               #include <stdlib.h>
               #include <lib$routines.h>
               #include <starlet.h>

               main()
               {
                 unsigned long systime[2];
                 unsigned short epoch_values[7] =
                   { 1970, 1, 1, 0, 0, 0, 0 };

                 lib$cvt_vectim(epoch_values, systime);

                 printf("%u %u", systime[0], systime[1]);
               }
            */
            unsigned long unix_epoch[2] = { 1273708544, 8164711 };
            unsigned long deltatime[2];
            unsigned long systime[2];
            struct vms_vectime {
                short year, month, day, hour, minute, second, centi_second;
            } time_values;
            long operation;

            /*
             * Turn the number of seconds since January 1st 1970 to an
             * internal delta time. Note that lib$cvt_to_internal_time() will
             * assume that t is signed, and will therefore break on 32-bit
             * systems some time in 2038.
             */
            operation = LIB$K_DELTA_SECONDS;
            status = lib$cvt_to_internal_time(&operation, &t, deltatime);

            /*
             * Add the delta time with the Unix epoch and we have the current
             * UTC time in internal format
             */
            status = lib$add_times(unix_epoch, deltatime, systime);

            /* Turn the internal time into a time vector */
            status = sys$numtim(&time_values, systime);

            /* Fill in the struct tm with the result */
            result->tm_sec = time_values.second;
            result->tm_min = time_values.minute;
            result->tm_hour = time_values.hour;
            result->tm_mday = time_values.day;
            result->tm_mon = time_values.month - 1;
            result->tm_year = time_values.year - 1900;

            operation = LIB$K_DAY_OF_WEEK;
            status = lib$cvt_from_internal_time(&operation,
                                                &result->tm_wday, systime);
            result->tm_wday %= 7;

            operation = LIB$K_DAY_OF_YEAR;
            status = lib$cvt_from_internal_time(&operation,
                                                &result->tm_yday, systime);
            result->tm_yday--;

            result->tm_isdst = 0; /* There's no way to know... */

            ts = result;
        }
    }
#endif
    return ts;
}
Пример #3
0
unsigned long sys$asctim(unsigned short *timlen,
                         struct dsc$descriptor *timbuf,
                         const void *timadra, unsigned long cvtflg)
{
    const struct TIME *timadr = (const struct TIME *)timadra;
    long count,timval;
    unsigned short wrktim[7];
    long length = timbuf->dsc$w_length;
    char *chrptr = timbuf->dsc$a_pointer;

    /* First use sys_numtim to get the date/time fields... */

    {
        register unsigned sts;
        sts = sys$numtim(wrktim, timadr);
        if ((sts & 1) == 0) {
            return sts;
        }
    }

    /* See if we want delta days or date... */

    if (cvtflg == 0) {

        /* Check if date or delta time... */

        if (*wrktim) {

            /* Put in days and month... */

            if (length > 0) {
                if ((timval = wrktim[2]) / 10 == 0) {
                    *chrptr++ = ' ';
                } else {
                    *chrptr++ = '0' + timval / 10;
                }
                length--;
            }
            if (length > 0) {
                *chrptr++ = '0' + (timval % 10);
                length--;
            }
            if ((count = length) > 5) count = 5;
            memcpy(chrptr,month_names + (wrktim[1] * 4 - 4),count);
            length -= count;
            chrptr += count;
            timval = *wrktim;
        } else {

            /* Get delta days... */

            timval = wrktim[2];
        }

        /* Common code for year number and delta days!! */

        count = 10000;
        if (timval < count) {
            count = 1000;
            while (length > 0 && timval < count && count > 1) {
                length--;
                *chrptr++ = ' ';
                count /= 10;
            }
        }
        while (length > 0 && count > 0) {
            length--;
            *chrptr++ = '0' + (timval / count);
            timval = timval % count;
            count /= 10;
        }

        /* Space between date and time... */

        if (length > 0) {
            *chrptr++ = ' ';
            length--;
        }
    }
    /* Do time... :-) */

    count = 3;
    do {
        timval = wrktim[count];
        if (length >= 1) *chrptr++ = '0' + (timval / 10);
        if (length >= 2) {
            *chrptr++ = '0' + (timval % 10);
            length -= 2;
        } else {
            length = 0;
        }
        if (count < 6 && length > 0) {
            length--;
            if (count == 5) {
                *chrptr++ = '.';
            } else {
                *chrptr++ = ':';
            }
        }
    } while (++count < 7);

    /* We've done it - time to return length... */

    if (timlen != NULL) *timlen = timbuf->dsc$w_length - length;
    return SS$_NORMAL;
}
Пример #4
0
Boolean Process::getCreationDate (CIMDateTime & d)
const
{
    long status;
    long dst_desc[2];
    char cimtime[80] = "";
    char log_string[] = "SYS$TIMEZONE_DAYLIGHT_SAVING";
    char libdst;
    unsigned __int64 bintime = 0;
    unsigned short int timbuf[7];
    unsigned long libop;
    unsigned long libdayweek;
    unsigned long libdayear;
    unsigned int retlen;
    struct tm timetm;
    struct tm *ptimetm = &timetm;

    // Added to get system uptime for SWAPPER process - PTR 73-51-29
    long item = SYI$_BOOTTIME;
    char t_string[24] = "";
    unsigned __int64  val = 0;
    struct dsc$descriptor_s sysinfo;

    sysinfo.dsc$b_dtype = DSC$K_DTYPE_T;
    sysinfo.dsc$b_class = DSC$K_CLASS_S;
    sysinfo.dsc$w_length = sizeof (t_string);
    sysinfo.dsc$a_pointer = t_string;

    static $DESCRIPTOR (lnm_tbl, "LNM$SYSTEM");
    struct
    {
        unsigned short wLength;
        unsigned short wCode;
        void *pBuffer;
        unsigned int *pRetLen;
        int term;
    } dst_item_list;

    bintime = pInfo.p_stime;

    libop = LIB$K_DAY_OF_WEEK;
    status = lib$cvt_from_internal_time (&libop, &libdayweek, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
        return false;
    }

    libop = LIB$K_DAY_OF_YEAR;
    status = lib$cvt_from_internal_time (&libop, &libdayear, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
        return false;
    }

    dst_desc[0] = strlen (log_string);
    dst_desc[1] = (long) log_string;
    dst_item_list.wLength = 1;
    dst_item_list.wCode = LNM$_STRING;
    dst_item_list.pBuffer = &libdst;
    dst_item_list.pRetLen = &retlen;
    dst_item_list.term = 0;

    status = sys$trnlnm (0, &lnm_tbl, &dst_desc, 0, &dst_item_list);
    if (!$VMS_STATUS_SUCCESS (status))
    {
        return false;
    }

    //  Added to get sysuptime for SWAPPER process --- PTR 73-51-29
    if (bintime == 0)
    {
        status = lib$getsyi(&item, 0, &sysinfo, &val, 0, 0);
        status = sys$bintim(&sysinfo, &bintime);
    }

    status = sys$numtim (timbuf, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
        return false;
    }

    timetm.tm_sec = timbuf[5];
    timetm.tm_min = timbuf[4];
    timetm.tm_hour = timbuf[3];
    timetm.tm_mday = timbuf[2];
    timetm.tm_mon = timbuf[1] - 1;
    timetm.tm_year = timbuf[0] - 1900;
    timetm.tm_wday = libdayweek - 1;
    timetm.tm_yday = libdayear - 1;
    timetm.tm_isdst = 0;
    if (libdst != 48)
    {
        timetm.tm_isdst = 1;
    }
    timetm.tm_gmtoff = -18000;
    timetm.tm_zone = "EST";

    if (convertToCIMDateString (ptimetm, cimtime) != -1)
    {
        d = CIMDateTime (cimtime);
        return true;
    }
    return false;
}
Пример #5
0
Boolean Process::getCreationDate (CIMDateTime & d)
  const
  {
    long status,
      dst_desc[2];
    char cimtime[80] = "";
    char log_string[] = "SYS$TIMEZONE_DAYLIGHT_SAVING";
    char libdst;
    unsigned __int64 bintime = 0;
    unsigned short int timbuf[7];
    unsigned long libop,
      libdayweek,
      libdayear;
    unsigned int retlen;
    struct tm timetm;
    struct tm *ptimetm = &timetm;
    static $DESCRIPTOR (lnm_tbl, "LNM$SYSTEM");
    struct
    {
      unsigned short wLength;
      unsigned short wCode;
      void *pBuffer;
      unsigned int *pRetLen;
      int term;
    }
    item_list;

      bintime = pInfo->p_stime;

      libop = LIB$K_DAY_OF_WEEK;
      status = lib$cvt_from_internal_time (&libop, &libdayweek, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
      return false;
    }

    libop = LIB$K_DAY_OF_YEAR;
    status = lib$cvt_from_internal_time (&libop, &libdayear, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
      return false;
    }

    dst_desc[0] = strlen (log_string);
    dst_desc[1] = (long) log_string;
    item_list.wLength = 1;
    item_list.wCode = LNM$_STRING;
    item_list.pBuffer = &libdst;
    item_list.pRetLen = &retlen;
    item_list.term = 0;

    status = sys$trnlnm (0, &lnm_tbl, &dst_desc, 0, &item_list);
    if (!$VMS_STATUS_SUCCESS (status))
    {
      return false;
    }

    status = sys$numtim (timbuf, &bintime);
    if (!$VMS_STATUS_SUCCESS (status))
    {
      return false;
    }

    timetm.tm_sec = timbuf[5];
    timetm.tm_min = timbuf[4];
    timetm.tm_hour = timbuf[3];
    timetm.tm_mday = timbuf[2];
    timetm.tm_mon = timbuf[1] - 1;
    timetm.tm_year = timbuf[0] - 1900;
    timetm.tm_wday = libdayweek - 1;
    timetm.tm_yday = libdayear - 1;
    timetm.tm_isdst = 0;
    if (libdst != 48)
    {
      timetm.tm_isdst = 1;
    }
    timetm.tm_gmtoff = -18000;
    timetm.tm_zone = "EST";

    if (convertToCIMDateString (ptimetm, cimtime) != -1)
    {
      d = CIMDateTime (cimtime);
      return true;
    }
    return false;
  }
Пример #6
0
static unsigned long
get_time (struct dsc$descriptor_s *qual, char *timearg)
{
/*
**  Routine:    get_time
**
**  Function:   This routine reads the argument string of the qualifier
**              "qual" that should be a VMS syntax date-time string.  The
**              date-time string is converted into the standard format
**              "mmddyyyy", specifying an absolute date.  The converted
**              string is written into the 9 bytes wide buffer "timearg".
**
**  Formal parameters:
**
**      qual    - Address of descriptor for the qualifier name
**      timearg - Address of a buffer carrying the 8-char time string returned
**
*/

    register unsigned long status;
    struct dsc$descriptor_d time_str;
    struct quadword {
        long high;
        long low;
    } bintimbuf = {0,0};
#ifdef __DECC
#pragma member_alignment save
#pragma nomember_alignment
#endif  /* __DECC */
    struct tim {
        short year;
        short month;
        short day;
        short hour;
        short minute;
        short second;
        short hundred;
    } numtimbuf;
#ifdef __DECC
#pragma member_alignment restore
#endif

    init_dyndesc(time_str);

    status = cli$get_value(qual, &time_str);
    /*
    **  If a date is given, convert it to 64-bit binary.
    */
    if (time_str.dsc$w_length) {
        status = sys$bintim(&time_str, &bintimbuf);
        if (!(status & 1)) return (status);
        str$free1_dx(&time_str);
    }
    /*
    **  Now call $NUMTIM to get the month, day, and year.
    */
    status = sys$numtim(&numtimbuf, (bintimbuf.low ? &bintimbuf : NULL));
    /*
    **  Write the "mmddyyyy" string to the return buffer.
    */
    if (!(status & 1)) {
        *timearg = '\0';
    } else {
        sprintf(timearg, "%02d%02d%04d", numtimbuf.month,
                numtimbuf.day, numtimbuf.year);
    }
    return (status);
}
Пример #7
0
struct tm *OPENSSL_gmtime(const time_t *timer, struct tm *result)
	{
	struct tm *ts = NULL;

#if defined(OPENSSL_THREADS) && !defined(OPENSSL_SYS_WIN32) && !defined(OPENSSL_SYS_OS2) && !defined(__CYGWIN32__) && (!defined(OPENSSL_SYS_VMS) || defined(gmtime_r)) && !defined(OPENSSL_SYS_MACOSX) && !defined(OPENSSL_SYS_SUNOS)
	/* should return &data, but doesn't on some systems,
	   so we don't even look at the return value */
	gmtime_r(timer,result);
	ts = result;
#elif !defined(OPENSSL_SYS_VMS)
	ts = gmtime(timer);
	if (ts == NULL)
		return NULL;

	memcpy(result, ts, sizeof(struct tm));
	ts = result;
#endif
#ifdef OPENSSL_SYS_VMS
	if (ts == NULL)
		{
		static $DESCRIPTOR(tabnam,"LNM$DCL_LOGICAL");
		static $DESCRIPTOR(lognam,"SYS$TIMEZONE_DIFFERENTIAL");
		char logvalue[256];
		unsigned int reslen = 0;
		struct {
			short buflen;
			short code;
			void *bufaddr;
			unsigned int *reslen;
		} itemlist[] = {
			{ 0, LNM$_STRING, 0, 0 },
			{ 0, 0, 0, 0 },
		};
		int status;
		time_t t;

		/* Get the value for SYS$TIMEZONE_DIFFERENTIAL */
		itemlist[0].buflen = sizeof(logvalue);
		itemlist[0].bufaddr = logvalue;
		itemlist[0].reslen = &reslen;
		status = sys$trnlnm(0, &tabnam, &lognam, 0, itemlist);
		if (!(status & 1))
			return NULL;
		logvalue[reslen] = '\0';

		/* Get the numerical value of the equivalence string */
		status = atoi(logvalue);

		/* and use it to move time to GMT */
		t = *timer - status;

		/* then convert the result to the time structure */
#ifndef OPENSSL_THREADS
		ts=(struct tm *)localtime(&t);
#else
		/* Since there was no gmtime_r() to do this stuff for us,
		   we have to do it the hard way. */
		{
		/* The VMS epoch is the astronomical Smithsonian date,
		   if I remember correctly, which is November 17, 1858.
		   Furthermore, time is measure in thenths of microseconds
		   and stored in quadwords (64 bit integers).  unix_epoch
		   below is January 1st 1970 expressed as a VMS time.  The
		   following code was used to get this number:

		   #include <stdio.h>
		   #include <stdlib.h>
		   #include <lib$routines.h>
		   #include <starlet.h>

		   main()
		   {
		     unsigned long systime[2];
		     unsigned short epoch_values[7] =
		       { 1970, 1, 1, 0, 0, 0, 0 };

		     lib$cvt_vectim(epoch_values, systime);

		     printf("%u %u", systime[0], systime[1]);
		   }
		*/
		unsigned long unix_epoch[2] = { 1273708544, 8164711 };
		unsigned long deltatime[2];
		unsigned long systime[2];
		struct vms_vectime
			{
			short year, month, day, hour, minute, second,
				centi_second;
			} time_values;
		long operation;

		/* Turn the number of seconds since January 1st 1970 to
		   an internal delta time.
		   Note that lib$cvt_to_internal_time() will assume
		   that t is signed, and will therefore break on 32-bit
		   systems some time in 2038.
		*/
		operation = LIB$K_DELTA_SECONDS;
		status = lib$cvt_to_internal_time(&operation,
			&t, deltatime);

		/* Add the delta time with the Unix epoch and we have
		   the current UTC time in internal format */
		status = lib$add_times(unix_epoch, deltatime, systime);

		/* Turn the internal time into a time vector */
		status = sys$numtim(&time_values, systime);

		/* Fill in the struct tm with the result */
		result->tm_sec = time_values.second;
		result->tm_min = time_values.minute;
		result->tm_hour = time_values.hour;
		result->tm_mday = time_values.day;
		result->tm_mon = time_values.month - 1;
		result->tm_year = time_values.year - 1900;

		operation = LIB$K_DAY_OF_WEEK;
		status = lib$cvt_from_internal_time(&operation,
			&result->tm_wday, systime);
		result->tm_wday %= 7;

		operation = LIB$K_DAY_OF_YEAR;
		status = lib$cvt_from_internal_time(&operation,
			&result->tm_yday, systime);
		result->tm_yday--;

		result->tm_isdst = 0; /* There's no way to know... */

		ts = result;
#endif
		}
		}
#endif
	return ts;
	}	
Пример #8
0
Boolean ComputerSystem::getInstallDate(CIMProperty& p)
{
   int status, istr;
   char record1[512], *rptr1=0;
   FILE *fptr1=0;
   unsigned __int64 bintime=0;
   unsigned short int timbuf[7], val=0;
   char cimtime[80]="";
   struct tm timetm;
   struct tm *ptimetm=&timetm;
   time_t tme=0, tme1=0;
   char t_string[24]="", libdst;
   unsigned int retlen;
   unsigned long libop, libdayweek, libdayear;
   long dst_desc[2];
   char log_string[]="SYS$TIMEZONE_DAYLIGHT_SAVING";
   struct dsc$descriptor_s sysinfo;
   static $DESCRIPTOR(lnm_tbl,"LNM$SYSTEM");
   struct {
        unsigned short wLength;
        unsigned short wCode;
        void*    pBuffer;
        unsigned int* pRetLen;
        int term;
        } item_list;

   sysinfo.dsc$b_dtype=DSC$K_DTYPE_T;
   sysinfo.dsc$b_class=DSC$K_CLASS_S;
   sysinfo.dsc$w_length=sizeof(t_string);
   sysinfo.dsc$a_pointer=t_string;

   status = system("pipe product show history openvms | search/nolog/nowarn/out=history.out sys$input install");
   if (!$VMS_STATUS_SUCCESS(status)) return false;

   if (fptr1 = fopen("history.out", "r"))
   {
        while (fgets(record1, sizeof(record1), fptr1))
        {
           for (istr=0; istr<=(sizeof(record1)-4); istr++)
           {
                if ((rptr1 = strstr(record1+istr,"-")) && !strncmp(rptr1+4,"-",1)) break;
                rptr1 = 0;
           }
           if (rptr1)
           {
                time(&tme);
                tme1 = mktime(ptimetm);		/* get timezone */
		strcpy(t_string,rptr1-2);
                t_string[20]='.';
                t_string[21]='0';
                t_string[22]='0';
                t_string[23]='0';
		status = sys$bintim (&sysinfo, &bintime);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		libop=LIB$K_DAY_OF_WEEK;
		status=lib$cvt_from_internal_time (&libop,&libdayweek,&bintime);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		libop=LIB$K_DAY_OF_YEAR;
		status=lib$cvt_from_internal_time (&libop,&libdayear,&bintime);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		dst_desc[0]  = strlen(log_string);
		dst_desc[1]  = (long) log_string;
		item_list.wLength = 1;
		item_list.wCode = LNM$_STRING;
		item_list.pBuffer = &libdst;
		item_list.pRetLen = &retlen;
		item_list.term =0;

		status = sys$trnlnm (0,&lnm_tbl,&dst_desc,0,&item_list);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		status = sys$numtim(timbuf,&bintime);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		timetm.tm_sec = timbuf[5];
		timetm.tm_min = timbuf[4];
		timetm.tm_hour = timbuf[3];
		timetm.tm_mday = timbuf[2];
		timetm.tm_mon = timbuf[1]-1;
		timetm.tm_year = timbuf[0]-1900;
		timetm.tm_wday = libdayweek-1;
		timetm.tm_yday = libdayear-1;
		timetm.tm_isdst = 0;
		if (libdst != 48) timetm.tm_isdst = 1;

		status = convertToCIMDateString(ptimetm,cimtime);
		if (!$VMS_STATUS_SUCCESS(status)) return false;

		CIMDateTime _installDate(cimtime);
		p = CIMProperty(PROPERTY_INSTALL_DATE, _installDate);
                fclose (fptr1);
                status = system("if (f$search(\"history.out\") .nes. \"\") then delete history.out;*");
                return true;
           } // end if (rptr1 = strstr(record1,"Install"))
        }
        fclose (fptr1);
        status = system("if (f$search(\"history.out\") .nes. \"\") then delete history.out;*");
        return false;
   } // end if (fptr1 = fopen(history.out, "r"))
   else
   {
        fclose (fptr1);
        status = system("if (f$search(\"history.out\") .nes. \"\") then delete history.out;*");
        return false;
   }
}