.TITLE	HELLO - MCR LOGON COMMAND
	.IDENT	"01.8X"
;
; COPYRIGHT (C) 1976
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A
; SINGLE COMPUTER SYSTEM AND MAY  BE  COPIED   ONLY  WITH  THE
; INCLUSION OF THE ABOVE COPYRIGHT NOTICE.  THIS SOFTWARE,  OR
; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED  OR  OTHERWISE
; MADE AVAILABLE TO ANY OTHER PERSON   EXCEPT FOR  USE ON SUCH
; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE  TERMS.  TITLE
; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL  TIMES  REMAIN
; IN DEC.
;
; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL
; EQUIPMENT CORPORATION.
;
; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF
; ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DEC.
;         
;
; VERSION:	01.8X
; BY:		H. LEV
; DATE:		7/15/75
;
; MODIFIED:	
;
;	EB033 --  TREAT A GROUP NUMBER OF 10 AS PRIVILEGED
;		  AND PREVENT THE ABORTING OF HEL BY A PARTIALLY
;		  LOGGED IN USER.(23-MAR-77)
;
;	EB056 --  ALLOW LOGIN.TXT LINES OF 132 CHARACTERS(29-MAR-77).
;
;	BLS024 -  PREVENT CONTROL-C BY PARTIALLY LOGGED-IN USER(11-AUG-77).
;
;	  JGD --  MODIFIED HELP COMMAND TO ALLOW DISPLAYING OF
;		  A TEXT FILE  NAME.TXT WHEN THE COMMAND 
;		  HELP "NAME" IS GIVEN.
;
;	JGD01 --  STORE TERMINAL NUMBER IN RSX11.SYS AT LOGON
;		  CHECK TO BE SURE NOT LOGGED ONTO OTHER TERMINAL,
;		  PUT PROTECTION WORD INTO TI:'S UCB(IN U.CW3)
;
;	JGD02 --  PRINT TEXT FILE NOLOG.TXT IF LOGONS DISABLED
;
;	JGD03 -- IF BIT 2 IN THE TERMINAL PRIVLEGE MASK IS SET
;		 (IN U2.CW3), THEN RUN XXX AS HELLO EXITS.
;		 ALSO IF BIT 2 IS SET THE PRINTING OF LOGIN.TXT
;		 IS SUPRESSED.  FINALLY, IF THE REQUESTED TASK
;		 CAN NOT BE RUN(ERROR RETURN), A WARNING MESSAGE
;		 IS PRINTED AND THE TERMINAL IS LOGGED OFF.
;
;	JGD04 -- WARN THE USER THAT THE NUMBER OF DISK BLOCKS HE HAS IN USE
;		 EXCEEDS THE NUMBER OF BLOCKS ALLOCATED TO HIM.
;		 IF BIT 15  IN THE PRIVLEGE MASK IS SET THE TERMINAL 
;		 AND USER IS LOGGED ON AS PRIVLEGED REGARDLESS OF 
;		 THE TERMINAL UIC
;
;	JGD05 -- IF BIT 4 IN THE TERMINAL PRIVLEGE MASK IS SET, LOG THE
;		 TERMINAL ON AS SLAVED.
;
	.MCALL	QIO$,DIR$,GMCR$,WTSE$S,OPEN$U,CLOSE$,READ$
	.MCALL	EXIT$S,GTIM$S,MRKT$,GET$,OPEN$R,FINIT$
	.MCALL	GLUN$S,RQST$S								; JGD01
;
; CONSTANTS
;
LUN1	=	1	; TI LUN
LUN2	=	2	; ACCOUNT FILE LUN
EFN1	=	1	; EVENT FLAG FOR ALL I/O
EFN2    =	2	; EVENT FLAG FOR MARKTIME					; JGD03
 
;
;
; LOCAL DATA
;
	.NLIST	BEX
TSK:	.ASCII	/      /								; JGD03
TSK1:	.BLKW	2
BYE:	.RAD50	/...BYE/								; JGD03
ASSN:	.ASCIZ	%ASN XXNN:=SY:/LOGIN%<15>
ACCT:	.ASCIZ	/ACCOUNT OR NAME: /
PSWD:	.ASCIZ	/PASSWORD: /
MS1:	.ASCII	<15><12>%	RSX-11M BL%
MS1A:	.ASCIZ	%     MULTI-USER SYSTEM%<12>
MS2:	.BLKB	16.
	.ASCII	/LOGGED ON TERMINAL /
MS2A:	.ASCIZ	/XXXX:/
MS3:	.ASCIZ	/GOOD MORNING/
MS4:	.ASCIZ	/GOOD AFTERNOON/
MS5:	.ASCIZ	/GOOD EVENING/
MS6:	.ASCIZ	/GOOD NIGHT, WHAT ARE YOU DOING UP AT THIS HOUR?/
MS7:	.ASCIZ	<15><12>/HEL -- LOGGED ONTO OTHER TERMINAL ALSO/<15><12><7>	; JGD01
MS8:	.ASCII	<15><12>/>> YOU ARE USING MORE THAN YOUR ALLOCATED DISK SPACE/	; JGD04
	.ASCII	<15><12>/>> PLEASE CLEAN UP YOUR UIC OR REQUEST MORE STORAGE SPACE/; JGD04
	.ASCIZ	<15><12><7>							; JGD04
;
; ERROR MESSAGES
;
ER1:	.ASCIZ	<15>/HEL -- SYNTAX ERROR/
ER2:	.ASCIZ	<15>/HEL -- INVALID ACCOUNT/
ER3:	.ASCIZ	<15>/HEL -- TERMINAL ALLOCATED TO OTHER USER/
ER4:	.ASCIZ	<15>/HEL -- COMMAND INPUT ERROR/
ER5:	.ASCIZ	<15>/HEL -- OTHER USER LOGGED ON/
ER6:	.ASCIZ	<15>/HEL -- ACCOUNT FILE OPEN FAILURE/
ER7:	.ASCIZ	<15>/HEL -- LOGINS ARE DISABLED/
ER8:	.ASCII	<15>/HEL -- MESSAGE FILE ERROR /
ER8NUM:	.ASCIZ	/-NNNNN/
ER9:	.ASCIZ	<15>/HEL -- MULTIPLE LOGINS ILLEGAL/				; JGD01
ER10:	.ASCIZ	<15>/HEL -- REQUESTED TASK NOT FOUND -- LOGGING OFF/		; JGD03
	.LIST	BEX
 
	.EVEN
PSWDBF:	.WORD	0		; ADDRESS OF PASSWORD BUFFER
GRP:	.WORD	0		; GROUP CODE
MEM:	.WORD	0		; MEMBER CODE
	.BLKB	4		;
UIC:	.ASCII	/000000/	; UIC
NAME:	.BLKB	14.		; LAST NAME AREA IF NAME SPECIFIED VS ACCOUNT
	.EVEN
 
ODPB:	QIO$	IO.WVB,LUN1,EFN1,,,,<BUF,0,40> ; OUTPUT DPB
IDPB:	QIO$	IO.RVB,LUN1,EFN1,,IOSB,,<BUF,1,0> ; INPUT DPB
FDPB:	QIO$	IO.RVB,LUN2,EFN1,,IOSB,,<$ACTBF,$BFLEN,,,1>
IOSB:	.BLKW	2		; I/O STATUS BLOCK
 
;
; LOGIN MESSAGE FILE DESCRIPTOR
;
MSGDSP:	.WORD	4		;
	.WORD	DEVNAM		;
	.WORD	5		;
	.WORD	DIRNAM		;
	.WORD	9.		;
	.WORD	FILNAM		;
 
