Clock.shar / revised nbs_time

Sanford 'Sandy' Zelkovitz sandy at turnkey.TCC.COM
Mon Aug 1 00:03:06 AEST 1988


Since I sent through the net, nbs_time, a NEW and MUCH improved version of
the program has been uploaded to my bbs by the author, Warren H. Tucker.
Not only did he improve the main program but he also included a few handy
additional programs as enhancements. Below, you will find all of the source 
code, in SHAR format, as sent to me.
 
Sanford ( Sandy ) Zelkovitz
XBBS  714-898-8634

------------------------------ Cut / Snip / Ax  Here ---------------------------


#!/bin/sh
# to extract, remove the header and type "sh filename"
if `test ! -s ./CMOSstime.c`
then
echo "writing ./CMOSstime.c"
cat > ./CMOSstime.c << '\Rogue\Monster\'
/* CHK=0xC608 */
/*+-------------------------------------------------------------------------
	CMOSstime.c -- read cmos clock then stime()

  Defined functions:
	date_to_epochsecs(year,month,day,hour,min,sec)
	days_since_epoch(year,month,day)
	leap_year(yr)
	main(argc,argv,envp)

  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA 30075
  (404)587-5766

--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-18:59-wht-release */
/*:07-22-1988-19:34-wht-creation */

#include <stdio.h>
#include <fcntl.h>
#include <sys/types.h>
#include <time.h>

#include "dev_cmos.h"

int leap_year(int );
int days_since_epoch(int ,int ,int );
long date_to_epochsecs(int ,int ,int ,int ,int ,int );

char	*ctime(long *);
int		stime(long *);
long	time(long *);

char	*cmos = "/dev/cmos";

/*+-------------------------------------------------------------------------
	leap_year(yr) -- returns 1 if leap year, 0 otherwise 
--------------------------------------------------------------------------*/
int
leap_year(yr)
int yr;
{
	return (yr % 4 == 0 && yr % 100 != 0 || yr % 400 == 0);
}	/* end of leap_year */

/*+-------------------------------------------------------------------------
	days_since_epoch(year,month,day)
Return the number of days between Jan 1, 1970 and year,month,day
year is full year (e.g., 1988)
month is 0-11
day is 0-30 (must be legal day in month)
--------------------------------------------------------------------------*/
int
days_since_epoch(year,month,day)
int		year;
int		month;
int		day;
{
register int days = day + 1;	/* adjust for day 0-n instead of 1-n */
register int m;
register int y;
register char *md = "\37\34\37\36\37\36\37\37\36\37\36\37";

	for (y = 1970; y < year; ++y) 
	{
		days += 365;
		if (leap_year(y)) ++days;
	}
	for (m = 0; m < month; ++m)
		days += md[m] + (m == 1 && leap_year(y));

	return(days);

}	/* end of days_since_epoch */

/*+-------------------------------------------------------------------------
	date_to_epochsecs(year,month,day,hour,min,sec)
Convert arguments into long seconds since 1/1/1970
year is full year (e.g., 1988)
month is 0-11
day is 0-30 (must be legal day in month)
hour is 0-23, min and sec 0-59
--------------------------------------------------------------------------*/
long
date_to_epochsecs(year,month,day,hour,min,sec)
int		year;
int		month;
int		day;
int		hour;
int		min;
int		sec;
{
register int m1;
register int m2;
long	t;
struct tm *tp;
struct tm *localtime();

	t = (days_since_epoch(year,month,day) - 1) * 86400L
		+ (hour * 3600L) + (min * 60L) + sec;

	/* Now the hard part -- correct for the time zone */
	tp = localtime(&t);
	m1 = tp->tm_hour * 60 + tp->tm_min;
	m2 = (hour * 60) + min;
	t -= ((m1 - m2 + 720 + 1440) % 1440 - 720) * 60L;
	return(t);

}	/* end of date_to_epochsecs */

/*+-------------------------------------------------------------------------
	main(argc,argv,envp)
--------------------------------------------------------------------------*/
main(argc,argv,envp)
int		argc;
char	**argv;
char	**envp;
{
int		year;
int		month;
int		day;
int		hour;
int		min;
int		sec;
int		fdcmos;
long	now;

	setbuf(stdout,NULL);
	setbuf(stderr,NULL);

	if((fdcmos = open(cmos,O_RDONLY)) < 0)
	{
		perror(cmos);
		exit(1);
	}

	get_clock(fdcmos,&year,&month,&day,&hour,&min,&sec);
	now = date_to_epochsecs(year,month,day,hour,min,sec);
	if(stime(&now))
	{
		perror("stime");
		exit(1);
	}
	time(&now);
	fputs("System time after stime(): ",stdout);
	fputs(ctime(&now), stdout);

	exit(0);
}	/* end of main */
\Rogue\Monster\
else
  echo "will not over write ./CMOSstime.c"
fi
if `test ! -s ./NBSsetclk.c`
then
echo "writing ./NBSsetclk.c"
cat > ./NBSsetclk.c << '\Rogue\Monster\'
/* CHK=0x0BFA */
/*+-----------------------------------------------------------------------
  SCO XENIX SYSTEM V.2  (Others too?)

  NBSsetclk.c -- call NBS, get time, hangup quickly, set system time,
                 update cmos clock (/dev/cmos)

  Defined functions:
	create_lock_file(lock_file_name)
	hangup(sig)
	hayes_dial()
	hayes_send_cmd(cmd)
	lclose()
	lgetc(char_rtnd)
	lgetc_timeout(timeout_msec)
	lgets_timeout(lrwt)
	lkill_buf()
	lock_tty()
	lopen()
	lputc(lchar)
	lputs_paced(pace_msec,string)
	lrdchk()
	lset_baud_rate(ioctl_flag)
	lset_parity(ioctl_flag)
	main(argc,argv,envp)
	make_lock_name(ttyname,lock_file_name)
	other_lock_name(first_lock_name)
	to_lower(ch)
	to_upper(ch)
	ulcmpb(str1,str2)
	ulindex(str1,str2)
	unlock_tty()
	usage()
	valid_baud_rate(baud)


  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA  30075
  (404)587-5766

  Note: must be root to execute

  Exit status codes for the program:
  1-n  signal values if program killed
  200  illogical cmos device behavior (when reading clock)
  249  stime() call failed
  250  could not open communications line
  251  /dev/cmos read&write access denied
  252  user is not root
  253  usage
  254  couldn't get time from line (after 40 retries! BAD line conditions)
  255  could not establish a connection

------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-19:03-wht-release */
/*:07-23-1988-13:11-wht-get good parsed time before hanging up w/max retries */
/*:07-23-1988-12:50-wht-do not use setclock ... messes up new system time */
/*:07-22-1988-20:17-wht-change output format */
/*:07-18-1988-22:07-wht-working! */
/*:07-18-1988-17:27-wht-creation */

#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <time.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <termio.h>

#include "dev_cmos.h"

#ifndef ushort
#define ushort	unsigned short
#endif
#ifndef uchar
#define uchar	unsigned char
#endif
#ifndef uint
#define uint	unsigned int
#endif
#ifndef ulong
#define ulong	unsigned long
#endif

