OU:BYE.MAC;2=IN:[12,10]BYE.VGN;1/AU:80.
\
-2,2
	.IDENT	/4.2XA/
-/SA338/+2,,
;
;	JGD01 		 INSERT TOTAL LOGONTIME INTO ACCOUNT FILE
;			 PREVENT PRIVLEDGED USER FROM LOGGING OFF
;			 IF LOGONS DISSABLED.  DON'T LOG OFF USER
;		 	 IF ACCOUNT FILE BUSY.
;
;	JGD04		 PASS A REQUEST TO MCR TO UPDATE THE ACCOUNT
;			 FILE WITH THE NUMBER OF FILES AND DISK BLOCKS
;			 USED BY THE USER.  THECOMMAND IS PASSED TO  ...UPD
;			 WHICH MUST BE INSTALLED.  DOCUMENTATION ON
;			 ...UPD IS CONTAINED IN THE FILE ACCBLK.MAC
;
;	JGD05		 IF BIT 4 IN U.PRV1 IS SET, TO NOT ABORT NON
;			 PRIVLEGED TASKS.
;
;	JGD06		 CHANGE ALL REFERENCES TO U.CW3 TO U.PRV1=U.LUIC-2
;
;	JGD07		MODIFICATIONS TO ALLOW ...SUB, BAT...(PSEUDO BATCH
;			USING A VIRTUAL TERMINAL) TO WORK.
;			1) IF CAN'T FIND LOGIN FLAG OR ACCOUNT FILE ERROR
;			   DON'T PASS MESSAGE TO UPDATE DISK BLOCK USAGE
;			 SO THAT THE ACCOUNTING PACKAGE MAY BE USED ON
;			 SYSTEMS WITH MULTIPLEXERS.
;
;	JGD13		MODIFICATIONS TO ALLOW FOR FULL SYSTEM PERFORMANCE
;			ACCOUNTING ON RSX11M V3.2.  IN ADDITION TO ALL ELSE
;			IT DOES, BYE WILL NOW ALSO DO:
;			1) UPDATE ACCOUNT FILE WITH THE TOTAL CPU TIME USED
;			2) ZERO THE VT: FLAG IN THE ACCOUNT FILE
;			3) SEND OFF A PACKET TO THE LOGGING TASK LOG...
;			   IF HELLO/BYE LOGGING IS SPECIFIED IN THE SYSTEM
;			   ACCOUNTING MASK WORD $ACMSK.  THE FORMAT OF THE
;			   DATA PACKET TO LOG... IS
;			   6,HOUR,MIN,SEC,TERM IDENT, ACNT #,CPTIM1,ATCNT,
;			   QICNT1,QICNT2,RNCNT,INSCNT
;			   WHERE:
;				CPTIM1       	- CPU TIME IN SECONDS 
;				QICNT1,QICNT2	- QIO COUNT DOUBLE WORD
;				RNCNT		- TOTAL NUMBER OF TASK RUN
;				INSCNT		- TOTAL # OF INSTALLS DONE
;				ATCNT		- NUMBER OF TIMES @ RUN
;			4) ZERO THE APPROPRIATE VALUES IN THE UCB
;
;	JGD14		MAKE BYE LOGOFF(FOR TASKS RUNNING SYSTEM
;			ACCOUNTING) LOOK LIKE RSX11M+ LOGOFF, IE.
;			PRINT OUT CONNECT TIME, CPUTIME,AND # OF
;			TASKS RUN ON TI: AT LOGOFF.
;
;	JGD15		MODIFY UCB ADDITIONS DEFINITIONS TO ALLOW FOR MULTIPLE
;			CLI SUPPORT(M$$CLI) WHICH ADDS A WORD BEFORE U.LUIC.
;			U.CLI POINTS TO MCR.  WITHOUT THIS CHANGE A SYSTEM
;			INCLUDING BOTH DECNET SUPPORT AND THE KMS PACKAGE
;			WILL HANG UP AS SOON AS ANYTHING IS TYPED.
;
;	JGD16		PREVENT FROM STARTING LOGOUT.CMD IF A VIRTUAL TERMINAL
;
;	JGD17		CHANGE DEFAULT UIC TO LOGIN UIC PRIOR TO ISSUING A 
;			@LOGOUT.CMD
;
;	JGD18		TRACK DOWN PHYSICAL LB:, CONDITIONALIZE OUT REFERENCES
;			TO PRIVILEGE MASK WORD IF R$$PRV NOT DEFINED
;
;	JGD20		REMOVE OLD SPECIAL CODE TO SYNCRONIZE VT: FOR BATCH
;			(SPAWNING NOW HANDLES SYNCRONIZATION).  HANDLE 
;			MIDNIGHT TURNAROUND(EXCEPT ON LAST DAY OF MONTH).
;
;	JGD21		DON'T SEND OFF PACKET TO LOG, IF ACCOUNT NOT FOUND
;			(STILL LOGGED ONTO FIRST TERMINAL?)
;
%
-/.MCALL/,,/; JGD01/
	.MCALL GLUN$S,OPEN$U,CLOSE$,MRKT$,UCBDF$
-,,/; JGD13/
	.MCALL	USTP$,SDAT$,RQST$

;
-/DEFINE ANSI/,,/; JGD06/
	UCBDF$			; DEFINE TERMINAL UCB OFFSETS
	.IFNDF	D$$H11&D$$J11&D$$M11&D$$ZMD&D$$Z11&D$$V11&D$$VMD