NLGDSP:	.WORD	4.		;						; JGD02
	.WORD	DEVNAM		;						; JGD02
	.WORD	5.		;						; JGD02
	.WORD	DIRNAM		;						; JGD02
	.WORD	9.		;						; JGD02
	.WORD	NLGNAM		;						; JGD02
 
HLPDSP:	.WORD	4.		;
	.WORD	DEVNAM		;
	.WORD	5.		;
	.WORD	DIRNAM		;
CHRNUM:	.WORD	13.								;**JGD
	.WORD	HLPNAM		;
DEVNAM:	.ASCII	/SY0:/		;
DIRNAM:	.ASCII	/[1,2]/
FILNAM:	.ASCII	/LOGIN.TXT/	;
HLPNAM:	.ASCII	/             /							;**JGD
TYPNAM:	.ASCII	/.TXT/								;**JGD
NLGNAM:	.ASCII	/NOLOG.TXT/							; JGD02
MONTH:	.ASCII	/JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC/
	.EVEN
 
FILOPN:	.WORD	0		; FILE OPEN FLAG 0-NO, 1-YES
ENTRY:	.WORD	0		; ADDRESS OF ACCOUNT ENTRY
OPNERR:	.WORD	0		; ACCOUNT FILE OPEN ERROR FLAG
NAMFLG:	.WORD	0		; NAME FLAG 0-ACCOUNT, 1-NAME
TXTFLG:	.WORD	0		; PRINT LOGIN.TXT FLAG 0=YES, 1=NO
BLKFLG:	.WORD	0		; DISPLAY TOO MANY BLOCKS IN USE MESSAGE(IF SET); JGD04
 
INDEX:	.WORD	0		; TEMP STORAGE					; JGD
BYEFLG:	.WORD	0		; IF =1, LOG OFF ON EXIT. USED ONLY IF A TASK	; JGD03
				; REQUESTED TO RUN CAN NOT BE FOUND		; JGD03
TIMBUF:	.BLKW	8.		; TIME BUFFER
GLNBUF:	.BLKW	6.		; BUFFER FOR GET LUN DIRECTIVE  **JGD001
 
GMCR:	GMCR$
BUF	=	GMCR+2		; BUFFER FOR TI I/O
 
	.BLKB	132.-80.+2	; EXPAND BUFFER FOR 132. CHARACTERS
 
MKT:	MRKT$	EFN2,100,1		; WAIT ONE HUNDRED TICS		; EB033	; JGD03
				; SLP PATCH MADE NO PROVISION FOR CLOCKS	; JGD03
				; WITH OTHER THAN 60 TICS/SECOND		; JGD03
	.SBTTL	MAIN LINE CODE
;+
; $HELEP - HELLO AND HELP COMMAND PROCESSOR
;
; FORMAT OF COMMAND
;
;	HELLO [GRP,MEM]
;	HELLO [GRP/MEM]  - DON'T PRINT LOGIN.TXT FILE
;	HELLO GRP,MEM
;	HELLO GRP/MEM - DON'T PRINT LOGIN.TXT
;	HELLO [GRP,MEM]/PASSWORD
;	HELLO NAME
;	HELLO NAME/PASSWORD
;
;	HELP - PRINT HELP.TXT FILE
;	HELP <TOPIC> - PRINT TOPIC.TXT FILE					**JGD
;
;	WHERE:
;		[GRP,MEM] IS UIC TYPE OF ACCOUNT
;		PASSWORD IS OPTIONAL PASSWORD, IF NOT SPECIFIED,
;			TASK WILL PROMPT FOR IT
;		NAME - USER NAME
;		TOPIC - ANY SUBJECT A USER MIGHT NEED HELP				**JGD
;			WITH, IE EDI, PIP, BASIC, ETC.					**JGD
;-
;
; GET COMMAND LINE
;
$HELEP:	DIR$	#GMCR		; GET MCR COMMAND LINE
	BCC	3$		;IF CC, OK
	CALL	ERR4		; ERROR, NONE THERE
	JMP	EXIT		;
; 
; ATTACH TO TI:
;
3$:	MOV	#ODPB,R4	; GET OUTPUT DPB ADDRESS
	MOV	#IO.ATT,2(R4)	; ATTACH
	CALL	QIO		; TO TI:
	MOV	#IO.WVB,2(R4)	; RESET FUNCTION CODE
	MOV	#44,Q.IOPL+4(R4) ; NO, SET TO PROMPT MODE
	BIT	#FE.MUP,$FMASK	; MULTI-USER PROTECTION SUPPORTED?
	BNE	4$		; YES
	JMP	EXIT		; NO, JUST EXIT
;
; IF COMMAND IS HELP PRINT HELP FILE
;
4$:	CMPB	BUF+3,#'P	; IS THIS HELP COMMAND?
	BNE	5$		; NO
	MOV	#HLPNAM,INDEX	;INDEX IS THE ADRESS OF THE NAME BUFFER			**JGD
	MOV	#BUF,R0		;GET BUFFER ADRESS FOR USE WITH GNBLK			**JGD
	CLR	CHRNUM		;CLEAR THE CHARACTER COUNTER				**JGD
425$:	CALL	$GNBLK		;GET THE NEXT NON BLANK CHARACTER IN THE BUFFER		**JGD
	BCS	427$		;WE MOVED PAST HELP INTO AN END OF LINE SO DISPLAY	**JGD
				;HELP.TXT						**JGD
	TST	R1		;ANY BLANKS SEEN YET-WE MUST PASS OVER HELP FIRST	**JGD
	BEQ	425$		;NO,GET ANOTHER NON BLANK,STILL NOT PAST HELP		**JGD
	BR	430$		;JUMP OVER UNNEEDED CODE				**JGD
427$:	MOV	#BUF,R0		;THE COMMAND IS HELP, SO PUT COMMAND IN AS FILE NAME	**JGD
	CALL	$GNBLK		;GET THE H IN HELP					**JGD
430$:	MOVB	R2,@INDEX	;WE'RE PAST HELP, SO PUT FIRST NON BLANK CHARACTER	**JGD
				;INTO AREA ESERVED IN HLPNAM				**JGD
	INC	CHRNUM		;ADD ONE TO CHARACTER COUNT				**JGD
	INC	INDEX		;UPDATE ADRESS						**JGD
	CALL	$GNBLK		;GET ANOTHER CHARACTER					**JGD
	BCS	460$		;END OF LINE FOUND SO PRINT HELP FILE			**JGD
	CMP	#9.,CHRNUM	;BE CAREFULL THAT NO MORE THAN 9 CHARACTERS		**JGD
	BEQ	460$		;ARE PART OF THE NAME PART OF FILESPECIFIER		**JGD
	BR	430$		;NOT FINISHED, GET ANOTHER CHARACTER			**JGD
460$:	MOVB	TYPNAM,@INDEX 	;NOW MOVE IN THE NAME .TXT	.			**JGD
	INC	INDEX		;UPDATE ADRESS						**JGD
	MOVB	TYPNAM+1,@INDEX ; 				T			**JGD
	INC 	INDEX		;UPDATE ADRESS						**JGD
	MOVB	TYPNAM+2,@INDEX ; 				X			**JGD
	INC	INDEX		;UPDATE ADRESS						**JGD
	MOVB	TYPNAM+3,@INDEX ; 				T			**JGD
	ADD	#4.,CHRNUM	;UPDATE CHARACTER COUNTER				**JGD
	MOV	#HLPDSP,R1	; YES, GET FILE DESCRIPTOR BLOCK
	CALL	DSPFIL		; DISPLAY FILE