void usage(void);
char to_upper(char );
char to_lower(char );
int ulcmpb(unsigned char  *,unsigned char  *);
int ulindex(char  *,char  *);
void hangup(int );
int make_lock_name(char  *,char  *);
int create_lock_file(char  *);
char  *other_lock_name(char  *);
int lock_tty(void );
void unlock_tty(void );
int valid_baud_rate(unsigned int );
int lset_baud_rate(int );
void lset_parity(int );
void lgetc(char  *);
int lrdchk(void );
void lputc(char );
void lputs_paced(int ,char  *);
char  *lgets_timeout(struct lrwt  *);
int lgetc_timeout(unsigned long );
void lkill_buf(void );
int lopen(void );
void lclose(void );
int hayes_send_cmd(char  *);
int hayes_dial(void );

ushort	geteuid();
ushort	getuid();
long	nap(long);
long 	time(long *);
char	*ctime(long *);

typedef struct lrwt	/* param to lgets_timeout in eculine.c */
{
ulong	to1;		/* timeout for 1st character (granularity 20) */
ulong	to2;		/* timeout for each next char (granularity 20) */
int		raw_flag;	/* !=0, rtn full buffer, ==0, rtn filtered hayes result */
char	*buffer;	/* buffer to fill */
int		bufsize;	/* size of buffer */
int		count;		/* from proc, count rcvd */
}	LRWT;

#define	EPOCH		40587					/* UNIX starts JD 2440587, */
#define	leap(y, m)	((y+m-1 - 70%m) / m)	/* also known as 1/1/70 */
#define	TONE		'*'
/* #define	TIME		"\n%05ld %03d %02d%02d%02d UTC" */
#define	TIME		"%05ld %03d %02d%02d%02d UTC"

/* for better source line utilization, frequent use of 'fprintf' and 'stderr'
   warrants the following */
#define pf	printf
#define	ff	fprintf
#define se	stderr
#define so	stdout

/* lopen() and related routines error codes */
#define LOPEN_INVALID	-1		/* for invalid tty name */
#define LOPEN_UNKPID	-2		/* unknown pid using line */
#define LOPEN_LCKERR	-3		/* lock file open error */
#define LOPEN_NODEV		-4		/* device does not exist */
#define LOPEN_OPNFAIL	-5		/* count not open line */
#define LOPEN_ALREADY	-6		/* line already open */

extern char	*revision;		/* ecurev.c temp file from buildrev */
extern char	*numeric_revision;	/*ecunumrev.c */

char	LLCKname[128];		/* lock file name */
char	Ltelno[64];			/* telephone number for remote or null */
char	Lline[64];			/* line name */
int		Liofd;				/* file descriptor for line */
int		Lparity;			/* 0==NONE, 'e' == even, 'o' == odd */
struct termio	Llv;		/* attributes for the line to remote */
uint	Lbaud;				/* baud rate */
ushort	euid;
ushort	uid;
char	*cmos = "/dev/cmos";

/*+-------------------------------------------------------------------------
	usage()
--------------------------------------------------------------------------*/
void
usage()
{
	ff(se,"Usage: nbs_time [-][-e][-o][-n][-b#][-t#]\n");
	ff(se,"Defaults 1200-N %s %s\n",Ltelno,Lline);
	ff(se," -        use defaults\n");
	ff(se," -e       even parity\n");
	ff(se," -o       odd parity\n");
	ff(se," -n       no parity\n");
	ff(se," -b#      baud rate\n");
	ff(se," -t#      telephone number\n");
	ff(se," -l<name> line (/dev/tty??)\n");
	exit(253);

}	/* end of usage */

/*+-------------------------------------------------------------------------
    to_upper() / to_lower()
  one would think that these were relatively standard
  types of thing, but MSC/Xenix specifies toupper() to convert to upper
  case if not already and Unix says to adjust without testing,
  so, two stupid little routines here
  ASCII only -- no EBCDIC gradoo here please
--------------------------------------------------------------------------*/
char to_upper(ch)
register char    ch;
{ return( ((ch >= 'a') && (ch <= 'z')) ? ch - 0x20 : ch);
}   /* end of to_upper() */

char to_lower(ch)
register char    ch;
{ return( ((ch >= 'A') && (ch <= 'Z')) ? ch + 0x20 : ch);
}   /* end of to_lower() */

/*+----------------------------------------------------------------------------
    ulcmpb(str1,str) -- Upper/Lower [case insensitive] Compare Bytes

 Returns -1 if strings are equal, else failing character position
 If the second strings terminates with a null and both strings have matched
 character for character until that point, then -1 is returned.
 NOTE:  this is not a test for complete equality of two strings, but allows
 discovery of a string as a substring in a larger containing string.
-----------------------------------------------------------------------------*/
int
ulcmpb(str1,str2)
register unsigned char    *str1;
register unsigned char    *str2;
{
register int     istr;

    for( istr=0 ; ;  ++istr )
    {
        if(str2[istr] == '\0')          /* if second string exhausts, match! */
            return(-1);
        if((str1[istr] == '\0' ) ||
			( to_upper(str1[istr]) != to_upper(str2[istr]) ))
            return(istr);
    }
	/*NOTREACHED*/
} /* end of ulcmpb */

/*+-------------------------------------------------------------------------
    ulindex:  Upper/Lower [case insensitive] Index functioni

  Returns position of 'str2' in 'str1' if found
  If 'str2' is null, then 0 is returned (null matches anything)
  Returns -1 if not found

  uses 'ulcmpb'
--------------------------------------------------------------------------*/
int ulindex(str1,str2)
register char	*str1;	/* the (target) string to search */
register char	*str2;	/* the (comparand) string to search for */
{
register int	istr1 = 0;		/* moving index into str1 */
register char	*mstr = str1;	/* moving string pointer */

    if(str2[0] == '\0')             /* null string matches anything */
        return(0);
	while(1)
    {
        if(*mstr == '\0')           /* if we exhaust target string, flunk */
            return(-1);
        /* Can we find either case of first comparand char in target? */
        if( to_upper(*mstr) == to_upper(str2[0]) )
        {
            /* we have a first char match... does rest of string match? */
            if(ulcmpb(mstr,str2) == -1)         /* if the rest matches, ... */
                return(istr1);                  /* ... return match position */
        }
        /* we did not match this time... increment istr1, mstr and try again */
        ++istr1;
        ++mstr;
    }
}	/* end of ulindex */

/*+-----------------------------------------------------------------------
	hangup(sig) -- terminate program (with comm line cleanup)
------------------------------------------------------------------------*/
void
hangup(sig)
int		sig;
{
void	lclose();

	ff(se,"\n");
	if(Liofd != -1)
		lclose();			/* close line */
	exit(sig);
}	/* end of hangup */

/*+-------------------------------------------------------------------------
	make_lock_name(ttyname,lock_file_name)
--------------------------------------------------------------------------*/
make_lock_name(ttyname,lock_file_name)
char	*ttyname;
char	*lock_file_name;
{
register int itmp;
register char *ttyptr;

	if((itmp = ulindex(ttyname,"/dev/tty")) != 0)
		return(LOPEN_INVALID);

	itmp = ulindex(ttyname,"tty");

	ttyptr = &ttyname[itmp];
	strcpy(lock_file_name,"/usr/spool/uucp/LCK..");
	strcat(lock_file_name,ttyptr);
	return(0);

}	/* end of make_lock_name */

