BYE.MAC;2=[12,10]BYE.VGN;1/AU:85.
\
-2,2
	.IDENT	/3.1XD/
-/MLG085/,,
;
;	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 THE 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 NUMBER 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.
;
%
-/.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
U.PRV1=U.CW3			; FOR SYSTEMS WITH ONLY DL11'S
	.IFF
-,,/; JGD15/
	.IFNDF	M$$CLI		; IF NO MULTIPLE CLI SUPPORT
U.PRV1=U.LUIC-2			; FOR SYSTEMS WITH MULTIPLEXERS
	.ENDC			; .END M$$CLI
	.IFDF	M$$CLI		; IF HAVE MULTIPLE CLI SUPPORT(DECNET)
	U.PRV1=U.CLI-2		; THEN U.PRV1 IS BUMPED UP 1
	.ENDC			; .END M$$CLI
	.ENDC
-,,/; JGD13/
	.IF DF M$$MUP		; MULTI USER PROTECTION BETTER BE PRESENT FOR
				; THE OFFSETS TO WORK
	.IFDF	R$$PRV		; IF KMS DATA STRUCTURE ADDED TO UCB
	.IFNDF	M$$CLI		; IF NO MULTIPLE CLI SUPPORT
U.ACN=U.LUIC-4			; USER ACCOUNT NUMBER
	.IFF			; IF HAVE MULTIPLE CLI SUPPORT
U.ACN=U.LUIC-6			; STILL HAVE USER ACCOUNT NUMBER
	.ENDC			; .END M$$CLI
	.ENDC			; .END R$$PRV

	.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


-,,/; 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
-,,/; JGD07/
SKPFLG:	.WORD	0	; =0 ->UPDATE DISK BLOCK USAGE, =1->SKIP UPDATE
-,,/; JGD13/
VTFLAG:	.WORD	0	; >0 IMPLIES WE HAVE A VIRTUAL TERMINAL
-,,/; 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
-/.ENDC	; R$$SCS/,,/; JGD07/
MSG1B:	.ASCIZ	<15><12>/$EOJ/	; TO SIGNAL BATCH ALL IS DONE
-/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
-/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


-/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/
3$:				; REF LABLE
	MOV	UCB,R0		; GET PRIVILEGE MASK WORD
	BIT	#20,U.PRV1(R0)	; 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
-/35$:/
-/.ENDC	; R$$SCS/,,/; JGD13/
 
	DEC	SPWDPB+S.PWCL	; PREVENT DEASSIGN COMMAND FROM CAUSING A PROMPT
	GLUN$S	#LUN1,#GLNBUF	; GET TERMINAL NUMBER AND TYPE
	CMP	#"VT,GLNBUF	; IS THIS A VIRTUAL TERMINAL
	BNE	352$		; IF NE, NO
	INC	VTFLAG		; ELSE SET FLAG
	INC	SKPFLG		; AND SKIP UPDATE FLAG
	BR	4$		; DON'T USE SPAWN DIRECTIVE WITH VT:
352$:				; REF LABLE
-/NO, WAIT SOME MORE/,,/; JGD13/
	TST	VTFLAG		; IS THIS A VT:
;	BNE	46$		; DON'T TRY DISMOUNTING DISKS FROM A VT:
	BEQ	6$		; NO, GO AHEAD AND DISMOUNT DISKS
	BIC	#U2.PRV,U.CW2(R0) ; SET TERMINAL NOT PRIVILEGED
	BR	46$		; DON'T TRY DISMOUNTING ANY DISKS
-/40$:/
-/BNE	10$/,,/; JGD13/
46$:				; REF LABLE
-/BYE1:/,.+1,/; JGD01/
	GTIM$S	#TIMBUF		; GET TIME AND FILL TIME BUFFER
	MOV	TIMBUF+6,R1	; GET HOUR
	CALL	LOGOFF		; FIND ACCOUNT FOR TERMINAL AND UPDATE
	TST 	VTFLAG		; IF WE ARE A VT:, NEED TO SET(RESET)
	BEQ	47$		; THE DPB FOR WRITE,  IF EQ, WE ARE NOT
	BR	BYE1		; ALWAYS LOG OFF VT: REGARDLESS OF FILE ERRORS
47$:				; REF LABLE
				; THE TOTAL LOGON TIME IN MINUTES
	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		; ACCOUNT FILE WAS LOCKED ,ATTEMPT QIO$ TO UNSLA
	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:			;BLS012