495$:	JMP	EXIT		; DONE
;
; CHECK IF OKAY TO LOGIN USER
;
5$:	MOV	$TKTCB,R0	; GET OUR TCB ADDRESS
	MOV	T.UCB(R0),R1	; GET TI UCB ADDRESS
	BIT	#U2.LOG,U.CW2(R1) ; IS A USER ALREADY LOGGED ON?
	BNE	7$		; NO
	CALL	ERR5		; YES, ERROR
	JMP	EXIT		;
7$:	CLR	FILOPN		; SET FILE NOT OPEN
	CLR	ENTRY		; ZERO ENTRY
	CLR	TXTFLG		; SET TO PRINT LOGIN.TXT
	BIT	#FE.NLG,$FMASK	; ARE LOGINS DISABLED?
	BEQ	701$		; NO
	MOV	#ER7,R0		; GET SET TO PRINT WARNING MESSAGE		; JGD02
	MOV	#40,ODPB+Q.IOPL+4 ; SET NORMAL CARRIAGE RETURN			; JGD02
	CALL	WRIT		; WRITE OUT THE LOGON DISABLED MESSAGE		; JGD02
	MOV	#NLGDSP,R1	; GET READY TO PRINT NOLOG.TXT			; JGD02
	CALL	DSPFIL		; PRINT IT					; JGD02
	MOV	#ODPB,R4	; GET OUTPUT DPB ADRESS				; JGD02
	MOV	#IO.DET,2(R4)	; SET FUNCTION TO DETACH			; JGD02
	CALL	QIO		; DETACH TERMINAL				; JGD02
	JMP	ERROR1		; AND EXIT					; JGD02
701$:	TST	U.OWN(R1)	; IS TERMINAL ALLOCATED?
	BEQ	8$		; NO
	JMP	ERR3		; YES, ERROR
8$:	MOV	#BUF,R0		; GET BUFFER ADDRESS
;
; GET ACCOUNT
;
10$:	CALL	$GNBLK		; GET NEXT NON-BLANK
	BCS	20$		; EOL
	TST	R1		; ANY BLANKS SEEN?
	BEQ	10$		; NO, CONTINUE SCAN
	BR	30$		; YES, GET ACCOUNT NUMBER
20$:	MOV	#ACCT,R0	; MUST PROMPT FOR ACCOUNT NUMBER
	CALL	WRIT		; PROMPT FOR ACCOUNT
	MOV	#BUF,R0		; POINT TO INPUT BUFFER
	MOV	#20.,R1		; SET COUNT OF CHARACTERS
	CALL	READ		; READ IN ACCOUNT NUMBER
	BR	40$		;
30$:	DEC	R0		; BACK UP BUFFER POINTER TO FIRST DIGIT
40$:	CALL	ACCNT		; GET ACCOUNT NUMBER
	BCC	41$		; OKAY
	JMP	ERR1		; NO, SYNTAX ERROR
;
; GET PASSWORD
;
41$:	CMPB	-1(R0),#'/	; PASSWORD COMMING?
	BNE	42$		; NO, SYNTAX ERROR
	MOV	R0,PSWDBF	; SAVE PASSWORD ADDRESS
	BR	46$		;
42$:	MOV	#PSWD,R0	; SET TO PROMPT FOR PASSWORD
	CALL	WRIT		; WRITE OUT PROMPT
	MOV	#BUF,R0		; GET INPUT BUFFER ADDRESS
	MOV	#6.,R1		; SET COUNT OF BYTES TO ZERO
	MOV	R0,R2		; COPY ADDRESS
45$:	CLRB	(R2)+		; ZERO IT OUT
	DEC	R1		; DONE ?
	BGT	45$		; NO, LOOP
	MOV	#BUF,R0		; POINT TO BUFFER
	MOV	#7.,R1		; SET COUNT OF CHARACTERS
	CALL	READAL		; READ PASSWORD
	BCC	451$		; OKAY
	JMP	ERR1		; SYNTAX ERROR
451$:	MOV	#BUF,PSWDBF	; SAVE PASSWORD BUFFER ADDRESS
;
; OPEN ACCOUNT FILE
;
46$:
	CALL	$SWSTK,461$	; SWITCH TO SYSTEM STATE			;BLS024
	MOV	$TKTCB,R1	; GET MY TEC ADRESS				;BLS024
	MOV	T.UCB(R1),R1	; PICKUP UCB ADDRESS				;BLS024
	BIS	#U2.SLV,U.CW2(R1) ; SET TERMINAL AS SLAVED			;BLS024
	RETURN			; RETURN TO USER STATE				;BLS024
461$:				; REF LABEL					;BLS024
	CLR	OPNERR		; SET NO OPEN ERROR
47$:	CALL	OPEN		; OPEN ACCOUNT FILE
	BCC	48$		; OPEN SUCCESSFUL
	CMP	OPNERR,#5	; FIVE FAILURES?
	BLT	472$		; NO
471$:	JMP	ERR6		; YES
472$:	DIR$	#MKT		; NO, WAIT ONE SECONDS
	BCS	471$		; ERROR
	WTSE$S	#1		; WAIT FOR TIME 
	INC	OPNERR		; INCREMENT TIME TRIED
	BR	47$		; TRY AGAIN
;
; SEARCH FOR ACCOUNT IN FILE
;
48$:	CALL	SEARCH		; SEARCH FOR ACCOUNT NUMBER
	BCC	481$		; OKAY
	JMP	ERR2		; ACCOUNT NOT FOUND
;
; LOG IN USER
;
481$:	MOV	ENTRY,R0	; GET ADDRESS OF ENTRY
	ADD	#A.GRP,R0	; INT TO GROUP CODE
	MOV	#UIC,R1		; GET ADDRESS OF UIC
	MOV	#6.,R2		; SET COUNT OF BYTES TO MOVE
482$:	MOVB	(R0)+,(R1)+	; MOVE THEM
	DEC	R2		; DONE?
	BGT	482$		; NO, LOOP
	MOV	#UIC+3,R0	; GET ADDRESS OF MEMBER
	CLRB	3(R0)		; SET END OF MEMBER
	CALL	$COTB		; CONVERT TO BINARY
	MOVB	R1,MEM		; STORE IT
	MOV	#UIC,R0		; GET GROUP CODE
	CLRB	3(R0)		; SET OF GROUP
	CALL	$COTB		; CONVERT TO BINARY
	MOVB	R1,GRP		; STORE IT
	MOV	ENTRY,R0	; POINT TO ADDRESS OF ACCOUNT ENTRY			; JGD04
	ADD	#A.UBLK,R0	; POINT TO USED BLOCKS ENTRY				; JGD04
	MOV	(R0),R1		; SAVE USED BLOCKS IN R1				; JGD04
	MOV	ENTRY,R0	; POINT TO ENTRY ADDRESS OF ACCOUNT			; JGD04
	ADD	#A.ABLK,R0	; POINT TO ALLOWED BLOCKS ENTRY				; JGD04
	MOV	(R0),R2		; ALLOCATED BLOCKS IN R2				; JGD04
	CMP	R2,R1		; IS ALLOWED BLOCKS>=USED BLOCKS			; JGD04
	BGE	485$		; YES, SKIP SETTING WARNING FLAG			; JGD04
	INC	BLKFLG		; NO, SET FLAG						; JGD04