/*+-----------------------------------------------------------------------
	create_lock_file()

  Returns 0 if lock file created,else error codes:
	LOPEN_ if error
    else pid of process currently busy on device
------------------------------------------------------------------------*/
create_lock_file(lock_file_name)
char	*lock_file_name;
{
register int	fd_lockf;
int		pid;
int		old_umask;
int		erc = 0;

	old_umask = umask(0);

	if((fd_lockf = open(lock_file_name,O_CREAT | O_EXCL | O_RDWR,0666)) < 0)
	{		/* file already exists */
		if((fd_lockf = open(lock_file_name,O_RDWR,0666)) < 0)
		{
			erc = LOPEN_LCKERR;
			goto RESTORE_UMASK;
		}
		else if(read(fd_lockf,(char *)&pid,sizeof(pid))) 
		{
			if(kill(pid,0)) 				/* is owner pid already dead? */
			{
				if(errno == ESRCH)			/* this error sez so */
				{
					pid = getpid();			/* so we will use it */
					lseek(fd_lockf,0L,0);
					write(fd_lockf,(char *)&pid,sizeof(pid));
					close(fd_lockf);
					erc = 0;
					goto RESTORE_UMASK;
				}
			} 
			/* owner pid still active with lock */
			close(fd_lockf);
			erc = pid;			/* port is busy */
			goto RESTORE_UMASK;
		}
		else
		{
			close(fd_lockf);
			erc = LOPEN_UNKPID;
			goto RESTORE_UMASK;
		}
	} 
	pid = getpid();
	write(fd_lockf,(char *)&pid,sizeof(pid));

	close(fd_lockf);
	chmod(lock_file_name,0666);

RESTORE_UMASK:
	(void)umask(old_umask);
	return(erc);

}	/* end of create_lock_file */

/*+-------------------------------------------------------------------------
	other_lock_name(first_lock_name)
--------------------------------------------------------------------------*/
char *
other_lock_name(first_lock_name)
char	*first_lock_name;
{
register int itmp;
static char other_lock_name[64];

	strcpy(other_lock_name,first_lock_name);
	itmp = strlen(other_lock_name) - 1;
	if(islower(other_lock_name[itmp]))
		other_lock_name[itmp] = toupper(other_lock_name[itmp]);
	else if(isupper(other_lock_name[itmp]))
		other_lock_name[itmp] = tolower(other_lock_name[itmp]);

	return(other_lock_name);
		
}	/* end of other_lock_name */

/*+-------------------------------------------------------------------------
	lock_tty()
--------------------------------------------------------------------------*/
lock_tty()
{
register int itmp;
struct stat ttystat;

	if(itmp = make_lock_name(Lline,LLCKname))
		return(itmp);

	if(stat(Lline,&ttystat) < 0)
		return(LOPEN_NODEV);

	if(itmp = create_lock_file(LLCKname))
		return(itmp);

	if(itmp = create_lock_file(other_lock_name(LLCKname)))
	{
		unlink(LLCKname);
		LLCKname[0] = 0;
		return(itmp);
	}

}	/* end of lock_tty */

/*+-----------------------------------------------------------------------
	void unlock_tty()
------------------------------------------------------------------------*/
void
unlock_tty()
{

	if(LLCKname[0] == 0)
		return;

	unlink(LLCKname);
	unlink(other_lock_name(LLCKname));

	LLCKname[0] = 0;
}	/* end of unlock_tty */

/*+-------------------------------------------------------------------------
	valid_baud_rate(baud) -- returns (positive) baud rate selector
or -1 if invalid baud rate
--------------------------------------------------------------------------*/
valid_baud_rate(baud)
uint	baud;
{
	switch(baud)
	{
		case 110: return(B110);
		case 300: return(B300);
		case 600: return(B600);
		case 1200: return(B1200);
		case 2400: return(B2400);
		case 4800: return(B4800);
		case 9600: return(B9600);
		case 19200: return(EXTA);
		case 38400: return(EXTB);
		default: return(-1);
	}

}	/* end of valid_baud_rate */

/*+-----------------------------------------------------------------------
	lset_baud_rate(ioctl_flag)

  If 'ioctl_flag' is set,then ioctl(Liofd,TCSETA,&Llv)
  is executed after setting baud rate
------------------------------------------------------------------------*/
lset_baud_rate(ioctl_flag)
int		ioctl_flag;
{
int		baud_selector = valid_baud_rate(Lbaud);

	if(baud_selector < 0)
	{
		ff(se,"invalid baud rate: %u\n",Lbaud);
		ff(se,"valid rates: 110,300,600,1200,2400,4800,9600,19200\n");
		return(1);
	}
	Llv.c_cflag &= ~CBAUD;
	Llv.c_cflag |= baud_selector;

	if(ioctl_flag)
		 ioctl(Liofd,(int)TCSETA,(char *)&Llv);
	return(1);

}	/* end of lset_baud_rate */

/*+-----------------------------------------------------------------------
	lset_parity(ioctl_flag)

  If 'ioctl_flag' is set,then ioctl(Liofd,TCSETA,&Llv)
  is executed after setting parity
------------------------------------------------------------------------*/
void
lset_parity(ioctl_flag)
int		ioctl_flag;
{
	Llv.c_cflag &= ~(CS8 | PARENB | PARODD);
	switch(to_lower(Lparity))
	{
		case 'e':
			Llv.c_cflag |= CS7 | PARENB;
			Llv.c_iflag |= ISTRIP;
			break;
		case 'o':
			Llv.c_cflag |= PARODD | CS7 | PARENB;
			Llv.c_iflag |= ISTRIP;
			break;
		default:
			ff(se,"invalid parity: %c ... defaulting to no parity\n");
		case 0:
		case 'n':
			Llv.c_cflag |= CS8;
			Llv.c_iflag &= ~(ISTRIP);
			Lparity = 0;
			break;
	}			

	if(ioctl_flag)
		 ioctl(Liofd,(int)TCSETA,(char *)&Llv);

}	/* end of lset_parity */

/*+-------------------------------------------------------------------------
	lgetc(char_rtnd)
--------------------------------------------------------------------------*/
void
lgetc(char_rtnd)
char	*char_rtnd;
{

READ_AGAIN:
	errno = 0;
	if(read(Liofd,char_rtnd,1) < 1)
	{
		if(errno == EINTR)			/* if signal interrupted, ... */
			goto READ_AGAIN;
		hangup(254);
	}

}	/* end of lgetc */

/*+-------------------------------------------------------------------------
	lrdchk() -- rdchk(Liofd)
--------------------------------------------------------------------------*/
int
lrdchk()
{
	return(rdchk(Liofd));

}	/* end of lrdchk */

/*+-----------------------------------------------------------------------
	lputc(lchar) -- write lchar to comm line
------------------------------------------------------------------------*/
void
lputc(lchar)
char	lchar;
{
	while(write(Liofd,&lchar,1) != 1)
	{
		if(errno == EINTR)
			continue;
		hangup(255);
	}
}	/* end of lputc */

/*+-----------------------------------------------------------------------
	lputs_paced(pace_msec,string) -- write string to comm line
  with time between each character 
------------------------------------------------------------------------*/
void
lputs_paced(pace_msec,string)
register int pace_msec;
register char	*string;
{
register long msec = (pace_msec) ? (long)pace_msec : (long)20;

	while(*string)
	{
		lputc(*string++);
		nap(msec);
	}

}	/* end of lputs_paced */