U.PRV1=U.CW3			; FOR SYSTEMS WITH ONLY DL11'S
	.IFF			; IF HAVE MULTIPLEXERS
-,,/; JGD15/
	.IFDF	M$$CLI!A$$CLI	; IF HAVE MULTIPLE CLI SUPPORT(DECNET) + MULTIPLEXERS
U.PRV1=U.CLI-2			; THEN U.PRV1 IS OFFSET FROM U.CLI (UP 1 WORD)
	.IFF			; IF NOT DEFINED
U.PRV1=U.LUIC-2			; FOR SYSTEMS WITH MULTIPLEXERS + NO MULTIPLE CLI
	.ENDC			; .END M$$CLI
	.ENDC			; END TEST FOR MULTIPLEXERS

-,,/; JGD13/
	.IF DF M$$MUP		; MULTI USER PROTECTION BETTER BE PRESENT FOR
				; THE OFFSETS TO WORK
	.IFDF	T$$CPU		; IF KMS DATA STRUCTURE ADDED TO UCB
	.IFDF	M$$CLI!A$$CLI	; IF MULTIPLE CLI SUPPORT
U.ACN=U.LUIC-6			; OFFSET USER ACCOUNT NUMBER FROM U.CLI
	.IFF			; IF NO MULTIPLE CLI SUPPORT
U.ACN=U.LUIC-4			; OFFSET USER ACCOUNT NUMBER FROM U.LUIC
	.ENDC			; .END M$$CLI
	.ENDC			; .END T$$CPU

	.IF DF	T$$CPU		; IF CPU TIME ACCOUNTING DEFINED
U.TIC2=U.ACN-2			; HIGH ORDER CPU TIME IN TICS
U.TIC1=U.TIC2-2			; LOW ORDER CPU TIME IN TICS
U.RNCT=U.TIC1-2			; NUMBER OF TASK RUN
U.INCT=U.RNCT-2			; NUMBER OF TIMES INS IS USED
U.ATCT=U.INCT-2			; NUMBER OF TIME @ IS RUN
	.ENDC			; T$$CPU
	.IF DF Q$$CNT		; IF QIO ACCOUNTING IS DEFINED
U.QIO2=U.ATCT-2			; QIO COUNTER HIGH VAL
U.QIO1=U.QIO2-2			; QIO COUNTER LO VAL
	.ENDC			; Q$$CNT
	.ENDC			; M$$MUP
-,,/; JGD18/
;
; DEFINE PRIVILEGE MASK WORD BITS
;
PM.ABO	=       20		; DO NOT ABORT NON-PRIV TASKS AT LOGOFF
PM.DSK	=      100		; ACNT FOR USER'S DISK BLOCKS AT LOGOFF


-,,/; JGD01/
;
;CONSTANTS
;
LUN1=1			; TI: LUN
LUN2=2			; ACNT FILE LUN
EFN1=1			; EVENT FLAG FOR ALL I/O
GLNBUF:	.BLKW	6.	; GET LUN BUFFER
ENTRY:	.WORD	0	; ADDRESS OF ACCOUNT ENTRY
PRVFLG:	.WORD	0	; FLAG TO INDICATE TERMINAL SHOULD BE RESET PRIVLEGED
OPNERR:	.WORD	0	; ACCOUNT FILE OPEN ERROR FLAG
-,,/; JGD17/
LUIC:	.WORD	0	; STORAGE FOR LOGIN UIC
-,,/; JGD07/
SKPFLG:	.WORD	0	; =0 ->UPDATE DISK BLOCK USAGE, =1->SKIP UPDATE
-,,/; JGD13/
VTFLAG:	.WORD	0	; >0 IMPLIES WE HAVE A VIRTUAL TERMINAL
-,,/; JGD21/
NOSEND:	.WORD	0	; >0 IMPLIES DON'T SEND PACKET TO LOG...
-,,/; JGD14/
CNCTIM:	.WORD	0	; CONNECT TIME
	.IF DF T$$CPU	; IF CPU ACCOUNTING SELECTED
CPUTIM:	.WORD	0	; CPU TIME(SEC)
RUNCNT:	.WORD	0	; NUMBER OF TASKS RUN
	.ENDC		; .END T$$CPU
-,,/; JGD18/
PRVMSK:	.WORD	0	; STORAGE FOR PRIVILEGE MASK WORD
-/MSG5:/,,/; JGD01/
MSG6:	.ASCIZ	<15><12>/BYE -- Still logged onto first terminal?/<15><12><7>/>/
MSG7:	.ASCIZ	<15><12>/BYE -- Account file busy -- Try again/<15><12><7>/>/
MSG8:	.ASCIZ	<15><12>/BYE -- Privileged logoffs disabled/<15><12><7>
MSG9:	.ASCIZ	<15><12>/BYE -- Account read error -- GET HELP!/<15><12><7>/>/
MSG10:	.ASCIZ	<15><12>/BYE -- Account file locked -- Try again!/<15><12><7>/>/
-,,/; JGD13/
MSG11:	.ASCIZ	<15><12>/BYE -- Send data error to system logging task LOG.../
-,,/; JGD14/
MSG12:	.ASCII	<15><12>
	.ASCII	/Connect time: /
MSG12A:	.ASCII	/NNNNN/
MSG12B:	.ASCIZ	/ Min./
	.IF DF T$$CPU		; IF CPU LOGGING DEFINED
MSG13:	.ASCII	/CPU time used:/
MSG13A:	.ASCII	/NNNNN/
MSG13B:	.ASCIZ	/ Sec./
MSG14:	.ASCII	/Task total:   /
MSG14A:	.ASCIZ	/NNNNN/
	.ENDC			; .END CPU ACCOUNTING