485$:	MOV	ENTRY,R0	; GET ADDRESS OF ACCOUNT ENTRY AGAIN			; JGD01
	ADD	#A.PRIV,R0	; POINT TO ADDRESS OF PRIVLEDGE MASK WORD		; JGD01
	MOV	(R0),INDEX	; SAVE THE MASK WORD					; JGD01
	BIT	#4,INDEX	; CHECK TO SEE IF TASK TO BE RUN ON EXIT		; JGD04
	BEQ	490$		; NO, ITS OK TO PRINT LOGIN.TXT				; JGD04
	INC	TXTFLG		; YES, DON'T PRINT LOGIN.TXT				; JGD03
	MOV	ENTRY,R0	; GET ADDRESS OF ACCOUNT ENTRY				; JGD03
	ADD	#A.TNAM,R0	; POINT TO TASK NAME TO RUN IF ANY			; JGD03
	MOVB	(R0)+,TSK	; INSERT FIRST LETTER INTO TASK NAME			; JGD03
	MOVB	(R0)+,TSK+1	; INSERT SECOND LETTER INTO TASK NAME			; JGD03
	MOVB	(R0)+,TSK+2	; INSERT THIRD LETTER INTO RUN COMMAND			; JGD03
	MOVB	(R0)+,TSK+3	; INSERT FOURTH LETTER INTO TASK NAME       		; JGD03
	MOVB	(R0)+,TSK+4	; INSERT FIFTH LETTER INTO TASK NAME        		; JGD03
	MOVB	(R0),TSK+5	; INSERT LAST LETTER INTO TASK NAME         		; JGD03
490$:				; BRANCHING LABEL					; JGD03
	CALL	$SWSTK,60$	; SWITCH TO SYSTEM STACK
	MOV	$TKTCB,R0	; GET TCB ADDRESS
	MOV	T.UCB(R0),R5	; GET TI UCB ADDRESS
	BIS	#U2.PRV,U.CW2(R5) ; SET TERMINAL A PRIVILEGED			 	; EB033
				; (TEMPORARY)						; EB033
	BIC	#U2.LOG,U.CW2(R5) ; SET TERMINAL LOGGED ON
	MOVB	GRP,U.UIC+1(R5)	; STORE GROUP
	MOVB	MEM,U.UIC(R5)	; STORE MEMBER
	MOV	U.UIC(R5),U.LUIC(R5) ; SET LOGIN PROTECTION UIC
	MOV	INDEX,U.CW3(R5)	; INSERT THE PROTECTION MASK INTO THE UNUSED		; JGD01
				; CHARACTERISTICS WORD U.CW3 IN TERMINAL UCB		; JGD01
	MOV	U.LUIC(R5),INDEX ; SAVE THE PROTECTION UIC FOR LATER			; JGD01
50$:	RETURN			; RETURN TO USER STATE
60$:	CALL	LOGON		; LOG IN ACCOUNT FILE
;
; SET UP DEVICE TO BE USED FOR SY:
;
	MOV	ENTRY,R0	; GET ADDRESS OF ACCOUNT ENTRY
	ADD	#A.SYDV,R0	; POINT TO DEFAULT SYSTEM DEVICE
	MOV	(R0)+,ASSN+4	; STORE IT IN ASSIGN COMMAND
	MOV	(R0)+,ASSN+6	;
	CLOSE$	#$ACTFL		; CLOSE ACCOUNT FILE
	CLR	FILOPN		; SET FILE CLOSED
;
; PRINT OUT SYSTEM ID AND TI: TERMINAL NUMBER
;
	MOV	#40,ODPB+Q.IOPL+4 ; SET LF BEFORE, CR AFTER
	MOV	#MS1,R0		; SET MESSAGE ADDRESS
	MOV	#MS1A,R2	; GET ADDRESS OF BASE LEVEL BUFFER
	MOV	#$SYSID,R1	; GET ADDRESS OF BASE LEVEL
	MOVB	(R1)+,(R2)+	; MOVE IN BASE LEVEL
	MOVB	(R1)+,(R2)+	;
	MOVB	(R1)+,(R2)+	;
	MOVB	(R1)+,(R2)+	;
	CALL	WRIT		; WRITE IT OUT
	MOVB	TIMBUF+6,R1	; GET HOUR OF THE DAY
	MOV	#MS6,R0		; DEFAULT TO 0-6AM
	CMP	R1,#6.		; IS IT 0-6AM?
	BLT	70$		; YES
	MOV	#MS3,R0		; NO, DEFAULT TO 6-12AM
	CMP	R1,#12.		; IS IT 6-12AM?
	BLT	70$		; YES
	MOV	#MS4,R0		; NO, DEFAULT  TO 0-6PM
	CMP	R1,#18.		; IS IT 0-6PM?
	BLT	70$		; YES
	MOV	#MS5,R0		; NO, DEFAULT TO 6-12PM
70$:	CALL	WRIT		; PRINT OUT MESSAGE
	MOV	#MS2,R0		; GET ADDRESS FOR DATE AND TIME
	CALL	DATTIM		; GET DATE AND TIME
	MOV	$TKTCB,R0	; GET TCB ADDRESS
	MOV	T.UCB(R0),R3	; GET TI UCB ADDRESS
	MOV	#MS2A,R0	; POINT TO AREA FOR TERMINAL NAME
	CALL	$FMTDV		; FORMAT DEVICE NAME
	MOVB	#15,(R0)+	; PUT IN CR
	MOVB	#12,(R0)+	; AND LF
	CLRB	(R0)		; SET END OF LINE
	MOV	#MS2,R0		; POINT TO BUFFER
	CALL	WRIT		; WRITE IT OUT
	TST	BLKFLG		; IS THE USER USING TOO MANY BLOCKS	; JGD04
	BEQ	100$		; NO , SKIP OVER				; JGD04
	MOV	#MS8,R0		; YES, PRINT WARNING MESSAGE			; JGD04
	CALL	WRIT		; AT TERMINAL					; JGD04
;
; PRINT OUT LOGIN MESSAGE FILE
;
100$:	TST	TXTFLG		; PRINT OUT LOGIN.TXT FILE?
	BNE	120$		; NO
	MOV	#MSGDSP,R1	; GET ADDRESS OF LOGIN.TXT FILE NAME
	CALL	DSPFIL		; DISPLAY FILE
;
; ASSIGN CORRECT DEVICE TO SY:
;
120$:	CALL	$SWSTK,150$	; SWITCH TO SYSTEM STATE
	MOV	#84.,R1		; SET LENGTH OF AN MCR BUFFER
	CALL	$ALOCB		; GET A BUFFER
	BCS	140$		; COULDN'T GET ONE
	MOV	$TKTCB,R1	; GET OUR TCB ADDRESS
	MOV	T.UCB(R1),R2	; GET TI UCB ADDRESS
	MOV	R2,2(R0)	; SET TI UCB ADDRESS
	BIS	#U2.AT.,U.CW2(R2) ; SET MCR SYNCHRONIZATION FLAG
	MOV	R0,R1		; COPY BUFFER ADDRESS
	CMP	(R1)+,(R1)+	; SKIP LINK AND UCB ADDRESS
	MOV	#ASSN,R2	; GET ADDRESS OF ASSIGN COMMAND
130$:	MOVB	(R2)+,(R1)+	; MOVE MESSAGE INTO BUFFER
	BNE	130$		; LOOP UNTIL ALL MOVED IN
	MOV	R0,R1		; GET ADDRESS OF BUFFER
	CALL	$QMCRL		; LINK INTO MCR LIST