/*+-------------------------------------------------------------------------
	char *lgets_timeout(LRWT *)

typedef struct lrwt
{
ulong	to1;
ulong	to2;
int		raw_flag;
char	*buffer;
int		bufsize;
int		count;
}	LRWT;

to1 and to2 are unsigned long values in milliseconds (not
currently supported well under BSD4); to1 is the time to wait
for the first character, to2 the time to wait for subsequent
characters.

if raw_flag 0,     non-printables are stripped from beginning
                   and end of received characters (i.e., modem
                   response reads); NULs discarded, parity stripped
if raw_flag 1,     full raw read buffer returned
if raw_flag 2,     full buffer, NULs discarded, parity stripped

buffer is address to read chars into

bufsize is buffer max size (allowing room for terminating null)
which should be at least 2 if raw_size includes 0x80 bit,
else at least 12 characters if 0x80 omitted.

count is a int which, at return, receives the actual count read

--------------------------------------------------------------------------*/
char *
lgets_timeout(lrwt)
LRWT	*lrwt;
{
register int actual_count = 0;
register char	*cptr = lrwt->buffer;
int		max_count = lrwt->bufsize;
char	*rtn_val;
int		timeout_counter;
int		qc1;
int		qc2;
long	quantum;
long	ltmp;

/* minimum wait is 60 msec */
	if(Lbaud < 300)
		if(lrwt->to2 < 300L) lrwt->to2 = 300L;
	if(Lbaud < 1200)
		if(lrwt->to2 < 200L) lrwt->to2 = 200L;
	else
		if(lrwt->to2 < 60L) lrwt->to2 = 60L;

/* shortest interval */
	ltmp = (lrwt->to1 < lrwt->to2) ? lrwt->to1 : lrwt->to2;

/* calculate wait quantum */
	quantum = ltmp / 10L;				/* try for ten ticks */
	if(quantum < 20L)
		quantum = 20L;
	qc1 = lrwt->to1 / quantum;
	if(!qc1) qc1 = 1L;
	qc2 = lrwt->to2 / quantum;
	if(!qc2) qc2 = 1L;

/* perform the lrtw function
   input: qc1 is first nap count (for first charcters) 
          qc2 is 2nd nap count (for subsequent characters) 
          quantum is the nap period in milliseconds
          cptr is char* to receive read string
          max_count is max number of characters incl null
          lrwt->raw_flag as described above

  output: lrwt->count is actual count of return result
          lrwt->buffer is return read buffer
*/
	max_count--;				/* leave room for null */

	lrwt->raw_flag &= 0x0F;		/* get rid of 0xF0 flags */
	timeout_counter = qc1;		/* first timeout */ 
	*cptr = 0;					/* init result string */
	while(timeout_counter--)
	{
		nap(quantum);
		while(lrdchk())
		{
			lgetc(cptr);
			if(lrwt->raw_flag != 1)
			{
				*cptr &= 0x7F;
				if(*cptr == 0)
					continue;
			}

			*++cptr = 0;
			actual_count++;
			if(--max_count == 0)
				goto READ_LINE_POST_PROCESS;
			timeout_counter = qc2;
		}
	}

READ_LINE_POST_PROCESS:
	if(lrwt->raw_flag)
	{
		lrwt->count = actual_count;
		return(lrwt->buffer);
	}
	cptr = lrwt->buffer;
	while(((*cptr >0) && (*cptr < 0x20)) || (*cptr >= 0x7F))
		cptr++;
	rtn_val = cptr;
	actual_count = 0;
	while(((*cptr &= 0x7F) >= 0x20) && (*cptr <= 0x7E))
	{
		cptr++;
		actual_count++;
	}
	*cptr = 0;
	strcpy(lrwt->buffer,rtn_val);
	lrwt->count = actual_count;
	return(lrwt->buffer);
}	/* end of lgets_timeout */

/*+-------------------------------------------------------------------------
	lgetc_timeout(timeout_msec)

 reads one character from line unless timeout_msec passes with no receipt.
 timeout_msec < 20 msec becomes 20 msec
 return char (raw - parity bit preserved) if received, else -1 if timeout
--------------------------------------------------------------------------*/
int
lgetc_timeout(timeout_msec)
ulong	timeout_msec;
{
LRWT	lr;
char	getc_buf[2];		/* room for one char + null */

	lr.to1 = timeout_msec;
	lr.to2 = timeout_msec;
	lr.raw_flag = 1;		/* full raw read */
	lr.buffer = getc_buf;
	lr.bufsize = sizeof(getc_buf);
	lgets_timeout(&lr);
	return(  (lr.count == 1) ? (int)getc_buf[0] : -1 );

}	/* end of lgetc_timeout */

/*+-------------------------------------------------------------------------
	lkill_buf()
--------------------------------------------------------------------------*/
void
lkill_buf()
{
	ioctl(Liofd,(int)TCFLSH,(char *)2); /* flush input and output */
}	/* end of lkill_buf */

/*+----------------------------------------------------------------------
	lopen()
returns negative LOPEN_ codes if failure else positive pid using line
else 0 if successful open
------------------------------------------------------------------------*/
int
lopen()
{
register int	itmp;

	if(Liofd >= 0)
		return(LOPEN_ALREADY);
	if(itmp = lock_tty())		/* get lock file */
		return(itmp);
	Liofd = open(Lline,O_RDWR,0777);
	if(Liofd < 0)
		return(LOPEN_OPNFAIL);
	else
	{
		ioctl(Liofd,(int)TCGETA,(char *)&Llv);
		Llv.c_iflag = (IGNPAR | IGNBRK | IXOFF );
		Llv.c_cflag |= (CREAD | HUPCL);
		Llv.c_lflag = 0;

		Llv.c_cc[VMIN]   = 1;
		Llv.c_cc[VTIME]  = 1;

		lset_baud_rate(0);		/* do not perform ioctl */
		lset_parity(1);			/* do perform ioctl */
	}

	return(0);

}	/* end of lopen */

/*+-----------------------------------------------------------------------
	lclose()
------------------------------------------------------------------------*/
void
lclose()
{
	if(Liofd < 0)
		return;
	ioctl(Liofd,(int)TCGETA,(char *)&Llv); /* save initial state */
	Llv.c_cflag |= HUPCL;
	ioctl(Liofd,(int)TCSETA,(char *)&Llv);
	close(Liofd);
	Liofd = -1;
	unlock_tty();		/* kill lock file */

}	/* end of lclose */

/*+-------------------------------------------------------------------------
	hayes_send_cmd(cmd)
  0: success (cmd accepted)
 -1: cannot talk to modem
--------------------------------------------------------------------------*/
hayes_send_cmd(cmd)
char	*cmd;
{
register char	*cptr;
int retry = 0;

	cptr = cmd;
	lkill_buf();
	while(1)
	{
		lputc(0x07);	/* something random */
		if(lgetc_timeout(500L) < 0)
		{
			if(retry)
				return(-1);
			retry = 1;
			lputs_paced(0,"ATQ0E1V1\r");
			nap((long)1500);
			lkill_buf();
			continue;
		}
		break;
	}
	while(*cptr)
	{
		lputc(*cptr++);
		if(lgetc_timeout(500L) < 0)
			return(-1);
	}
	lputc('\r');
	if(lgetc_timeout(500L) < 0)
		return(-1);
	return(0);

}	/* end of hayes_send_cmd */