-,,/; JGD18/
MSG15:	.ASCIZ	<15><12>/BYE -- LB: not redirected to physical device/
-,,/; JGD20/
MSG16:	.ASCII	<15><12>/BYE -- Account file not updated./
	.ASCII	<15><12>/BYE -- Connect time is unreasonably long./
	.ASCIZ	<15><12><7>/BYE -- Check to see if system clock is correct./
-,,/; JGD17/
GRP:	.ASCIZ	/GGG/
MEM:	.ASCIZ	/MMM/
-/DMO:/,,/; JGD01/
UPDAT:	.ASCIZ	%UPD XXXX:[GGG,MMM]PASWRD/UP%<15>
-/IOSTAT:/,,/; JGD13/
RQSTLG:	RQST$	LOG...		; START UP THE LOGGING TASK
USTPLG:	USTP$	LOG...		; UNSTOP THE LOGGING TASK
SENDAT:	SDAT$	LOG...,SNDBUF	; SEND DATA TO LOG...
SNDBUF:	.WORD	6		; THE SIX SHOW'S IT'S A BYE/LOGOFF RECORD
	.BLKW	12.		; THE REST OF THE SEND PACKET
-,,/; JGD01/
FDPB:	QIO$	IO.RVB,LUN2,EFN1,,IOSB,,<$ACTBF,$BFLEN,,,1>
IOSB:	.BLKW	2		; IOSTATUS BLOCK
MKT:	MRKT$	1,1,2		; WAIT 1 SECOND

-/$BYEEP:/,,/; JGD16/
	GLUN$S	#LUN1,#GLNBUF	; GET TERMINAL NUMBER AND TYPE
	CMP	#"VT,GLNBUF	; IS THIS A VIRTUAL TERMINAL
	BNE	1$		; IF NE, NO
	INC	VTFLAG		; TELL ALL THE WORLD ITS VIRTUAL
	INC	SKPFLG		; DON'T TRY & UPDATE DIRECTORY