140$:	RETURN			; RETURN TO USER STATE
150$:	MOV	#10,MKT+M.KTMG	; CHANGE WAIT MAGNITUDE TO 10 TICS	; EB033 ; JGD03
152$:	CALL	RUNCK		; CHECK OUT TO SEE IF RUN TASK ON EXIT		; JGD03
	BCC	155$		; IF CARRY IS CLEAR CONTINUE			; JGD03
	DIR$	#MKT		; IF CARRY SET, WAIT ONE THNTH SECOND		; JGD03
	BR	152$		; AND TRY AGAIN					; JGD03
155$:	MOV	#ODPB,R4	; GET TERMINAL DPB ADDRESS			; JGD03
	MOV	#IO.DET,2(R4)	; SET TO DETACH TERMINAL
	CALL	QIO		; DETACH IT
	MOV	$TKTCB,R0	; GET OUR TCB ADDRESS
	MOV	T.UCB(R0),R1	; GET TI UCB ADDRESS
;	MOV	#10,MKT+M.KTMG	 ; CHANGE WAIT MAGNITUDE TO 10 TICS		; EB033
160$:	BIT	#U2.AT.,U.CW2(R1) ; ASN DONE?
	BEQ	170$		; YES
	DIR$	#MKT		; NO, WAIT ONE TENTH SECOND		; EB033 ; JGD03
	BCS	175$		;
	WTSE$S	#1		; WAIT
	BCS	175$		;
	BR	160$		; LOOP
170$:	CMPB	U.LUIC+1(R1),#10 ; IS UIC PRIVILEGED?
	BLOS	180$		; YES						; EB038
	BIT	#100000,U.CW3(R1) ; IS BIT 15 SET, IF YES SET TI: PRIVLEGED	; JGD03
	BNE	180$		; YES, TI: SHOULB BE PRIVLEGED			; JGD03
175$:	BIC	#U2.PRV,U.CW2(R1) ; NO, CLEAR PRIV FLAG
180$:	BIC	#T3.MCR,T.ST3(R0) ; INHIBIT MCR PROMPT
	BIT	#20,U.CW3(R1)	; SHOULD TERMINAL BE LEFT SLAVED AT LOGON	; JGD05
	BNE	182$		; YES, LEAVE IT SLAVED				; JGD05
	BIC	#U2.SLV,U.CW2(R1) ; ALLOW TERMINAL INPUT AGAIN			; EB033
182$:	TST	BYEFLG		; IF A REQUESTED TASK WAS NOT INSTALLED, THEN	; JGD03
				; LOG OFF					; JGD03
	BEQ	190$		; A TASK IF REQUESTED WAS INSTALLED		; JGD03
	RQST$S	#BYE		; REQUESTED TASK NOT FOUND, LOG OFF		; JGD03
	BIS	#U2.SLV,U.CW2(R1) ; SET TI SLAVE UNTIL BYE CAN RUN		; JGD03
190$:	JMP	EXIT		;						; JGD03
RUNCK:	MOV	$TKTCB,R1	; GET OUR  TCB ADRESS				; JGD03
	CLC			; CLEAR CARRY FLAG EACH PASS THROUGH		; JGD03
	MOV	T.UCB(R1),R2	; GET TI UCB ADDRESS				; JGD03
	BIT	#4,U.CW3(R2)	; IS RUN TASK ON EXIT BIT SET			; JGD03
	BNE	5$		; YES, BRANCH					; JGD03
	RETURN			; NO, THEN RETURN				; JGD03
5$:	BIT	#U2.AT.,U.CW2(R2) ; IS MCR STILL BUSY ?				; JGD03
	BEQ	6$		; NO ,THEN CONVERT TSK TO RAD50			; JGD03
	SEC			; YES SET CARRY AND RETURN			; JGD03
	RETURN			;						; JGD03
6$:	MOV	#TSK,R0		; MOVE ADRESS OF TASK NAME INTO R0		; JGD03
;	CLR	R1		; R1 =0 -> PERIOD A TERMINATOR			; JGD03
	INC	R1		; R1 NE 0 -> PERIOD A R50 CHARACTER		; JGD03
				; AFTER SETTING UP R0, AND R1 WE CAN USE THE	; JGD03
				; SUPPLIED ASCII TO RAD50 CONVERSION ROUTINE	; JGD03
	CALL	$CAT5		; CALL RAD50 SUBROUTINE				; JGD03
	MOV	R1,TSK1		; R1 HAS RAD50 TASK NAME, SO PUT IT IN TSK1	; JGD03
	CLR	R1		; R1 =0 -> PERIOD A TERMINATOR			; JGD03
	MOV	#TSK+3,R0	; GET ADDRESS OF 2ND HALF OF TASK NAME		; JGD03
	CALL	$CAT5		; CALL RAD50 SUBROUTINE				; JGD03
	MOV	R1,TSK1+2	; MOVE SECOND HALF OF RAD50 NAME INTO TSK1	; JGD03
	RQST$S	#TSK1		; REQUEST THE TASK TO RUN 			; JGD03
	BCS	7$		; IF CARRY SET DIRECTIVE IS REJECTED		; JGD03
	RETURN			;						; JGD03
7$:	BR	ERR10		; GO WARN THAT TASK WAS NOT FOUND		; JGD03

	.SBTTL	ERROR PROCESSING
ERR1:	MOV	#ER1,R0		; SYNTAX ERROR
	BR	ERROR		;
ERR2:	MOV	#ER2,R0		; INVALID ACCOUNT
	BR	ERROR		;
ERR3:	MOV	#ER3,R0		; INVALID PASSWORD
	BR	ERROR		;
ERR4:	MOV	#ER4,R0		; COMMAND INPUT ERROR
	BR	ERROUT		; 
ERR5:	MOV	#ER5,R0		; OTHER USER LOGGED ON
	BR	ERROUT		;
ERR6:	MOV	#ER6,R0		; ACCOUNT FILE OPEN ERROR
	BR	ERROR		;
ERR7:	MOV	#ER7,R0		; LOGINS ARE DISABLED
	BR	ERROUT		;						; JGD02
ERR8:	MOV	#ER8,R0		; LOGIN MESSAGE FILE ERROR
	BR	ERROUT		;
ERR9:	MOV	#ER9,R0		; MULTIPLE LOGINS FOR NON PRIVLEDGED USERS	; JGD01
	BR	ERROR		; ARE ILLEGAL					; JGD01
ERR10:	MOV	#ER10,R0	; REQUESTED TASK NOT FOUND			; JGD03
	CALL	WRIT		; WRITE OUT WARNING MESSAGE			; JGD03
	INC	BYEFLG		; SET BYE FLAG SO TERMINAL WILL LOG OFF AT EXIT	; JGD03
	RETURN			; FINISH LOGGING ON				; JGD03
 
 
ERROUT:	MOV	#40,ODPB+Q.IOPL+4 ; SET NORMAL CARRIAGE RETURN
	CALL	WRIT		; WRITE OUT ERROR MESSAGE
	MOV	#ODPB,R4	; GET OUTPUT DPB ADDRESS
	MOV	#IO.DET,2(R4)	; SET FUNCTION TO DETACH
	CALLR	QIO		; DETACH TERMINAL
ERROR:	CALL	ERROUT		; PRINT OUT ERROR MESSAGE
ERROR1:	MOV	$TKTCB,R0	; GET OUR TCB ADDRESS				; JGD02
	MOV	T.UCB(R0),R0	; GET TI UCB ADDRESS
	BIS	#U2.LOG,U.CW2(R0) ; BE SURE HE'S LOGGED OFF
	BIC	#U2.SLV,U.CW2(R0) ; BE SURE TO SET THE TERMINAL NON SLAVE	; JGD03
	CLR	U.LUIC(R0)	; SET LOGIN UIC TO ZERO
	CLR	U.UIC(R0)	; ZERO DEFAULT UIC