/*+-----------------------------------------------------------------------
	hayes_dial()
returns 1 on success (CONNECT), 
		0 if failure to connect
		-1 if cannot talk to modem
------------------------------------------------------------------------*/
int
hayes_dial()
{
register int itmp;
char	s128[128];
int		rtn_code = -1;	/* assume fail, CONNECT will chg to zero */
int		s7;
LRWT	lr;

	s7 = 30;
	strcpy(s128,"ATV1E1S11=45DT" );
	strcat(s128,Ltelno);

	if(itmp = hayes_send_cmd(s128))
		return(itmp);

/* some modems (ahem, the Hayes 2400) do not accurately honor S7 */
	lr.to1 = s7 * 3 * 1000L;
	lr.to2 = 100L;
	lr.raw_flag = 0;
	lr.buffer = s128;
	lr.bufsize = sizeof(s128);
	ff(se,"Dialing %s ... INT to abort ... ",Ltelno);
	fflush(se);
	lgets_timeout(&lr);
	if(lr.count)
		ff(se,"%s\n",s128);
	if(strncmp(s128,"CONNECT",7) == 0)
		return(1);
	return(0);

}	/* end of hayes_dial */

/*+-------------------------------------------------------------------------
	main(argc,argv,envp)

  main() program forks to create rcvr process; then main()
  becomes the xmtr process
------------------------------------------------------------------------*/
main(argc,argv,envp)
int		argc;
char	**argv;
char	**envp;
{
char	*cptr;
int		iargv;
int		swchar;
int		itmp;
LRWT	lr;
char	rd_buf[64];
long	now;
long	julian;
long	time_at_connect;
int		day_of_year;
int		year;
int		month;
int		day;
int		hour;
int		min;
int		sec;
int		fdcmos;
int		have_time = 0;
int		max_tries;
struct tm *lt;

	setbuf(stderr,NULL);
	setbuf(stdout,NULL);

/* init line variables */
	strcpy(Lline,"/dev/tty1a");
	strcpy(Ltelno,"1(202)653-0351");
	Liofd = -1;
	Lbaud = 1200;
	Lparity = 0;

	if(argc < 2)
		usage();

	if((argc == 2) && (!strcmp(argv[1],"-")))
		;
	else
	{
		for(iargv = 1; iargv < argc; iargv++)
		{
			if(*argv[iargv] != '-')
				continue;
			switch(*(argv[iargv] + 1))
			{
				case 'e': Lparity = 'e'; break;
				case 'o': Lparity = 'o'; break;
				case 'n': Lparity =  0 ; break;
				case 'b': Lbaud = atoi(argv[iargv] + 2); break;
				case 't': strcpy(Ltelno,argv[iargv] + 2); break;
				case 'l': strcpy(Lline,argv[iargv] + 2); break;
				default:  usage();
			}
		}
	}

	uid = getuid();
	euid = geteuid();
	if((euid == 0) || (uid == 0))	/* if root running or prog text ... */
		nice(-40);
	else
	{
		ff(se,"must be root\n");
		exit(252);
	}

	if((fdcmos = open(cmos,O_RDWR,0)) < 0)
	{
		perror(cmos);
		exit(251);
	}

	signal(SIGHUP,hangup);
	signal(SIGQUIT,hangup);
	signal(SIGINT,hangup);
	signal(SIGTERM,hangup);

	if(itmp = lopen())
	{
		switch(itmp)
		{
			case LOPEN_INVALID:
				ff(se,"invalid line name\n"); break;
			case LOPEN_UNKPID:
				ff(se,"unknown pid is using line\n"); break;
			case LOPEN_LCKERR:
				ff(se,"lock file error\n"); break;
			case LOPEN_NODEV:
				ff(se,"line does not exist\n"); break;
			case LOPEN_ALREADY:
				ff(se,"line already open\n"); break;
			case LOPEN_OPNFAIL:
				ff(se,"line open error\n"); break;
			default:
				ff(se,"pid %d using line\n",itmp); break;
		}
		exit(250);
	}

	lr.to1 = 1100L;
	lr.to2 =  100L;
	lr.raw_flag = 0;	/* full raw read */
	lr.buffer = rd_buf;
	lr.bufsize = sizeof(rd_buf);

/* spend money on long distance call ... only time freaks can understand */
	if(!hayes_dial())
		hangup(255);
	time_at_connect = time((long *)0);

	max_tries = 40;		/* 40 sec max connect time (charged for 1 min anyway) */
	while(!have_time)
	{
		for(itmp = 0; itmp < 30; itmp++)		/* look for asterisk */
		{
			if(lgetc_timeout(500L) == TONE)
				break;
		}

		lgets_timeout(&lr);		/* get date/time string */

		if(sscanf(lr.buffer,TIME,&julian,&day_of_year,&hour,&min,&sec) != 5)
		{
			ff(se,"garbled result: '%s'  ",lr.buffer);
			if(--max_tries)
			{
				puts("... retrying");
				continue;
			}
			puts("... aborting");
			break;		/* too many retries ... BAAAAD line condx */
		}
		have_time = 1;
	}

	lclose();

/* no longer spending money */

	fprintf(stdout,"Connect time %ld second(s)\n",
		time((long *)0) - time_at_connect);

	if(have_time)
	{
		now = (((julian - EPOCH) * 24 + hour) * 60 + min) * 60 + sec;
		if(stime(&now) < 0)
		{
			perror("stime");
			exit(249);
		}
		fputs("Time retrieved from standard: ",stdout);
		fputs(ctime(&now), stdout);
		time(&now);
		lt = localtime(&now);
		fputs("setting cmos clock ... ",stdout);
		set_clock(fdcmos,lt->tm_year,lt->tm_mon,lt->tm_mday,
				lt->tm_hour,lt->tm_min,lt->tm_sec);
		fputs("result: ",stdout);
		get_clock(fdcmos,&year,&month,&day,&hour,&min,&sec);
		printf("%02d/%02d/%04d %02d:%02d:%02d\n",month,day,year,hour,min,sec);
		exit(0);
	}
	else
	{
		puts("Did not get time ... sorry");
		exit(254);
	}

}	/* end of main */

/* end of nbs_time.c */

\Rogue\Monster\
else
  echo "will not over write ./NBSsetclk.c"
fi
if `test ! -s ./README`
then
echo "writing ./README"
cat > ./README << '\Rogue\Monster\'
Abstract
--------------------------------------------------------------------
XENIX V supports the 286 cmos ram with two devices (/dev/cmos,
/dev/clock), programs /etc/setclock and /lib/cvtdate and a shell
script /etc/asktime.

However, there is no way to set the system time or the cmos clock
ACCURATELY using these tools since seconds are not part of the
paradigm of setclock or /dev/clock.  One can, however, set the cmos
clock accurately by the direct manipulation of /dev/cmos.  Then again,
by reading /dev/cmos, one can get the correct time and set the
system time with stime(S).

Overview of cmostime.tar.Z
--------------------------------------------------------------------
This collection of programs allow you to:

1) set the cmos clock and system time very accurately by calling
   the Naval Observatory ((202)653-0351 in DC) using 'NBSsetclk'

2) set the system clock from the (somwhat drifty) cmos clock
   by using 'CMOSstime'

3) display interesting things in the cmos ram by using 'cmos_disp'