1$:				; REF LABLE
-,,/; JGD18/
	CALL	SETLB		; FIND PHYSICAL LB:(EXIT IF CAN'T)
-/201$:/
-/R0,UCB/,,/; JGD01/
	BIT	#FE.NLG,$FMASK	; ARE LOGONS DISABLED
	BEQ	207$		; NO, SO CONTINUE ON WITH LOGOFF
	BIT	#U2.PRV,U.CW2(R0) ; IS TERMINAL PRIVLEGED
	BEQ	207$		; NO , SO CONTINUE WITH LOGOF
	MOV	#MSG8,R0	; PRIVLEDGED, SO PRINT WARNING AND EXIT
	CALL	BYEERR		; WITHOUT LOGING OFF TERMINAL
	EXIT$S			; EXIT
-/207$:/,,/; JGD01/
	BIT	#U2.PRV,U.CW2(R0) ; IS TERMINAL PRIVLEDGED
	BEQ	210$		; IF NOT PRIVLEDGED SKIP OVER
	INC	PRVFLG		; SET PRIVLEGE FLAG FOR LATER
210$:				; REF LABLE
-/CALL	ABORT/,.,/; JGD05/

	.IFDF	R$$PRV		; IF RUN PRIV SELECTED
	MOV	UCB,R0		; GET PRIVILEGE MASK WORD
	MOV	U.PRV1(R0),PRVMSK ; SAVE PRIVILEGE MASK WORD
	.ENDC			; .END R$$PRV

	BIT	#PM.ABO,PRVMSK	; SHOULD WE SKIP ABORTING TASKS?
	BNE	301$		; IF NE, YES, BIT IS SET
	CALL	ABORT		; ABORT ALL NON-PRIVLEGED TASKS FROM TI:
301$:				; REFERENCE LABLE
-/CALL	ABORT/,.,/; JGD05/
				; Code added to bypass the V4.0 double abort
				; for non-priv tasks with abort ast's.
	BIT	#PM.ABO,PRVMSK	; Should we skip aborting tasks?
	BNE	361$		; If NE, yes, bit is set
	CALL	ABORT		; Abort all non-privileged tasks from TI:
361$:				; Ref lable
-/34$:/,,/; JGD17/
	GTIM$S	#TIMBUF		; GET TIME AND FILL TIME BUFFER
	MOV	TIMBUF+6,R1	; GET HOUR
	CALL	LOGOFF		; FIND ACCOUNT FOR TERMINAL AND UPDATE
	MOV	UCB,R0		; GET UCB ADDRESS AGAIN
-/BYE1:/,.+1,/; JGD01/
47$:				; REF LABLE
	TST 	VTFLAG		; IF WE ARE A VT:, ALWAYS LOG OFF
	BNE	BYE1		; REGARDLESS OF ERRORS
	TST	OPNERR		; IF THE ACCOUNT FILE IS BUSY DON'T LOG OFF
				; USER.  LET HIM TRY AGAIN
	BEQ	BYE1		; ENTRY MADE INTO ACCOUNT FILE, SO PROCEED
				; TO LOG OFF TERMINAL
	DIR$	#SLVDPB		; ACNT FILE WAS LOCKED ,ATTEMPT QIO$ TO UNSLAV
	MOV	UCB,R0		; IN CASE QIO FAILS DO IT DIRECTLY
	BIC	#U2.SLV,U.CW2(R0) ; SO USER CAN TRY AGAIN, IE NON SLAVE
	BIS	#U2.PRV,U.CW2(R0) ; TEMPORARILY MAKE PRIVLEGE
	TST	PRVFLG		; SHOULD TERMINAL BE PRIVLEDGED
	BGT	50$		; YES, LEAVE PRIVLEGED AND EXIT
	BIC	#U2.PRV,U.CW2(R0) ; OTHERWISE SET NON PRIVLEDGED
50$:	EXIT$S			; LET USER TRY AGAIN TO LOG OFF
BYE1:	;CALL	LGOLOG		; LOG LOGOUT ON CO:
;	ROL	-(SP)		; SAVE C-BIT FOR WAIT-CHECK
-,,/; JGD13/
	BIT	#200,$ACMSK	; ARE WE SUPPOSED TO LOG LOGOFFS
	BEQ	105$		; IF EQ 0, NO
	TST	NOSEND		; SHOULD WE SEND DATA(MAYBE LOGOFF ERROR)
	BNE	105$		; IF >0 NO SKIP
	DIR$	#SENDAT		; SEND DATA
	BCC	103$		; CARRY ON IF CARRY CLEAR
102$:	MOV	#MSG11,R0	; GET READY TO WARN USER OF SEND TROUBLE
	CALL	BYEERR		; DO IT
	BR	105$		; JUST EXIT
103$:	DIR$	#USTPLG		; UNSTOP THE LOGGER
	BCC	105$		; ALL OK IF CC
	DIR$	#RQSTLG		; LOG... MUST HAVE EXITED, RESTART IT
105$:				; REF LABLE
-/CALL	BYEERR/
-/CALL	BYEERR/+1,/20$:/,/; JGD04/
195$:				; REF LABLE
	BIT	#PM.DSK,PRVMSK	; IS BIT 6 OF THE PRIVLEGE MASK WORD SET
	BEQ	BYEXIT		; NO, SO DON'T UPDATE DISK BLOCK USAGE
	TST	SKPFLG		; SHOULD WE SKIP DISK BLOCK USAGE UPDATE?
	BNE	20$		; IF NE, YES , DON'T SEND A MESSAGE TO ...UPD
	MOV	#UPDAT,R5	; MOVE IN CMD TO UPDATE THE USERS ACCOUNT FILE
	CALL	GIVMCR		; GIVE IT TO MCR
;	ROR	(SP)+		; NEED TO WAIT ON CO:?
;	BCS	20$		; IF CS NO
;	CALL	$COWAT		; YES--WAIT FOR IT
20$:
-/BYEXIT:/
-/50$:/+1,,/; JGD13/
	.IF DF	T$$CPU
	CLR	U.ACN(R0)	; RESET ACNT # SO IT CAN COUNT ILLEGAL LOGONS
	.ENDC			; .ENDC T$$CPU
-/CMDFIL:/,,/; JGD16/
	TST	VTFLAG		; IS THIS A VIRTUAL TERMIANL
	BEQ	1$		; NO, CONTUE
	RETURN			; YES, SO DON'T DO THIS
1$:				; REF LABLE
-/.END	$BYEEP/,.,/; JGD01/

;+
; *** -LOGOFF  -  OPEN ACCOUNT FILE, COMPUTE LOGON TIME FOR THIS TERMINAL
;		     SESSION(MINUTES), AND ADD TO ACCOUNT FILE VALUE
;-
LOGOFF:				; REF LABLE
	CLR	OPNERR		; SET OPEN ERROR FLAG INITIALLY TO "NO ERROR"
50$:	CALL	OPEN		; OPEN [0,0]RSX11.SYS--THE ACCOUNT FILE
	BCS	100$		; SKIP ALL THE REST IF THE FILE WON'T OPEN
	CALL	SEARCH		; SEARCH ACCOUNT FILE FOR CURRENT ACCOUNT
				; LOGGED ONTO THIS TERMINAL
	BCS	100$		; DIDN'T FIND TI# IN ACNT
	CALL	UPDATE		; COMPUTE LOGON TIME FOR THIS TERMINAL
				; AND ADD IT TO TOTAL IN ACCOUNT FILE
	BCS	100$		; DON'T CLOSE HERE IF FILE LOCKED
-,,/; JGD17/
	MOVB	UPDAT+10.,GRP	; GET GROUP CODE
	MOVB	UPDAT+11.,GRP+1	;
	MOVB	UPDAT+12.,GRP+2	;
	MOVB	UPDAT+14.,MEM	; GET MEMBER CODE
	MOVB	UPDAT+15.,MEM+1	;
	MOVB	UPDAT+16.,MEM+2	;
	MOV	#GRP,R0		; SET GROUP STRING
	CALL	$COTB		; CONVERT TO BINARY
	MOV	R1,LUIC		; SET IN UIC(TEMP STORAGE)
	SWAB 	LUIC		; SWAP HIGH AND LOW BYTES(GRP IN HIGH BYTE)
	MOV	#MEM,R0		; SET MEMBER VALUE
	CALL	$COTB		; CONVERT TO BINARY BYTE
	BIS	R1,LUIC		; FINISH UP CREATING LOGIN UIC
	MOV	UCB,R0		; GET UCB ADDRESS
	MOV	LUIC,U.LUIC(R0)	; SET LOGIN UIC
-,,/; JGD14/
	MOV	#1,R2		; KEEP LEADING ZEROS
	MOV	CNCTIM,R1	; CNVRT TO DECIMAL ASCII THE CONNECT TIME(MIN)
	MOV	#MSG12A,R0	; ADDRESS OF WHERE TO PUT VALUE
	CALL	$CBDMG		; CONVERT TO ASCII DECIMAL
	MOV	#MSG12A,R0	; GET SET TO CONVERT LEADING ZEROS TO SPACES
	CALL	INSPAC		; INSERT SPACES
	MOV	#MSG12,R0	; GET SET TO WRITE IT OUT
	CALL	BYEERR		; WRITE IT OUT CONNECT TIME MESSAGE
	.IF DF	T$$CPU		; IF CPU ACCOUNTING RUNNING
	MOV	#1,R2		; KEEP LEADING ZEROS
	MOV	#MSG13A,R0	; PUT CPU TIME(SEC) HERE
	MOV	CPUTIM,R1	; CONVERT THIS NUMBER
	TST	CPUTIM		; ANY CPU TIME TO DISPLAY
	BEQ	97$		; IF EQ 0, NO, SKIP OVER
	CALL	$CBDMG		; CONVERT TO DECIMAL MAGNITUDE
	MOV	#MSG13A,R0	; GET SET TO CONVERT LEADING ZEROS TO SPACES
	CALL	INSPAC		; INSERT SPACES
	MOV	#MSG13,R0	; GET SET TO WRITE IT OUT  CPU TIME MESSAGE
	CALL	BYEERR		; WRITE IT OUT
97$:	TST	RUNCNT		; HAVE ANY TASKS BEEN REQUESTED TO RUN
	BEQ	98$		; IF EQ,NO( LOGGING MUST BE OFF)
	MOV	#1,R2		; DON'T SUPRESS ZEROS
	MOV	RUNCNT,R1	; NUMBER TO CONVERT
	MOV	#MSG14A,R0	; PUT NUMBER HERE
	CALL	$CBDMG		; CONVERT TO DECIMAL MAGNITUDE
	MOV	#MSG14A,R0	; GET SET TO CONVERT  LEADINZ ZEROS TO SPACES
	CALL	INSPAC		; DO IT
	MOV	#MSG14,R0	; GET SET TO WRITE IT OUT RUN COUNT MESSAGE
	CALL	BYEERR		; WRITE IT
98$:				; REF LABLE
	.ENDC			; .END T$$CPU
-,,/; JGD01/
99$:	CALL	CLOSE		; CLOSE THE FILE
100$:	RETURN			; RETURN AND FINISH LOGGING OFF


;+
; *** - OPEN  -  OPEN [0,0]RSX11.SYS FOR UPDATE
;-
OPEN:	OPEN$U	#$ACTFL,,,#FD.RWM	;OPEN [0,0]RSX11.SYS FOR UPDATE
	BCC	50$		; CARRY CLEAR IMPLIES FILE OPEN
				; IF SET-->FILE LOCKED, BUSY,OR FCS ERROR
	CMP	OPNERR,#5	; FIVE FAILURES?
	BLT	25$		; NO, LETS TRY OPENING IT AGAIN
20$:	MOV	#MSG7,R0	; YES, LOOKS LIKE ACCOUNT FILE BUSY
	CALL	BYEERR		; PRINT MESSAGE TO TRY LOGGING OFF AGAIN
				; UNLESS LOGGING OFF SUCESSFUL, A NONPRIV'D
				; USER CAN'T LOG ON AGAIN(VIA HELLO)
	SEC			; SET "CARRY" TO DECLARE FAILURE
	RETURN			; TRYING TO UPDATE THE ACCOUNT FILE
25$:	DIR$	#MKT		; MAYBE FILE IS BUSY, WAIT ONE SECOND
	BCS	20$		; ERROR?, TRY LOGGING OFF LATER, MARK TIMES
				; SHOULD WORK!
	WTSE$S	#1		; WAIT FOR MARK TIME TO COMPLETE AND SET EFN 1
	INC	OPNERR		; INCREMENT  # OF TIMES TRIED
	BR	OPEN		; LETS TRY AGAIN
50$:	CLR	OPNERR		; RESET ERROR FLAG TO NO ERROR
	RETURN			; ALL DONE GO BACK

;+
; *** - QIO  -  ISSUE QIO
;
; INPUT:
;	R4 - DPB ADDRESS
;
;-
QIO:	DIR$	R4		; ISSUE QIO
	BCS	10$		; ERROR
	MOVB	Q.IOEF(R4),R5	; GET EVENT FLAG TO WAIT ON
	WTSE$S	R5		; WAIT FOR I/O COMPLETION
10$:	RETURN			;

;+
; 	** - CLOSE  -  CLOSE THE ACCOUNT FILE
;-
CLOSE:	CLOSE$	#$ACTFL		; CLOSE ACCOUNT FILE
	RETURN			;


;+
; *** - SEARCH  -  SEARCH FILE FOR LOGED ON TERMINAL
;
; OUTPUT:
;	R0 - ADDRESS OF ACCOUNT ENTRY
;	ENTRY - ADDRESS OF START OF ACCOUNT BLOCK IN BUFFER
;	CARRY CLEAR - ACCOUNT FOUND
;	CARRY SET - ACCOUNT NOT FOUND
;-
SEARCH:				;
	MOV	#FDPB,R4	; GET FILE DPB ADDRESS
	MOV	#1,Q.IOPL+10(R4) ; SET TO START AT VBN 1
	CLR	Q.IOPL+6(R4)	;
5$:	CALL	QIO		; READ NEXT BLOCK
	MOV	IOSB+2,R2	; GET COUNT OF WORDS READ
	BEQ	25$		; ZERO, NO WORDS READ
	MOV	#$ACTBF,R0	; GET BUFFER ADDRESS
10$:	MOV	R0,ENTRY	; YES, SAVE ENTRY ADDRESS
-,,/; JGD13/
	TST	VTFLAG		; IS TERMINAL A VT:?
	BEQ	11$		; IF EQ, NO
	ADD	#A.VTRM,R0	; POINT TO VT IN USE FLAG WORD
	TST	(R0)		; IS ANY THING THERE('V' LO BYTE, #, HI BYTE)
	BEQ	20$		; IF EQ, TRY ANOTHER ACCOUNT
	CLR	(R0)		; SO ZERO IT OUT
	BR	12$		; IF NE, GOT ACCOUNT
-,,/; JGD01/
11$:	ADD	#A.TERM,R0	; POINT ADDRESS AT TT ENTRY
	INC	R0		; POINT ADDRESS AT TERMINAL #
	INC	R0		;
	CMP	GLNBUF+2,(R0)	; IS ACNT ENTRY THE SAME AS TI'S #?
	BNE	20$		; NO, KEEP GOING
12$:	MOV	ENTRY,R0	; YES, THEN RESTORE ENTRY ADDRESS
	JMP	40$		; FOUND TERMINAL NUMBER
20$:	MOV	ENTRY,R0	; RESTORE ENTRY POINTER
	ADD	#A.LEN,R0	; POINT TO NEXT ENTRY
	SUB	#A.LEN,R2	; COMPUTE WORDS LEFT IN BUFFER
	BHI	10$		; LOOP, MORE LEFT
25$:	CMPB	#IE.EOF,IOSB	; END OF FILE?
	BEQ	50$		; YES(MUST HAVE LOGGED OFF BEFORE)
				; BUT PRIVLEDGED USERS MAY DO THIS
	TSTB	IOSB		; ANY ERRORS?
	BMI	60$		; YES(A READ ERROR?)
	ADD	#$BFLEN/512.,Q.IOPL+10(R4) ; NO, POINT TO NEXT VBN
	ADC	Q.IOPL+6(R4)	;
	JMP	5$		; READ IN NEXT BUFFER
40$:	RETURN			;
50$:	CALL	CLOSE		; CLOSE THE ACCOUNT FILE
	MOV	#MSG6,R0	; USER COULD BE LOGGED ON OTHER TERMINAL ALSO
				; OR ACCOUNT FILE  GOT SCRAMBLED
	INC	NOSEND		; LEAVE A FLAG SO WON'T SEND DATA TO LOG
55$:	CALL	BYEERR		; WARN USER
-,,/; JGD07/
	INC	SKPFLG		; IF ANY ERROR, OR ACCOUNT NOT FOUND DO NOT
				; TRY AND UPDATE DISK BLOCK USAGE
-,,/; JGD01/
	SEC			; SKIP UPDATE PART("TTN" NOT ZEROED)
				; IF A READ ERROR FOUND OR IF THE "TTN" ENTRY
				; INTO THE ACCOUNT FILE IS NOT FOUND, LOG OFF
				; THE USER.  A PRIVLEDGED USER CAN GET BACK ON
				; AND UNLOCK A NONPRIVLEDGED ACCOUNT
	RETURN			; RETURN
60$:	CALL	CLOSE		; ACCOUNT FILE READ FAILURE, LOG OFF AND
				; GET HELP
	MOV	#MSG9,R0	; PRINT -- FILE READ FAILURE
	BR	55$		; PRINT ERROR MESSAGE AND EXIT

;+
; *** - UPDATE -- ADD CURRENT TERMINAL LOGON TIME TO TOTAL TIME
;			IN DATA FILE
;-

UPDATE:				; REF LABLE
	MOV	#FDPB,R4	; GET THE FILE DPB ADDRESS
	MOV	#IO.WVB,2(R4)	; SET QIO FOR WRITE TO FILE
	MOV	IOSB+2,Q.IOPL+2(R4) ; SET COUNT OF BYTES TO WRITE
-,,/; JGD13/
	TST	VTFLAG		; IF ON VT: MUST TREAT LOGOFF DIFFERENTLY
	BNE	5$		; IF NE IS A VT:
-,,/; JGD04/
	MOV	ENTRY,R0	; POINT TO START OF ACCOUNT FILE
	ADD	#A.SYDV,R0	; POINT TO DEVICE NAME
	MOVB	(R0)+,UPDAT+4	; MOVE IN THE DEVICE NAME
	MOVB	(R0)+,UPDAT+5	;
	MOVB	(R0)+,UPDAT+6	;
	MOVB	(R0)+,UPDAT+7	; ALL 4 CHARACTERS
	MOV	ENTRY,R0	; RESTORE POINTER
	ADD	#A.GRP,R0	; POINT TO GROUP ENTRY
	MOVB	(R0)+,UPDAT+10.	; MOVE IN THE GROUP CODE
	MOVB	(R0)+,UPDAT+11.	;
	MOVB	(R0)+,UPDAT+12.	;
	MOVB	(R0)+,UPDAT+14.	; MOVE IN THE MEMBER CODE
	MOVB	(R0)+,UPDAT+15.	;
	MOVB	(R0)+,UPDAT+16.	; ALL DONE
	MOV	ENTRY,R0	; RESET POINTER TO START OF ACCOUNT BLOCK
	ADD	#A.PSWD,R0	; POINT TO PASSWORD ENTRY
	MOVB	(R0)+,UPDAT+18.	; MOVE IN THE 6 LETTER PASSWORD
	MOVB	(R0)+,UPDAT+19.	;
	MOVB	(R0)+,UPDAT+20.	;
	MOVB	(R0)+,UPDAT+21.	;
	MOVB	(R0)+,UPDAT+22.	;
	MOVB	(R0)+,UPDAT+23.	; ALL DONE
-,,/; JGD01/
	MOV	ENTRY,R0	; GET ADDRESS OF ACCOUNT ENTRY
	ADD	#A.TERM,R0	; POINT TO TERMINAL NUMBER ENTRY
	CLR	(R0)+		; REMOVE "TT" ENTRY FROM FILE
	CLR	(R0)		; REMOVE TERMINAL NUMBER FROM FILE
-,,/; JGD13/
5$:	MOVB	GLNBUF,SNDBUF+10; SHOW TERMINAL TYPE
	MOVB	GLNBUF+2,SNDBUF+11 ; SHOW TERMINAL NUMBER
	MOV	TIMBUF+6,SNDBUF+2 ; SET HOUR
	MOV	TIMBUF+10,SNDBUF+4 ; SET MIN
	MOV	TIMBUF+12,SNDBUF+6 ; SET SEC
	MOV	UCB,R0		; GET OUR UCB ADDRESS
	MOV	U.LUIC(R0),SNDBUF+14 ; SET LOGIN UIC
	.IF DF T$$CPU		; IF CPU LOGGING BUILT IN
	MOV	U.ACN(R0),SNDBUF+12 ; SET OUR ACNT # IN THE SEND PACKET
	CLR	U.ACN(R0)	; RESET IT TO ZERO
	MOV	U.ATCT(R0),SNDBUF+20 ; SET @ USAGE COUNT IN SEND BUFFER
	MOV	U.QIO1(R0),SNDBUF+22 ; LOVAL QIO CNT
	MOV	U.QIO2(R0),SNDBUF+24 ; HIVAL QIO CNT
	MOV	U.RNCT(R0),SNDBUF+26 ; SET RUN COUNT IN SEND PACKET
-,,/; JGD14/
	MOV	U.RNCT(R0),RUNCNT ; SET RUN COUNT FOR LATER DISPLAY
-,,/; JGD13/
	MOV	U.INCT(R0),SNDBUF+30 ; SET INS COUNT IN SEND PACKET
	MOV	U.TIC1(R0),R2	; LOW TIC COUNT
	MOV	U.TIC2(R0),R1	; HIGH TIC COUNT
	MOV	$TKPS,R0	; GET TICS/SEC
	CALL	$DDIV		; DO DP DIVIDE
	MOV	R2,SNDBUF+16	; SET CPU TIME INTO SEND BUFFER
-,,/; JGD14/
	MOV	R2,CPUTIM	; SET CPU TIME FOR LATER DISPLAY
-,,/; JGD13/
	MOV	ENTRY,R0	; POINT TO START OF ACOUNT BLOCK
	ADD	#A.CPU,R0	; POINT TO CPU TIME ENTRY(2 WORDS)
	ADD	R2,(R0)+	; ADD IN CURRENT TIME
	ADC	(R0)		; ADD CARRY IF ANY
	ADD	R1,(R0)		; AND ADD HIGH ORDER PART
				; *** NOTE IF THE ACCOUNT FILE IS NOT
				;     RESET REGULARLY(EACH MONTH) OVERFLOWS 
				;     CAN RESULT IN DESTROYING THE DATA.
	.ENDC			; .ENDC T$$CPU
	TST	VTFLAG		; IS THIS TERMINAL A VT:?
	BGT	10$		; IF GT YES, SKIP THE REST OF THE STUFF
-,,/; JGD01/
	MOVB	TIMBUF+4,R1	; GET DAY, TO BE SURE LOGOFF IS ON SAME DAY
	MOV	ENTRY,R0	; AS LOGON. GET ADDRESS OF ACCOUNT ENTRY
	ADD	#A.LDAT,R0	; POINT TO DATE ENTRY
-,,/; JGD20/
	MOVB	(R0),R0		; GET DAY OF LOGON
	SUB	R0,R1		; COMPUTE NUMBER OF DAYS DIFFERENT.
	BLT	10$		; IF LT, TIME ERROR, OR TURNOVER AT END OF 
				; MONTH, IN EITHER CASE, DON'T UPDATE
	CMP	R1,#MAXDAY	; HAVE MORE THAN 'MAXDAY'S GONE BY??
	BLE	7$		; NO, SO PROCEED
	MOV	#MSG16,R0	; WARN USER, TIME MAY BE OFF
	CALL	BYEERR		; WRITE OUT MESSAGE
	BR	10$		; AND SKIP UPDATE
7$:	MUL	#24.,R1		; GET NUMBER OF HOURS IN 'N' DAYS
	MOVB	TIMBUF+6,R0	; GET HOUR AT WHICH TERMINAL LOGGED OFF
	ADD	R0,R1		; ADD IN NUMBER OF HOURS DIFFERENT
-,,/; JGD20/
	MUL	#74,R1		; MULTIPLY BY 60 TO PUT IN MINUITS
	MOVB	TIMBUF+10,R0	; GET MINUITES AT LOGOFF
	ADD	R0,R1		; ADD TO GET THE TOTAL CLOCK MINUITS
	MOV	ENTRY,R0	; GET ADDRESS OF ACCOUNT FILE ENTRY
	ADD	#A.LDAT+2,R0	; POINT TO THE HOUR/YEAR WORD
	INC	R0		; POINT TO HOUR-THE HIGH BYTE
	MOVB	(R0)+,R3	; SAVE THE HOUR
	MUL	#74,R3		; CONVERT TO MINUITS
	MOVB	(R0),R2		; GET MINUITS AT LOGON TIME
	ADD	R2,R3		; COMPUTE TOTAL CLOCK MINUITS AT LOGON
	SUB	R3,R1		; GET TOTAL TIME LOGGED AT TERMINAL THIS TIME
-,,/; JGD14/
	MOV	R1,CNCTIM	; SET CONNECT TIME IN FOR LATER DISPLAY
-,,/; JGD01/
	MOV	ENTRY,R0	; RESTORE FILE ADDRESS
	ADD	#A.CTIM,R0	; POINT TO TOTAL CONNECT TIME ENTRY
	ADD	(R0),R1		; ADD LOGON TIME TO TOTAL CONNECT TIME
	BVS	10$		; IF ACCOUNT WOULD OVERFLOW DON'T ADD MORE IN
	MOV	R1,(R0)		; OTHERWISE, INSERT INTO THE ACCOUNT FILE
10$:	CALL	QIO		; WRITE OUT THE UPDATED ACCOUNT BLOCK
	TSTB	IOSB		; CHECK TO SEE IF ERROR ON WRITE TO ACNT
				; THIS GUARDS AGAINST DK0: BEING WRITE LOCKED
	BGT	20$		; NO ERROR IF >0, SO SKIP OVER THE NEXT LINES
	INC	OPNERR		; SET OPNERR AS FLAG SO WON'T LOG OFF TERMINAL
	CALL	CLOSE		; CLOSE FILE FAST, THE DISK IS WRITE LOCKED
	MOV	#MSG10,R0	; WARN THE USER THAT ACCOUNT IS WRITE LOCKED
	CALL	BYEERR		; PRINT OUT THE MESSAGE
	SEC			; SET CARRY TO FLAG ERROR
20$:	MOV	#IO.RVB,2(R4)	; RESTORE THE DPB
	MOV	#$BFLEN,Q.IOPL+2(R4) ; AND THE BUFFER LENGTH
	RETURN			;
 
 
;+
; INSPAC - CONVERT LEADING ZEROS TO SPACES
;
; INPUT:	R0 POINTS TO FIRST CHARACTER
;
;-
INSPAC:	CMPB	#'0,(R0)	; IS IT A '0'
	BNE	10$		; IF NE ALL DONE
	MOVB	#40,(R0)+	; ELSE FILL WITH A SPACE
	BR	INSPAC		; AND LOOP
10$:	RETURN			; ALL DONE

-,,/; JGD18/

;+
; SETLB -- FIND THE PHYSICAL DEVICE TO WHICH LB0: IS REDIRECTED
; 	   AND SET IT IN THE FDB FOR RSX11.SYS
;-
SETLB:
	CALL	$SWSTK,5$	; SWITCH TO SYSTEM STATE
	MOV	$TKTCB,R1	; GET MY TCB ADDRESS
	MOV	T.UCB(R1),R1	; GET TERMINAL UCB ADDRESS
	MOV	$DEVHD,R2	; START AT BEGINNING OF DEVICE TABLE
1$:	CMP	D.NAM(R2),#"LB	; AND LOOK FOR LB:
	BEQ	2$		; EQ- FOUND
	MOV	D.LNK(R2),R2	; NEXT DEVICE
	BNE	1$		; TRY IT!
	CLR	4(SP)		; INDICATE ERROR BY SETTING USER R1=0
	RETURN			; TELL USER STATE
2$:	MOV	D.UCB(R2),R0	; GET UCB ADDR
	MOV	U.RED(R0),R0	; FIND PHYSICAL LB: (IE FIRST REDIRECT)
	MOV	U.DCB(R0),R2	; FIND THE DCB OF PHYSICAL DEVICE
	MOV	D.NAM(R2),4(SP)	; PUT LB DEVICE INTO USER STATE R1
	SUB	D.UCB(R2),R0	; CALC UNIT NUMBER
	MOV	D.UCBL(R2),R1	;
	CALL	$DIV		;
	ADD	D.UNIT(R2),R0	;
	BIC	#177400,R0	; CLEAR UNWANTED BITS
	MOV	R0,6(SP)	; PUT UNIT NUMBER INTO USER STATE R2
	RETURN			; RETURN TO USER STATE
5$:				; REF LABEL
	TST	R1		; DID WE FIND PHYSICAL LB:???
	BNE	7$		; NE- YES
	MOV	#MSG15,R0	; SET ERROR MESSAGE (CAN'T FIND PHYS LB0:)
	CALL	BYEERR		; PRINT IT OUT
	EXIT$S			; EXIT AT ONCE
7$:	CLR	N.FID+F.FNB+$ACTFL ; ASSURE NOT OPEN BY FILE ID.
	MOV	F.DSPT+$ACTFL,R0 ; GET ADDR OF DATASET DESCRIPTOR
	MOV	2(R0),R0	; GET ADDR OF DEVICE STRING
	MOV	R1,(R0)+	; INSERT LB'S DEVICE NAME
	MOV	R2,R1		; SETUP TO CONVERT UNIT NUM TO ASCII
	MOV	#1,R2		; NO ZERO SUPPRESS
	CALL	$CBTMG		; CONVERT AND PLACE IN DEVICE STRING
	RETURN			;

	.END	$BYEEP		;
/