;	ROL	-(SP)		; SAVE C-BIT FOR WAIT-CHECK		;BLS012
-,,/; JGD13/
	BIT	#200,$ACMSK	; ARE WE SUPPOSED TO LOG LOGOFFS
	BEQ	105$		; IF EQ 0, NO
	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
-/BNE	15$/,.,/; JGD13/
	BNE	101$		; IF NE, YES

-/.ENDC	; R$$SCS/,,/; JGD07/
	TST	VTFLAG		; IF>0, TI: IS VT:,SKIP PRINTING EXIT MESSAGE
	BEQ	8$		; IF EQ, PRINT EXIT MESSAGES
	BR	BYEXIT		; AND EXIT
8$:	MOV	TIMBUF+6,R1	; GET HOUR
-/15$:/,.+2,/; JGD07/
101$:	MOV	#MSG1+1,R0	; GET BUFFER FOR TIME
	CALL	DATTIM		; CONVERT TIME TO ASCII
	MOV	UCB,R3		; GET TI UCB ADDRESS
-/CALL	BYEERR/,/EXIT$S/,/; JGD07/
11$:	CALL	BYEERR		; ISSUE IT
12$:	MOV	UCB,R0		; GET TI UCB ADDRESS
-,,/; JGD04/
	BIT	#100,U.PRV1(R0)	; 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 ANYWAY
	BNE	15$		; IF NE, YES , DON'T SEND A MESSAGE TO ...UPD
	MOV	#UPDAT,R5	; MOVE IN COMMAND TO UPDATE THE USERS ACCOUNT FI
	CALL	GIVMCR		; GIVE IT TO MCR
15$:	MOV	UCB,R0		; GET TI UCB ADDRESS
;	ROR	(SP)+		; NEED TO WAIT ON CO:?
;	BCS	20$		; IF CS NO
;	CALL	$COWAT		; YES--WAIT FOR IT
20$:
BYEXIT:	MOV	UCB,R0		; GET TI: UCB ADDRESS
25$:	BIS	#U2.LOG,U.CW2(R0) ; LOG TERMINAL OFF
-,,/; JGD13/
	.IF DF	T$$CPU
	CLR	U.ACN(R0)	; RESET ACCOUNT NUMBER, SO IT CAN COUNT ILLEGAL LOGONS
	.ENDC			; .ENDC T$$CPU
-,,/; JGD04/
	CLR	U.UIC(R0)	; ZERO DEFAULT UIC
	CLR	U.LUIC(R0)	; ZERO LOGIN UIC
	MOV	$TKTCB,R1	; GET OUR TCB ADDRESS
	BIC	#T3.MCR,T.ST3(R1) ; INHIBIT PROMPT FROM MCR
BYEXT:				; REF LABLE
	TST 	VTFLAG		; IS THIS A VT:?
	BNE	30$		; IF NE YES
	MRKT$S	,#2,#2,#30$	; DON'T WAIT FOREVER FOR THE UNSLAVE QIO
	DIR$	#SLVDPB		; ATTEMPT QIO$ TO UNSLAVE TI:
30$:	MOV	UCB,R0		; GET UCB ADR
	BIC	#U2.SLV!U2.AT.,U.CW2(R0) ; RESET TERMINAL STATUS DIRECTLY IN CASE QIO FAILS
	TST	VTFLAG		; IS THIS A VIRTUAL TERMINAL
	BEQ	XIT		; NO, ALL DONE
	MOV	$TKTCB,R1	; GET OUR TCB ADDRESS
	BIC	#T3.MCR,T.ST3(R1) ; INHIBIT PROMPT FROM MCR
	MOV	#IO.WVB,ERRDPB+2 ; SET TO WRITE
	MOV	#MSG1B,R0	; YES, MUST SEND VT: A '$EOJ'
	CLR	VTFLAG		; LET BYEERR PRINT NOW
	CALL	BYEERR		; PRINT '>'
XIT:	EXIT$S			; ALL DONE EXIT
-/.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
-,,/; JGD14/
	MOV	#1,R2		; KEEP LEADING ZEROS
	MOV	CNCTIM,R1	; CONVERT 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 NONPRIVLEDGED
				; 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 ONTO OTHER TERMINAL ALSO
				; OR ACCOUNT FILE  GOT SCRAMBLED
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			; BE SURE TO 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
	CMPB	(R0),R1		; IF DATES NOT EQUAL, DON'T ADD TIME TO ACNT
	BNE	10$		; NOT EQUAL SO ONLY ZERO TERMINAL NUMBER
				; AND LOG OFF
	MOVB	TIMBUF+6,R1	; GET HOUR AT WHICH TERMINAL LOGGED OFF
	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 THE 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
	.END	$BYEEP		;
/