EXIT:	TST	FILOPN		; IS ACCOUNT FILE OPEN?
	BEQ	10$		; NO
	CLOSE$	#$ACTFL		; YES, CLOSE IT
10$:	EXIT$S			; AND EXIT

	.SBTTL	SUBROUTINES
;+
; *** - WRIT  -  WRITE OUT BUFFER
;
; INPUT:
;	R0 - MESSAGE ADDRESS
;
;-
WRIT:	MOV	R0,R1		; COPY BUFFER ADDRESS
10$:	TSTB	(R1)+		; END OF MESSAGE?
	BNE	10$		; NO, LOOP TILL END
	SUB	R0,R1		; COMPUTE LENGTH
	MOV	#ODPB,R4	; GET OUTPUT DPB ADDRESS
	MOV	R0,Q.IOPL(R4)	; SET BUFFER ADDRESS
	MOV	R1,Q.IOPL+2(R4) ; SET BUFFER LENGTH
	CALLR	QIO		; WRITE IT OUT
 
 
;+
; *** - READ  - READ A LINE FROM TERMINAL
;
; INPUT:
;	R0 - BUFFER ADDRESS
;	R1 - LENGTH TO READ
;
; OUTPUT:
;	R0 - BUFFER ADDRESS
;-
READ:	MOV	#IDPB,R4	; GET INPUT DPB ADDRESS
	MOV	#IO.RVB,2(R4)	; SET READ VIRTUAL
	MOV	R0,Q.IOPL(R4)	; SET BUFFER ADDRESS
	MOV	R1,Q.IOPL+2(R4) ; SET BUFFER LENGTH
	CALL	QIO		; READ
	MOV	R0,R1		; GET BUFFER ADDRESS
	ADD	IOSB+2,R1	; ADD NUMBER OF CHARACTERS READ
	MOVB	IOSB+1,(R1)	; STORE TERMINATOR
	RETURN			;
 
;+
; *** - READAL  - READ PASS ALL AND NO ECHO
;
; INPUT:
;	R0 - BUFFER ADDRESS
;	R1 - MAX CHARACTERS TO READ
;
; OUTPUT:
;	R0 - UNCHANGED
;-
READAL:	MOV	R0,R2		; GET BUFFER ADDRESS
	MOV	R1,-(SP)	; SAVE BYTES TO READ
	MOV	#IDPB,R4	; GET INPUT DPB ADDRESS
	MOV	#IO.RST!IO.RNE!IO.RLB,2(R4) ; SET READ ALL FUNCTION CODE
10$:	MOV	R1,Q.IOPL+2(R4) ; SET TO READ ONE CHARACTER AT A TIME
	MOV	R2,Q.IOPL(R4)	; SET BUFFER ADDRESS
	CALL	QIO		; READ
	MOVB	IOSB+1,R3	; GET TERMINATING CHARACTER
	ADD	IOSB+2,R2	; BUMP BUFFER POINTER BY CHARACTERS READ
	SUB	IOSB+2,R1	; COMPUTE CHARACTERS LEFT TO READ
	CMPB	R3,#15		; EOL?
	BEQ	30$		; YES
	CMPB	R3,#33		; ESC?
	BEQ	30$		; YES
	CMPB	R3,#177		; RUBOUT?
	BNE	15$		; NO
	CMP	R2,R0		; YES, AT START OF BUFFER?
	BLOS	10$		; YES, NO NEED TO RUBOUT MORE
	CLRB	-(R2)		; NO, RUBOUT CHARACTER
	INC	R1		; SET ROOM FOR MORE
	BR	10$		; AND TRY AGAIN
15$:	CMPB	R3,#25		; CTRL/U?
	BNE	17$		; NO
	MOV	(SP)+,R1	; SET CHARACTERS TO READ
	BR	READAL		; AND LOOP
17$:	SEC			; SET ERROR
	BR	60$		;
30$:	SUB	R0,R2		; COMPUTE CHARACTERS IN BUFFER
	BEQ	55$		; IF ZERO, BLANK LINE
40$:	MOVB	(R0),R1		; GET NEXT CHARACTER
	CMPB	R1,#140		; IS IT UPPER CASE?
	BLOS	50$		; NO
	CMPB	R1,#172		; MAYBE
	BHI	50$		; NO
	BICB	#40,R1		; CONVERT TO LOWER CASE
50$:	MOVB	R1,(R0)+	; STORE CHARACTER
	DEC	R2		; ANY MORE CHARACTERS
	BGT	40$		; YES, LOOP
55$:	MOVB	#15,(R0)	; SET END OF LINE
	CLC			; SET SUCCESS
60$:	MOV	(SP)+,R1	; CLEAR STACK
	RETURN			;
  
;+
; *** - ACCNT  - GET ACCOUNT NUMBER OR USER NAME
;
; INPUT:
;	R0 - BUFFER POINTER
;
; OUTPUT:
;	R0 - UPDATED
;	  GRP - GROUP CODE
;	  MEM - MEMBER CODE
;	  UIC - 6 DIGIT ASCII UIC CODE
;	OR IF NAME SPECIFIED
;	  NAME - 14 CHARACATER NAME OF USER
;	CARRY SET - SYNTAX ERROR
;	CARRY CLEAR - OKAY
;-
ACCNT:	CLR	NAMFLG		; SET NO NAME SPECIFIED
	CALL	$GNBLK		; GET NEXT NON-BLANK
	BCS	40$		; EOL IS ERROR
	CMPB	R2,#'[		; BRACKET IS OPTIONAL
	BNE	1$		; NOT BRACKET
	MOV	R0,-(SP)	; SAVE BUFFER ADDREES
	DEC	(SP)		; BACK IT UP TO BRACKET
	BR	101$		; SKIP
1$:	DEC	R0		; NO, BACKUP TO FIRST CHARACTER
	MOV	R0,-(SP)	; SAVE BUFFER ADDRESS
101$:	CALL	$GTNUM		; GET GROUP CODE
	MOV	R1,GRP		; STORE IT
	BNE	2$		; NON-ZERO IS GOOD
	MOV	(SP)+,R0	; RESTORE BUFFER POINTER
	BR	10$		; TRY IT AS NAME
2$:	TST	(SP)+		; POP OFF OLD BUFFER ADDRESS
	CMP	R1,#377		; VALID GROUP CODE?
	BHI	40$		; NO
	CMPB	R2,#',		; TERMINATOR?
	BEQ	3$		; YES
	CMPB	R2,#'/		; SLASH - DON'T PRINT LOGIN.TXT?
	BNE	40$		; NO, SYNTAX ERROR
	INC	TXTFLG		; YES, SET FLAG TO SUPPRESS LOGIN.TXT
3$:	CALL	$GTNUM		; GET MEMBER CODE
	MOV	R1,MEM		; STORE IT
	CMP	R1,#377		; VALID MEMBER CODE?
	BHI	40$		; NO
	CALL	$NNBLK		; GET TERMINATOR
	BCS	5$		; EOL IS OKAY
	CMPB	R2,#']		; IS IT BRACKET?
	BNE	4$		; NO, ERROR
	CALL	$GNBLK		; YES, GET NEXT
	BCS	5$		; EOL, GOOD
4$:	CMPB	R2,#'/		; PASSWORD COMMING?
	BNE	40$		; NO, ERROR