The file is compressed to 12-bits (using compress16 thanks to
Sandy Zelkovitz's BBS at 1(714)898-8634).  When tar is run on
the uncompressed file, a group of files consisting of the sources,
executables and Makefile is produced.

List of files:
CMOSstime CMOSstime.c Makefile NBSsetclk NBSsetclk.c README
at_cmos.h cmos_disp cmos_disp.c dev_cmos.c dev_cmos.h NBSsetclk

--------------------------------------------------------------------
'NBSsetclk' MUST be run by root.  Why waste a long distance call
only to have stime() fail?  Most user will use the default parameters
of this program by invoking it with 'NBSsetclk -'.  Running the
program with no parameters gives you the options available.
NBSsetclk assumes a Hayes modem is connected to the line and
that command recognition is enabled.  /dev/tty1a is used by default.
The program tries up to 40 times (40 seconds) to read the time,
making it likely that you will succeed.  However, the program will
terminate before the minimum 1 minute connect charge has expired.

Exit status codes for the NBSsetclk:
1-n  signal values if program killed
200  illogical cmos device behavior (when reading clock)
249  stime() call failed
250  could not open communications line
251  /dev/cmos read&write access denied
252  user is not root
253  usage
254  couldn't get time from line (after 40 retries! BAD line conditions)
255  couldn't establish a connection

CMOSstime
--------------------------------------------------------------------
'CMOSstime' must be run by root.  Run it in your /etc/rc in place
of the rather klunky 'asktime'.  It reads the cmos clock and sets
the system time to the second.  The program returns exit status 0
if it succeeds, 1 for most failures (stime() failure or /dev/cmos
read access failure), or 200 for the rare cases where the cmos
device appears to be acting up.

cmos_disp
--------------------------------------------------------------------
This is an experimental program that displays information contained
in the cmos ram.  It has some bugs in it (on my system, it reports
no floppy drives, when I in fact have one).  The information used
to build the program came from the sketchy notes in the IBM AT
Technical Reference Manual.  Look in header file 'at_cmos.h' and
source file 'cmos_disp.c' for notes I have made about empirical
"discoveries".

Acknowlegments
--------------------------------------------------------------------
The routines for converting mm/dd/yy hh:mm:ss to seconds since
the epoch were adapted from the 'tm_to_time.c' module in Emmet P.
Gray's conversion of arc to unix.

The concepts of parsing the Naval Observatory data stream came from
an anonymous author's nbs.c (which read the data stream from stdin).

The hayes modem handler came from my homebrew comm program I've
been hacking on the last couple of years.

And I'd like to say hello to Mom and everybody that's watching.
Enjoy.

NOT COPYRIGHTED BY or clutched to the chest of:
Warren H. Tucker
150 West Lake Drive
Mountain Park, GA.  30075
(404)587-5766

\Rogue\Monster\
else
  echo "will not over write ./README"
fi
if `test ! -s ./at_cmos.h`
then
echo "writing ./at_cmos.h"
cat > ./at_cmos.h << '\Rogue\Monster\'
/* CHK=0x7AFA */
/*+-------------------------------------------------------------------------
	at_cmos.h -- 286 cmos ram definitions

  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA 30075
  (404)587-5766

--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-19:06-wht-release */
/*:07-23-1988-15:12-wht-break out from cmos_disp.c */

#ifndef uchar
#define uchar	unsigned char
#endif

typedef struct at_cmos
{
	uchar	sec;
	uchar	sec_alarm;
	uchar	min;
	uchar	min_alarm;
	uchar	hour;
	uchar	hour_alarm;
	uchar	day;			/* 0-6 */
	uchar	date;			/* 1-31 */
	uchar	month;
	uchar	year;
	uchar	srA;			/* status register A */
	uchar	srB;			/* status register B */
	uchar	srC;			/* status register C */
	uchar	srD;			/* status register D */

	uchar	dsb;			/* diagnostic status byte */
	uchar	ssb;			/* shutdown status byte */
	uchar	ddtb;			/* diskette drive type byte */
	uchar	rsvd11;			/* byte at address 0x11 reserved */
	uchar	fdtb;			/* fixed disk type byte */
	uchar	rsvd13;			/* byte at address 0x13 reserved */
	uchar	equip;			/* equipment byte */

/* base size of memory = (contents(byte 0x16) << 8) + contents(byte 0x15) */
	uchar	base_low;		/* low base memory byte */
	uchar	base_high;		/* hi base memory byte */
	
/* memory expansion size similar calculation (0x17 low order byte, 0x18 hi) */
	uchar	expand_low;
	uchar	expand_high;

/* reserved bytes */
	uchar	rsvd19_2D[ 0x2D - 0x19 + 1 ];

/* checksum (on bytes in addresses 0x10 - 0x20) */
	uchar	cksum_high;		/* tech ref sez these bytes in other order */
	uchar	cksum_low;

/* > 1 mb expansion size (in cmos ram addresses 0x30-31) */
	uchar	exp2_low;
	uchar	exp2_high;

	uchar	century;		/* date century byte */
	uchar	info_flag;		/* see IF_ bits below */

	uchar	rsvd34_3F[ 0x3F - 0x34 + 1];

} AT_CMOS;

union cmos_union
{
	uchar		a[64];
	AT_CMOS		s;
};

/*+-----------------------------------------------------------------------
	AT Real Time Clock Status Register bit assignments
------------------------------------------------------------------------*/
#define SRA_UIP		0x80	/* update in progress */
#define SRA_DV22	0x70	/* 3-bit time-base divider */
#define SRA_DVOUT	0x0F	/* 4-bit time-base divider output freq */

#define SRB_SET		0x80	/* when 1, no tick advance (set mode) */
#define SRB_PIE		0x40	/* when 1, periodic interrupt */
#define SRB_AIE		0x20	/* when 1, alarm enabled */
#define SRB_UIE		0x10	/* enabled update-ended interrupt */
#define SRB_SQWE	0x08	/* square wave enabled */
#define SRB_DM		0x04	/* data mode 1==binary, 0==BCD */
#define SRB_24HR	0x02	/* 1==24 hour mode, 0==12 hour mode */
#define SRB_DSE		0x01	/* daylight savings time enabled */

#define SRC_IRQF	0x80
#define SRC_PF		0x40
#define SRC_AF		0x20
#define SRC_UF		0x10
							/* remaining bits in status register C reserved */

#define SRD_VRB		0x80	/* valid ram (==0 when power has been lost)
							 * remaining bits in status register D reserved */


/*+-----------------------------------------------------------------------
	Diagnostic Status Byte
------------------------------------------------------------------------*/
#define DSB_RTLOST	0x80	/* ==1 if real time clock chip lost power */
#define DSB_CSI		0x40	/* checksum status indicator == 1 if bad */
#define DSB_ICI		0x20	/* invalid configuration information (if ==1) */
#define DSB_MSM		0x10	/* memory size miscompare (==1 if different) */
#define DSB_HDBAD	0x08	/* fixed disk bad if == 1 */
#define DSB_TSI		0x04	/* time status indicator (==1 if time bad) */

#ifdef NEEDED	/* not under XENIX! */
#define		cmos_ctrl_dev		0x70		/* cmos address control port */
#define		cmos_data_dev		0x71		/* cmos data i/o port */
#endif

\Rogue\Monster\
else
  echo "will not over write ./at_cmos.h"
fi
if `test ! -s ./cmos_disp.c`
then
echo "writing ./cmos_disp.c"
cat > ./cmos_disp.c << '\Rogue\Monster\'
/* CHK=0xD818 */
/*+-------------------------------------------------------------------------
	cmos_disp.c -- interprets /dev/cmos 286 CMOS ram

  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA 30075
  (404)587-5766
--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-19:05-wht-release */
/*:07-23-1988-14:17-wht-BIG face life on old program */

#include <stdio.h>
#include <fcntl.h>
#include "at_cmos.h"
#include "dev_cmos.h"

union cmos_union	cmos;

char	*day_of_week[] =
{
	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
};

char	*cmosname = "/dev/cmos";

main(argc,argv)
int		argc;
char	**argv;
{
register int icmos;
register int itmp;
char	*format;
int		fdcmos;
int		clock_bcd_mode;			/* true if clock in bcd mode */
unsigned short calc_cksum;		/* calculated checksum */
unsigned short cmos_cksum;		/* checksum in cmos */

	if((fdcmos = open(cmosname,O_RDONLY)) < 0)
	{
		perror(cmosname);
		exit(1);
	}
	get_cmos(fdcmos,&cmos);
	close(fdcmos);

	for(icmos = 0; icmos < 64; icmos++)
	{
		if(icmos % 16 == 0)
			printf("\n %02x:  ",icmos);
		printf("%02x ",cmos.a[icmos]);
		if(icmos % 4 == 3)
			printf(" ");
	}
	printf("\n\n");

	clock_bcd_mode = (cmos.s.srB & SRB_DM) ? 0 : 1;

	printf("Base memory:       %6dk  (%8lx bytes hex)\n",
					itmp = cmos.s.base_high << 8 | cmos.s.base_low,
					(long)itmp * (long)1024);

	printf("Expansion memory:  %6dk  (%8lx bytes hex)\n",
					itmp = cmos.s.expand_high << 8 | cmos.s.expand_low,
					(long)itmp * (long)1024);

	printf("Memory above 1MB:  %6dk  (%8lx bytes hex)\n",
					itmp = cmos.s.exp2_high << 8 | cmos.s.exp2_low,
					(long)itmp * (long)1024);

	printf("\n");

	printf("Diag status byte: %02x  Shutdown status byte: %02x\n",
					cmos.s.dsb,cmos.s.ssb);

	if(cmos.s.dsb)
	{
		itmp = cmos.s.dsb;
		printf("  Diagnostic Status Byte (DSB) says:\n");
		if(itmp & 0x80)
			printf("      Real-time clock has lost power.\n");
		if(itmp & 0x40)
			printf("      Bad configuration record checksum.\n");
		if(itmp & 0x20)
			printf("      Incorrect configuration information.\n");
		if(itmp & 0x10)
			printf("      Memory size miscompare.\n");
		if(itmp & 0x08)
			printf("      Fixed disk adapter failed init.\n");
		if(itmp & 0x04)
			printf("      Time is invalid.\n");
		printf("\n");
	}

	printf("Clock: %d-hour mode, %s time, alarm %s, %s mode\n",
					(cmos.s.srB & SRB_24HR) ? 24 : 12,
					(cmos.s.srB & SRB_DSE) ? "daylight" : "standard",
					(cmos.s.srB & SRB_AIE) ? "enabled" : "disabled",
					(clock_bcd_mode) ? "bcd" : "hex");

	if(clock_bcd_mode)
		format = "Date: %02x-%02x-%02x%02x  ";
	else
		format = "Date: %02d-%02d-%02d%02d  ";
	printf(format,cmos.s.month,cmos.s.date,cmos.s.century,cmos.s.year);

	if(clock_bcd_mode)
		format = "Time: %02x:%02x:%02x  Alarm: %02x:%02x:%02x\n";
	else
		format = "Time: %02d:%02d:%02d  Alarm: %02d:%02d:%02d\n";
	printf(format,cmos.s.hour,cmos.s.min,cmos.s.sec,
		cmos.s.hour_alarm,cmos.s.min_alarm,cmos.s.sec_alarm);

	printf("Number of diskette drives: %d   Math coprocessor %s\n",
					(int)(cmos.s.equip & 0xC0) >> 6,
					(cmos.s.equip & 0x02) ? "present" : "not present"
					);

	printf("Primary display:  ");
	switch( itmp = (cmos.s.equip & 0x30) >> 4)
	{
		case 1:
			format = "Color/Graphics 40 column\n";
			break;
		case 2:
			format = "Color/Graphics 80 column\n";
			break;
		case 3:
			format = "Monochrome display\n";
			break;
		default:
			format = "unknown type: %d\n";
			break;
	}
	printf(format,itmp);

/* tech ref doesn't say: empirically determined checksum algorithm (correct?) */
	calc_cksum = 0;
	for(itmp = 0x10; itmp < 0x21; itmp++)
		calc_cksum += cmos.a[itmp];
	calc_cksum++;

	cmos_cksum = (cmos.s.cksum_high << 8) | cmos.s.cksum_low;
	printf("Checksum: in ram: %04x  calculated: %04x\n",cmos_cksum,calc_cksum);

	exit(0);	/* for now */
	
}	/* end of main() */

\Rogue\Monster\
else
  echo "will not over write ./cmos_disp.c"
fi
if `test ! -s ./dev_cmos.c`
then
echo "writing ./dev_cmos.c"
cat > ./dev_cmos.c << '\Rogue\Monster\'
/* CHK=0x2A78 */
/*+-------------------------------------------------------------------------
	dev_cmos.c -- XENIX /dev/cmos routines

  Defined functions:
	bcdch_to_uchar(bcdch)
	get_clock(fdcmos,year,month,day,hour,min,sec)
	get_cmos(fdcmos,cmosbuf)
	set_clock(fdcmos,year,month,day,hour,min,sec)
	uchar_to_bcdch(uch)

  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA 30075
  (404)587-5766

--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-19:06-wht-release */
/*:07-23-1988-13:53-wht-creation */

#include "at_cmos.h"
#include "dev_cmos.h"

long seek(int,long,int);
int read(int,char *,int);

union cmos_union cu;

#define SEEKPOS(elem)	((long)((char *)&cu.s.elem - (char *)&cu))

/*+-------------------------------------------------------------------------
	bcdch_to_uchar(bcdch) -- convert two-nibble bcd to binary
--------------------------------------------------------------------------*/
unsigned char
bcdch_to_uchar(bcdch)
unsigned char bcdch;
{
	return((((bcdch & 0xF0) >> 4) * 10) + (bcdch & 0x0F));
}	/* end of bcdch_to_uchar */

/*+-------------------------------------------------------------------------
	uchar_to_bcdch(uch) -- convert binary to two-nibble bcd
--------------------------------------------------------------------------*/
unsigned char
uchar_to_bcdch(uch)
unsigned char uch;
{
	return(((uch / 10) << 4) | (uch % 10));
}	/* end of uchar_to_bcdch */

/*+-------------------------------------------------------------------------
	get_cmos(fdcmos,cmosbuf)
--------------------------------------------------------------------------*/
void
get_cmos(fdcmos,cmosbuf)
int		fdcmos;
union cmos_union *cmosbuf;
{
unsigned int wait_counter;
unsigned char stat_reg_A;

/* check for clock update in progress and wait til done */
	wait_counter = 32768;
	while(1)
	{
		if(--wait_counter == 0)
		{
			puts("/dev/cmos: clock update in progress for too long");
			exit(200);
		}
		
		lseek(fdcmos,SEEKPOS(srA),0);		/* position to status register A */
		read(fdcmos,&stat_reg_A,1);
		if(!(stat_reg_A & SRA_UIP))			/* check update bit */
			break;							/* and break out of loop if not */
	}

/* read the cmos ram */
	lseek(fdcmos,0L,0);
	read(fdcmos,(char *)cmosbuf,sizeof(AT_CMOS));

}	/* end of get_cmos */

/*+-------------------------------------------------------------------------
	get_clock(fdcmos,year,month,day,hour,min,sec) -- read /dev/cmos clock

fdcmos open fd to /dev/cmos
return values:
year is full year (e.g., 1988)
month is 0-11
day is 0-30
hour is 0-23
min is 0-59
--------------------------------------------------------------------------*/
void
get_clock(fdcmos,year,month,day,hour,min,sec)
int		fdcmos;
int		*year;
int		*month;
int		*day;
int		*hour;
int		*min;
int		*sec;
{
char	clkstr[12];

	get_cmos(fdcmos,&cu);

	*year  = (int)bcdch_to_uchar(cu.s.year) + 1900;
	*month = (int)bcdch_to_uchar(cu.s.month) - 1;
	*day   = (int)bcdch_to_uchar(cu.s.date) - 1;
	*hour  = (int)bcdch_to_uchar(cu.s.hour);
	*min   = (int)bcdch_to_uchar(cu.s.min);
	*sec   = (int)bcdch_to_uchar(cu.s.sec);

}	/* end of get_clock */

/*+-------------------------------------------------------------------------
	set_clock(fdcmos,year,month,day,hour,min,sec) -- write /dev/cmos clock
fdcmos open fd to /dev/cmos
other values: as returned by localtime()
--------------------------------------------------------------------------*/
void
set_clock(fdcmos,year,month,day,hour,min,sec)
int		fdcmos;
int		year;
int		month;
int		day;
int		hour;
int		min;
{
unsigned char stat_reg_B;
unsigned char wchar;

	month++;			/* month to 1-n */
	year %= 100;		/* think ahead (ha) */

/* set no tick advance */
	lseek(fdcmos,SEEKPOS(srB),0);
	read(fdcmos,&stat_reg_B,1);		/* get current value */
	stat_reg_B |= SRB_SET;
	lseek(fdcmos,SEEKPOS(srB),0);
	write(fdcmos,&stat_reg_B,1);	/* plug new value */

/* set clock */
	wchar = uchar_to_bcdch((uchar)year);
	lseek(fdcmos,SEEKPOS(year),0);
	write(fdcmos,&wchar,1);

	wchar = uchar_to_bcdch((uchar)month);
	lseek(fdcmos,SEEKPOS(month),0);
	write(fdcmos,&wchar,1);

	wchar = uchar_to_bcdch((uchar)day);
	lseek(fdcmos,SEEKPOS(date),0);
	write(fdcmos,&wchar,1);

	wchar = uchar_to_bcdch((uchar)hour);
	lseek(fdcmos,SEEKPOS(hour),0);
	write(fdcmos,&wchar,1);

	wchar = uchar_to_bcdch((uchar)min);
	lseek(fdcmos,SEEKPOS(min),0);
	write(fdcmos,&wchar,1);

	wchar = uchar_to_bcdch((uchar)sec);
	lseek(fdcmos,SEEKPOS(sec),0);
	write(fdcmos,&wchar,1);
	
/* set no tick advance */
	lseek(fdcmos,SEEKPOS(srB),0);
	stat_reg_B &= ~SRB_SET;
	write(fdcmos,&stat_reg_B,1);	/* plug new value */

}	/* end of set_clock */

\Rogue\Monster\
else
  echo "will not over write ./dev_cmos.c"
fi
if `test ! -s ./dev_cmos.h`
then
echo "writing ./dev_cmos.h"
cat > ./dev_cmos.h << '\Rogue\Monster\'
/* CHK=0x843A */
/*+-------------------------------------------------------------------------
	dev_clock.h -- prototypes for dev_clock.c functions

  Warren H. Tucker, 150 West Lake Drive, Mountain Park, GA 30075
  (404)587-5766

--------------------------------------------------------------------------*/
/*+:EDITS:*/
/*:07-23-1988-19:07-wht-release */
/*:07-23-1988-13:55-wht-creattion */

unsigned char bcdch_to_uchar(unsigned char );
unsigned char uchar_to_bcdch(unsigned char );
void get_cmos(int ,union cmos_union  *);
void get_clock(int ,int  *,int  *,int  *,int  *,int  *,int  *);
void set_clock(int ,int ,int ,int ,int ,int ,int );
\Rogue\Monster\
else
  echo "will not over write ./dev_cmos.h"
fi
if `test ! -s ./tags`
then
echo "writing ./tags"
cat > ./tags << '\Rogue\Monster\'
bcdch_to_uchar dev_cmos.c ?^bcdch_to_uchar(bcdch)$?
create_lock_file NBSsetclk.c ?^create_lock_file(lock_file_name)$?
date_to_epochsecs CMOSstime.c ?^date_to_epochsecs(year,month,day,hour,min,sec)$?
days_since_epoch CMOSstime.c ?^days_since_epoch(year,month,day)$?
get_clock dev_cmos.c ?^get_clock(fdcmos,year,month,day,hour,min,sec)$?
get_cmos dev_cmos.c ?^get_cmos(fdcmos,cmosbuf)$?
hangup NBSsetclk.c ?^hangup(sig)$?
hayes_dial NBSsetclk.c ?^hayes_dial()$?
hayes_send_cmd NBSsetclk.c ?^hayes_send_cmd(cmd)$?
lclose NBSsetclk.c ?^lclose()$?
leap_year CMOSstime.c ?^leap_year(yr)$?
lgetc NBSsetclk.c ?^lgetc(char_rtnd)$?
lgetc_timeout NBSsetclk.c ?^lgetc_timeout(timeout_msec)$?
lgets_timeout NBSsetclk.c ?^lgets_timeout(lrwt)$?
lkill_buf NBSsetclk.c ?^lkill_buf()$?
lock_tty NBSsetclk.c ?^lock_tty()$?
lopen NBSsetclk.c ?^lopen()$?
lputc NBSsetclk.c ?^lputc(lchar)$?
lputs_paced NBSsetclk.c ?^lputs_paced(pace_msec,string)$?
lrdchk NBSsetclk.c ?^lrdchk()$?
lset_baud_rate NBSsetclk.c ?^lset_baud_rate(ioctl_flag)$?
lset_parity NBSsetclk.c ?^lset_parity(ioctl_flag)$?
main CMOSstime.c ?^main(argc,argv,envp)$?
main NBSsetclk.c ?^main(argc,argv,envp)$?
main cmos_disp.c ?^main(argc,argv)$?
make_lock_name NBSsetclk.c ?^make_lock_name(ttyname,lock_file_name)$?
other_lock_name NBSsetclk.c ?^other_lock_name(first_lock_name)$?
set_clock dev_cmos.c ?^set_clock(fdcmos,year,month,day,hour,min,sec)$?
to_lower NBSsetclk.c ?^char to_lower(ch)$?
to_upper NBSsetclk.c ?^char to_upper(ch)$?
uchar_to_bcdch dev_cmos.c ?^uchar_to_bcdch(uch)$?
ulcmpb NBSsetclk.c ?^ulcmpb(str1,str2)$?
ulindex NBSsetclk.c ?^int ulindex(str1,str2)$?
unlock_tty NBSsetclk.c ?^unlock_tty()$?
usage NBSsetclk.c ?^usage()$?
valid_baud_rate NBSsetclk.c ?^valid_baud_rate(baud)$?
\Rogue\Monster\
else
  echo "will not over write ./tags"
fi
echo "Finished archive 1 of 1"
exit



More information about the Comp.unix.questions mailing list