5$:	MOV	R0,-(SP)	; SAVE BUFFER ADDRESS
	MOV	PC,R2		; SET TO GENERATE LEADING ZEROES
	MOV	#UIC,R0		; POINT TO AREA FOR MEMBER
	MOV	MEM,R1		; RETRIEVE MEMBER CODE
	CALL	$CBOMG		; CONVERT MEMBER TO ASCII
	MOV	#UIC-3,R0	; POINT TO AREA FOR GROUP CODE
	MOV	GRP,R1		; GET GROUP CODE
	CALL	$CBOMG		; CONVERT GROUP TO ASCII
	MOV	(SP)+,R0	; RESTORE BUFFER ADDRESS
	BR	45$		; 
10$:	MOV	#NAME,R3	; GET ADDRESS OF NAME AREA
	MOV	#14.,R4		; SET LENGTH OF NAME
20$:	MOVB	#40,(R3)+	; BLANK IT OUT
	DEC	R4		; DONE?
	BGT	20$		; NO, LOOP
	INC	NAMFLG		; YES, SET NAME IS SPECIFIED
	MOV	#14.,R4		; SET LENGTH OF NAME
	MOV	#NAME,R5	; SET ADDRESS
30$:	CALL	$GNBLK		; GET NEXT NON-BLANK CHARACTER
	BCS	45$		; EOL, END
	TST	R1		; ANY BLANKS?
	BNE	35$		; YES, ONLY SLASH IS VALID
	CALL	TSTCHR		; IS IT A VALID CHARACTER?
	BCC	37$		; YES
35$:	CMPB	R2,#'/		; NO, PASSWORD COMMING?
	BEQ	50$		; YES
	BR	40$		; NO
37$:	MOVB	R2,(R5)+	; STORE CHARACTER
	DEC	R4		; ROOM FOR MORE?
	BGT	30$		; YES, TRY TO STORE IT
40$:	SEC			; ERROR
	BR	50$		;
45$:	CLC			; SET SUCCESS
50$:	RETURN			;
 
;+
; *** - OPEN  - OPEN FILE
;
;-
OPEN:	OPEN$U	#$ACTFL,,,#FD.RWM	; OPEN FILE
	BCS	10$		; ERROR
	INC	FILOPN		; SET FILE IS OPEN
10$:	RETURN			;
 
 
;+
; *** - 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		; AND WAIT
10$:	RETURN			;
 
 
;+
; *** - TSTCHR  -  TEST CHARACTER FOR VALID SYMBOL IN NAME.
;		   VALID CAHARCTERS ARE A-Z, 0-9, $, ', !, AND .
;
; INPUT:
;	R2 - CHARACTER TO BE CHECKED
; OUTPUT:
;	R2 - UNCHANGED
;	CARRY CLEAR - GOOD
;	CARRY SET - ERROR
;-
TSTCHR:	CMPB	R2,#'A		; ALPHABETIC?
	BLO	10$		; NO
	CMPB	R2,#'Z		; MAYBE
	BLOS	40$		; YES
10$:	CMPB	R2,#'0		; NUMERIC?
	BLO	20$		; NO
	CMPB	R2,#'9		; MAYBE
	BLOS	40$		; YES
20$:	CMPB	R2,#'$		; NO, DOLLAR?
	BEQ	40$		; YES
	CMPB	R2,#''		; NO, APOSTROPHE?
	BEQ	40$		; YES
	CMPB	R2,#'!		; NO, EXCLAMATION
	BEQ	40$		; YES
	CMPB	R2,#'.		; NO, PERIOD?
	BEQ	40$		; YES
30$:	SEC			; NO, SET ERROR
	BR	50$		;
40$:	CLC			; SET SUCCESS
50$:	RETURN			;

;+
; *** - SEARCH  -  SEARCH FILE FOR ACCOUNT NUMBER
;
; OUTPUT:
;	R0 - ADDRESS OF ACCOUNT ENTRY
;	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$:	TST	NAMFLG		; IS NAME SPECIFIED?
	BEQ	15$		; NO
	MOV	R0,ENTRY	; YES, SAVE ENTRY ADDRESS
	MOV	R1,-(SP)	; SAVE BYTES LEFT
	MOV	R2,-(SP)	; 
	ADD	#A.LNM,R0	; GET ADDRESS OF LAST NAME
	MOV	#NAME,R1	; GET ADDRESS OF NAME ENTERED
	MOV	#14.,R2		; SET LENGTH OF NAME
12$:	CMPB	(R0)+,(R1)+	; NAMES THE SAME?
	BEQ	14$		; YES
	SEC			; NO
	BR	18$		;
14$:	DEC	R2		; SO FAR
	BGT	12$		; CONTINUE TILL END
	MOV	ENTRY,R0	; RESTORE ENTRY ADDRESS
	BR	17$		; NAME IS THE SAME
15$:	CMP	UIC,A.GRP(R0)	; GROUP CODES MATCH
	BNE	20$		; NO
	CMP	UIC+2,A.GRP+2(R0) ; MAYBE
	BNE	20$		; NO
	CMP	UIC+4,A.MBR+1(R0) ; YES, MEMBER CODES MATCH?
	BNE	20$		; NO
	MOV	R0,ENTRY	; SAVE ENTRY POINTER
	MOV	R1,-(SP)	; SAVE R1 AND R2
	MOV	R2,-(SP)	;
17$:	CALL	TPSWD		; CHECK PASSWORD
18$:	MOV	(SP)+,R2	; RESTORE R1 AND R2 
	MOV	(SP)+,R1	;
	MOV	ENTRY,R0	; RESTORE ENTRY POINTER
	BCC	40$		; PASSWORD CHECKS OUT
20$:	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	30$		; YES
	TSTB	IOSB		; ANY ERRORS?
	BMI	30$		; YES
	ADD	#$BFLEN/512.,Q.IOPL+10(R4) ; NO, POINT TO NEXT VBN
	ADC	Q.IOPL+6(R4)	;
	BR	5$		; READ IN NEXT BUFFER
30$:	SEC			; ERROR, ACCOUNT NOT FOUND
40$:	RETURN			;
 
;+
; *** - TPSWD  -  TEST PASSWORD
;
; CARRY SET - INVALID PASSWORD
; CARRY CLEAR - GOOD PASSWORD
;
;-
TPSWD:	ADD	#A.PSWD,R0	; POINT TO PASSWORD IN FILE
	MOV	PSWDBF,R1	; POINT TO PASSWORD TYPED IN
	MOV	#6.,R2		; SET SIZE OF PASSWORD
2$:	CMPB	(R1),#15	; EOL?
	BEQ	4$		; YES
	CMPB	(R1)+,(R0)+	; NO, MATCH?
	BNE	10$		; NO, ERROR
	DEC	R2		; ALL DONE?
	BGT	2$		; NO, LOOP
	BR	20$		; YES
4$:	CMPB	(R0)+,#' 	; BLANK FROM HERE ON?
	BNE	10$		; NO, ERROR
	DEC	R2		; DONE?
	BGT	4$		; NO, LOOP
	BR	20$		; YES
10$:	SEC			; SET ERROR
20$:	RETURN			;
 
;+
; *** - LOGON  -  LOG THE SIGN ON TIME, UPDATE THE COUNT OF
;		  LOGONS, AND WRITE ENTRY BACK TO FILE
;
; INPUT:
;	ENTRY - ADDRESS OF ACCOUNT ENTRY
;
;-
LOGON:	GTIM$S	#TIMBUF		; GET TIME
	BCS	10$		; ERROR
	MOV	ENTRY,R0	; GET ADRESS OF ENTRY			**JGD001
	ADD	#A.TERM,R0	; UPDATE TO POINT AT TERMINAL #		**JGD001
	GLUN$S	#LUN1,#GLNBUF	; GET TERMINAL NUMBER			**JGD001
	TST	(R0)		; IS USER IS STILL LOGGED ONTO SOME	**JGD001
				; TERMINAL,				**JGD001
	BNE	20$		; HE IS, SO DON'T FIDDLE WITH ACCOUNT	**JGD001
	MOV	GLNBUF,(R0)+	; HE ISN'T,INSERT 'TT' INTO FILE	**JGD001
	MOV	GLNBUF+2,(R0)	; INSERT FLAG BYTE AND TERM.# INTO FILE **JGD001
	MOV	ENTRY,R0	; GET ADDRESS OF ENTRY
	ADD	#A.LDAT,R0	; UPDATE TO POINT TO LOGON TIME
	MOVB	TIMBUF+4,(R0)+	; SET DAY
	MOVB	TIMBUF+2,(R0)+	; MONTH
	MOVB	TIMBUF,(R0)+	; AND YEAR
	MOVB	TIMBUF+6,(R0)+	; HOUR
	MOVB	TIMBUF+10,(R0)+	; MINUTE
	MOVB	TIMBUF+12,(R0)+	; AND SECOND
	INC	(R0)		; BUMP UP THE LOGON COUNT
	MOV	#FDPB,R4	; GET FILE DPB ADRESS	
	MOV	#IO.WVB,2(R4)	; SET WRITE FUNCTION CODE
	MOV	IOSB+2,Q.IOPL+2(R4) ; SET COUNT OF BYTES TO WRITE
	CALL	QIO		; WRITE OUT ACCOUNT ENTRY
	MOV	#IO.RVB,2(R4)	; RESTORE DPB
	MOV	#$BFLEN,Q.IOPL+2(R4) ;
10$:	RETURN			;
20$:	MOV	INDEX,R1	; GET TERMINAL GROUP NUMBER			**JGD001
	SWAB	R1		; MOVE GROUP NUMBER TO LOWER BYTE		**JGD001
	CMPB	R1,#10		; IF THE USER IS NOT PRIVLEDGED, THEN LOGGING	**JGD001
				; ON TO MULTIPLE TERMINALS IS ILLEGAL		**JGD001
	BHI	30$		; NOT PRIVLEDGED, WARN AND LOG OFF		**JGD001
	MOV	#MS7,R0		; WARN USER HE IS LOGGED ONTO MULTIPLE 		**JGD001
	CALL	WRIT		; TERMINALS					**JGD001
	RETURN			; LEAVE ACCOUNT FILE ALONE			**JGD001
30$:	JMP	ERR9	 	; REPORT ERROR AND LOG OFF			**JGD001
;+
; *** - DATTIM  -  CONVERT DATE AND TIME TO ASCII
;
; INPUT:
;	R0 - BUFFER ADDRESS
;	TIMBUF - DATA RETURNED BY GTIM$
; OUTPUT:
;	R0 - UPDATED (16. CHARACTERS)
;	R1, R2, R3 - USED
;-
DATTIM:	MOVB	TIMBUF+4,R1	; GET DAY
	CALL	TWODEC		; CONVERT TO TWO DECIMAL DIGITS
	MOVB	#'-,(R0)+	;
	MOVB	TIMBUF+2,R1	; GET MONTH
	CALL	GETMON		; CONVERT TO ASCII
	MOVB	#'-,(R0)+	;
	MOVB	TIMBUF,R1	; GET YEAR
	CALL	TWODEC		; CONVERT TO TWO DECIMAL DIGITS
	MOVB	#40,(R0)+	;
	MOVB	TIMBUF+6,R1	; GET HOUR
	CALL	TWODEC		; CONVERT TO TWO DECIMAL DIGITS
	MOVB	#':,(R0)+	;
	MOVB	TIMBUF+10,R1	; GET MINUTE
	CALL	TWODEC		; CONVERT TO TWO DECIMAL DIGITS
	MOVB	#40,(R0)+	;
	RETURN			;
 
 
;+
; *** - TWODEC  -  CONVERT BINARY NUMBER TO TWO DECIMAL DIGITS
;
; INPUT:
;	R0 - BUFFER ADDRESS
;	R1 - BINARY NUMBER TO BE CONVERTED
; OUTPUT:
;	R0 - UPDATED
;	R1, R2, AND R3 USED
;-
TWODEC:	CMP	R1,#10.		; >= 10.?
	BGE	10$		; YES
	MOVB	#'0,(R0)+	; NO, PUT IN LEADING ZERO
10$:	CLR	R2		; SET TO SUPPRESS LEADING ZEROES
	CALL	$CBDMG		; CONVERT TO DECIMAL
	RETURN			;
 
 
;+
; *** - GETMON  -  CONVERT MONTH TO ASCII
;
; INPUT:
;	R0 - BUFFER ADDRESS
;	R1 - MONTH (1-12)
; OUTPUT:
;	R0 - UPDATED
;	R1, R2 USED
;-
GETMON:	DEC	R1		; CONVERT TO INDEX
	MOV	R1,R2		; COPY IT
	ADD	R2,R1		; MULTIPLY BY
	ADD	R2,R1		; THREE
	ADD	#MONTH,R1	; GET ADDRESS OF MONTH IN ASCII
	MOVB	(R1)+,(R0)+	; MOVE MONTH
	MOVB	(R1)+,(R0)+	; INTO BUFFER
	MOVB	(R1)+,(R0)+	;
	RETURN			;
 
;+
; *** - DSPFIL  -  DISPLAY FILE ON TERMINAL
;
; INPUT:
;	R1 - ADDRESS OF FILE NAME DECRIPTOR
; OUTPUT:
;	R0, R1, R2, R3 - USED
;-
DSPFIL:	FINIT$			;
	MOV	#$ACTFL,R0	; GET FILE FDB
	MOV	#40,ODPB+Q.IOPL+4 ; SET CARRIAGE CONTROL
	OPEN$R	R0,,R1,#0,#BUF,#132. ; OPEN TEXT FILE FOR READ
	BCS	30$		; ERROR
	INC	FILOPN		; SET FILE OPEN FLAG
10$:	GET$	#$ACTFL,#BUF,#132. ; READ A LINE FROM FILE
	BCS	20$		; 
	MOV	F.NRBD(R0),R1	; GET LENGTH OF LINE
	MOV	#BUF,R0		; GET BUFFER ADDRESS
	ADD	R0,R1		; GET ADDRESS OF LAST CHARACTER
	CLRB	(R1)		; SET END OF LINE
	CALL	WRIT		; WRITE IT OUT TO TI:
	BR	10$		; LOOP UNTIL EOF
20$:	CMPB	F.ERR(R0),#IE.EOF ; END OF FILE?
	BEQ	40$		; YES
30$:	MOVB	F.ERR(R0),R1	; GET ERROR CODE
	MOV	#ER8NUM,R0	; GET ADDRESS OF BUFFER
	CLR	R2		; SUPPRESS LEADING ZEROES
	CALL	$CBDSG		; CONVERT ERROR CODE
	MOVB	#'.,(R0)+	; PUT IN DECIMAL POINT
	CLRB	(R0)		; SET END OF LINE
	CALL	ERR8		; PRINT OUT ERROR MESSAGE
40$:	CLOSE$	#$ACTFL		; CLOSE FILE
	CLR	FILOPN		; SET FILE CLOSED FLAG
	RETURN			;
	.END	$HELEP