.TITLE	WHOLOG - PRINT LOGGED ON USERS
	.IDENT	/V01/
;+
; WRITTEN BY:	GARY L. MAXWELL
;		29-MAR-80
;		NATIONAL STRONG MOTION DATA CENTER
;		OFFICE OF EARTHQUAKE STUDIES
;		U.S. GEOLOGICAL SURVEY
;		345 MIDDLEFIELD ROAD
;		MAIL STOP 77
;		MENLO PARK, CALIFORNIA 94025
;
; GET INFORMATION REGARDING LOGGED IN TERMINALS, ACTIVE TASKS,
; AND NAMES AND INFO ON USERS FROM ACCOUNT FILE.
;-

	.MCALL	UCBDF$,DCBDF$,TCBDF$

	UCBDF$			; DEFINE UCB OFFSETS
	DCBDF$			; DEFINE DCB OFFSETS
	TCBDF$			; DEFINE TCB OFFSETS

; LOCAL SYMBOLS

SPACE	= <' >			; SPACE CHAR
PERIOD	= <'.>			; PERIOD CHAR

ANMLN	= 17.			; LARGEST NAME WHO ALLOWS

ACTSAV:	.WORD	0		; SAVE AREA FOR ACTIVE TASK POINTER
BUFPTR:	.WORD	0		; SAVE AREA FOR DATA BUFFER POINTER
ACTUIC:	.WORD	0		; SAVE AREA FOR ACCOUNT ENTRY UIC
	.PAGE
	.SBTTL	GET LOGGED ON TERMINALS
	.PSECT	WHOLOG,RO

;+
; LOGFIL - GET LOGGED ON TERMINAL INFORMATION
;
; INPUT: R0 POINTS TO MEMORY TO START STUFFING TERMINAL BLOCK INFO.
;
; OUTPUT: R0 IS UPDATED.
;
; ALL REGISTERS DESTROYED.
;-
LOGFIL::
	MOV	$BUFED,-(SP)	; GET END OF MEMORY
	SUB 	#LLEN,(SP)	; SUBTRACT ONE BLOCK LENGTH
	CLR	NUMLOG		; CLEAR NO. LOGGED IN TT:'S
	MOV	$DEVHD,R5	; POINT TO DEVICE HEAD

10$:	MOVB	D.UNIT(R5),R4	; GET LOWEST UNIT NO.
	MOV	D.NAM(R5),R3	; GET ASCII DEVICE NAME
	MOV	D.UCB(R5),R2	; POINT TO FIRST UCB

20$:	BIT	#DV.TTY,U.CW1(R2) ; UNIT A TERMINAL?
	BEQ	30$		; NO, BRANCH TO GET NEXT ONE
	BIT	#U2.LOG,U.CW2(R2) ; IS SOMEONE LOGGED ON?
	BNE	30$		; NO, BRANCH TO NEXT TT:
	CMP	$COPT,R2	; FORGET CONSOLE DEVICE FOR SKED TASKS		;**NEW**
	BEQ	30$								;**NEW**

25$:	CMP	R0,(SP)		; SEE IF ENOUGH ROOM FOR NEW BLOCK
	BLOS	28$		; YES, BRANCH AHEAD
	CALL	ALLOC		; ELSE TRY TO GET MORE MEMORY
	BCS	60$		; DIDN'T WORK - BRANCH TO EXIT
	MOV	$BUFED,(SP)	; ELSE GET NEW CEILING
	SUB	#LLEN,(SP)	; SUBTRACT BLOCK LENGTH
	BR	25$		; TRY SPACE TEST AGAIN

28$:	MOV	R2,(R0)+	; STORE UCB ADDRESS
	MOV	R3,(R0)+	; STORE DEVICE NAME
	MOV	R4,(R0)+	; STORE DEVICE UNIT
	MOV	U.LUIC(R2),(R0)+ ; STORE LOGON UIC
	CLR	(R0)+		; CLEAR ACTIVE TASK LISTHEAD
	CLR	(R0)+		; CLEAR ACCOUNT ENTRY POINTER
	INC	NUMLOG		; BUMP NO. LOGGED IN USERS

30$:	INC	R4		; BUMP UNIT NO.
	CMPB	D.UNIT+1(R5),R4 ; HAVE WE DONE ALL UNITS ON DCB?
	BLT	40$		; YES, BRANCH TO GET NEW DCB
	ADD	D.UCBL(R5),R2	; ELSE POINT TO NEXT UCB
	BR	20$		; AND GO EXAMINE IT

40$:	MOV	D.LNK(R5),R5	; POINT TO NEXT DCB
	BNE	10$		; GO PROCESS IF NOT NULL
	CLR	(R0)+		; ELSE MARK END OF TT: LIST

60$:	MOV	(SP)+,R5	; CLEAN STACK (DON'T AFFECT CARRY!)
	RETURN			; AND RETURN TO CALLER
	.PAGE
	.SBTTL	GET ACTIVE TASKS FOR TT:'S
;+
; TSKFIL - GET ESSENTIAL INFO FROM TCBS OF ACTIVE TASKS THAT
;	   HAVE LOGGED-IN TI:'S.
;
; INPUT - R0 POINTS TO BEGINNING OF MEMORY TO USE.
;
; OUTPUT - R0 UPDATED
;
; ALL REGISTERS ARE DESTROYED.
;-
TSKFIL::
	MOV	R0,BUFPTR	; SAVE WHERE TO START FILLING
	CLR	ACTSAV		; SHOW THAT WE'RE STARTING
	CLR	TSKFND		; CLEAR TASK FOUND COUNTER

10$:	CALL	$SWSTK,250$	; GO TO SYSTEM STATE
	MOV	BUFPTR,R0	;; POINT TO DATA BUFFER
	MOV	$BUFED,R2	;; POINT TO END OF BUFFER
	SUB	#TLEN,R2	;; SUBTRACT LENGTH OF A BLOCK
	MOV	ACTSAV,R1	;; GET ACTIVE TASK POINTER
	BNE	20$		;; BRANCH IF POINTER ACTIVE
	MOV	$ACTHD,R1	;; ELSE POINT TO TOP OF LIST
20$:	MOV	$LGFHD,R4	;; POINT TO LIST OF LOGGED IN TT:'S
	MOV	T.UCB(R1),R3	;; GET TASK'S TI: UCB

40$:	CMP	LUCB(R4),R3	;; MATCH WITH A TT:'S UCB?
	BEQ	500$		;; YES, GO CREATE ENTRY
	ADD	#LLEN,R4	;; ELSE POINT TO NEXT TT: ENTRY
	TST	(R4)		;; LOOKED AT ALL TT:'S?
	BNE	40$		;; NO, BRANCH TO DO NEXT ONE
	BR	540$		;; ELSE BRANCH TO GET NEXT ACTIVE TASK

500$:	CMP	R0,R2		;; ROOM FOR ANOTHER BLOCK?
	BHI	190$		;; NO, LEAVE SYS STATE TO TRY FOR MORE
	MOV	R0,-(SP)	;; SAVE BLOCK POINTER
	MOV	T.NAM(R1),(R0)+	;; GET FIRST HALF TASKNAME
	MOV	T.NAM+2(R1),(R0)+ ;; GET SECOND HALF NAME
	MOV	T.STAT(R1),(R0)+ ;; GET FIRST STATUS WORD
	MOV	T.ST2(R1),(R0)+	;; GET SECOND STATUS WORD
	MOVB	T.IOC(R1),R3	;; GET I/O COUNT
	MOV	R3,(R0)+	;; STORE IN FULL WORD
	CLR	(R0)+		;; CLEAR NEXT TASK BLOCK POINTER
	INC	TSKFND		;; BUMP TASK COUNTER
;
; INSERT TASK AT END OF LIST OF ACTIVE TASKS FOR TT:
;
	MOV	LTSK(R4),R3	;; GET POINTER TO TT:'S FIRST TASK
	BEQ	520$		;; BRANCH IF LIST ALREADY EMPTY

510$:	MOV	TLNK(R3),R5	;; GET POINTER TO NEXT TASK IN LIST
	BEQ	530$		;; BRANCH IF END OF LIST FOUND
	MOV	R5,R3		;; ELSE COPY POINTER
	BR	510$		;; TRY THIS TASK OUT

520$:	MOV	(SP)+,LTSK(R4)	;; LINK INTO TT:'S LISTHEAD
	BR	540$		;; SKIP TO NEXT ACTIVE TASK
530$:	MOV	(SP)+,TLNK(R3)	;; LINK INTO END OF TASK LIST

540$:	MOV	T.ACTL(R1),R1	;; POINT TO NEXT ACTIVE TASK
	TST	T.ACTL(R1)	;; LOOKING AT NULL TASK?
	BNE	20$		;; NO, GO PROCESS IT
	CLR	ACTSAV		;; YES, INDICATE WE'RE DONE
	BR	200$		;; AND LEAVE SYSTEM STATE

190$:	MOV	R1,ACTSAV	;; SAVE POINTER FOR WHEN WE RETURN
200$:	MOV	R0,BUFPTR	;; SAVE CURRENT DATA POINTER
	RETURN			;; RETURN TO USER STATE

250$:
	TST	ACTSAV		; NORMAL EXIT FROM SYS STATE?
	BEQ	270$		; YES, GO EXIT NOW
	CALL 	ALLOC		; ELSE TRY GETTING MORE MEMORY
	BCC	10$		; BRANCH IF IT WORKED
270$:	MOV	BUFPTR,R0	; INDICATE WHERE WE STOPPED
	RETURN			; RETURN FROM SUBROUTINE
	.PAGE
	.SBTTL	GET ACCOUNT FILE INFO
;+
; ACNTFL - GET NAME AND LAST LOGON INFO FROM ACCOUNT FILE
;	   THIS ROUTINE MAKES ONLY ONE PASS OVER ACCOUNT FILE
;
; INPUTS: R0 POINTS TO FIRST MEMORY LOCATION TO STUFF DATA
;
; OUTPUT: R0 IS UPDATED. CARRY CLEAR IF NORMAL RETURN.
;			 CARRY SET IF MEMORY OVERFLOW
;-
ACNTFL::
	CLR	CURENT		; CLEAR CURRENT BLOCK POINTER
	CLR	NUMFND		; CLEAR NUMBER USERS FOUND
	MOV	R0,R5		; COPY POINTER - WE NEED R0
	MOV	$BUFED,-(SP)	; PUSH MEMORY LIMIT
	SUB	#ALEN,(SP)	; SUBTRACT LENGTH OF A BLOCK
	CALL	FREAD		; READ FIRST BLOCK OF ACCOUNT FILE
	MOV	IOSB+2,RDLEN	; GET NO. BYTES READ IN
	BEQ	150$		; BRANCH IF NOTHING READ

10$:	MOV	#$ACTBF,R4	; POINT TO ACCOUNT FILE BUFFER

20$:	MOV	R4,R0		; COPY ACCOUNT ENTRY POINTER
	ADD	#A.MBR,R0	; POINT TO UIC MEMBER STRING
	CLRB	3(R0)		; CLEAR BYTE THAT FOLLOWS
	CALL	$COTB		; CONVERT CODE TO BINARY
	MOV	R1,-(SP)	; SAVE RESULT ON STACK FOR NOW
	MOV	R4,R0		; COPY POINTER AGAIN
	ADD	#A.GRP,R0	; POINT TO UIC GROUP STRING
	CLRB	3(R0)		; CLEAR BYTE THAT FOLLOWS
	CALL	$COTB		; CONVERT TO BINARY
	SWAB	R1		; PUT GROUP CODE IN HIGH ORDER
	BIS	(SP)+,R1	; OR IN THE MEMBER CODE
	MOV	R1,ACTUIC	; AND SAVE THE UIC
	MOV	$LGFHD,R0	; POINT TO FIRST LOGGED IN TT:

30$:	TST	LACNT(R0)	; THIS TERMINAL HAVE A USER YET?
	BNE	145$		; YES, BRANCH TO GET NEXT TT:
	CMP	LUIC(R0),ACTUIC	; NO, DO THE UIC'S MATCH?
	BNE	145$		; NO, GET TO NEXT USER

	INC	NUMFND		; YES, FIRST BUMP FOUND COUNTER
	TST	CURENT		; NAME BLOCK ALREADY CREATED?
	BEQ	35$		; NO, GO CREATE A NEW ONE
	MOV	CURENT,LACNT(R0) ; YES, JUST COPY IN POINTER
	BR	142$		; AND GO SEE IF WE'RE DONE

35$:	CMP	R5,(SP)		; ANY ROOM LEFT FOR A BLOCK
	BLOS	350$		; YES, GO PROCEED
	CALL	ALLOC		; NO, TRY TO GET MORE SPACE
	BCS	199$		; BRANCH ON FAILURE
	MOV	$BUFED,(SP)	; ELSE GET NEW LIMIT
	SUB	#ALEN,(SP)	; SUBTRACT LENGTH OF A BLOCK
	BR	35$		; TRY AGAIN
	.PAGE
; WE HAVE FOUND A MATCH BETWEEN TT: UIC AND ACCOUNT ENTRY UIC
; AND MUST CREATE A NEW ACCOUNT BLOCK (BLOCK DOES NOT EXIST ALREADY)

350$:	MOV	R5,CURENT	; SET UP POINTER TO NEW BLOCK
	MOV	R5,LACNT(R0)	; LINK IN FOR THIS TT:

	MOV	R5,R3		; COPY ADDRESS WHERE NAME LENGTH GOES
	CLR	(R5)+		; CLEAR BYTE COUNT OUT
	MOV	R4,R2		; COPY ACCOUNT ENTRY POINTER
	ADD	#A.FNM,R2	; POINT TO FIRST NAME
	CLR	R1		; USE R1 TO COUNT BYTES

50$:	MOVB	(R2)+,(R5)	; COPY BYTE OF NAME
	INC	R1		; BUMP COUNTER
	CMPB	#SPACE,(R5)+	; WAS LAST CHAR A SPACE?
	BEQ	60$		; YES, BRANCH ON END OF NAME
	CMP	#12.,R1		; HAVE WE COPIED 12 BYTES YET?
	BGT	50$		; NO, KEEP COPYING
	MOVB	#SPACE,(R5)+	; ELSE PAD OUT WITH A SPACE
	INC	R1		; BUMP BYTE COUNT ONCE MORE
	BR	62$		; AND GO WRITE OUT THE LENGTH

60$:	CMP	#1,R1		; WAS FIRST NAME ENTIRELY NULL?
	BEQ	63$		; YES, SKIP AHEAD
62$:	MOV	R1,(R3)		; WRITE OUT LENGTH OF FIRST NAME
	BR	120$		; AND GO DO LAST NAME

63$:	DEC	R5		; ERASE THE SPACE CHAR

120$:	CLR	R1		; CLEAR THE COUNTER AGAIN
	MOV	R4,R2		; COPY ACCOUNT ENTRY POINTER AGAIN
	ADD	#A.LNM,R2	; POINT TO LAST NAME

130$:	MOVB	(R2)+,(R5)	; COPY BYTE OF NAME
	INC	R1		; BUMP COUNTER
	CMPB	#SPACE,(R5)+	; WAS CHAR A SPACE?
	BEQ	135$		; YES, END OF NAME
	CMP	#14.,R1		; HAVE WE COPIED 14 CHARACTERS?
	BGT	130$		; NO, DO NEXT CHARACTER
	BR	140$		; YES, GO ADD IN BYTE COUNT

135$:	DEC	R5		; POINT BACK TO SPACE CHAR
	DEC	R1		; AND BUMP BACK COUNT
140$:	ADD	R1,(R3)		; ADD IN LAST NAME LENGTH
	CMP	#ANMLN,(R3)	; IS WHOLE NAME TOO LONG?
	BGE	142$		; NO, BRANCH AHEAD
	.PAGE
; FIRST AND LAST NAME ARE TOO LONG, SO WE JUST USE FIRST INITIAL
; OF FIRST NAME, THEN RECOPY THE LAST NAME AGAIN

	MOV	R3,R5		; COPY POINTER TO COUNT WORD
	MOV	#3,(R5)+	; INITIAL COUNT WITH INITIAL
	INC	R5		; SKIP OVER FIRST INITIAL
	MOVB	#PERIOD,(R5)+	; PUT A PERIOD AFTER IT
	MOVB	#SPACE,(R5)+	; AND A SPACE AFTER THAT
	BR	120$		; GO DO LAST NAME AGAIN

142$:	BIT	#1,R5		; ON A WORD BOUNDARY?
	BEQ	143$		; NO, SKIP AHEAD
	INC	R5		; ELSE GET ON A WORD BOUNDARY

143$:	CMP	NUMFND,NUMLOG	; FOUND EVERYONE YET?
	BHIS	199$		; YES, GO EXIT

145$:	ADD	#LLEN,R0	; POINT TO NEXT TT: BLOCK
	TST	(R0)		; REACHED END YET?
	BNE	30$		; NO, KEEP PROCESSING

	CLR	CURENT		; ELSE RESET CURRENT POINTER
	ADD	#A.LEN,R4	; POINT TO NEXT ENTRY
	SUB	#A.LEN,RDLEN	; BUMP BACK COUNT IN BUFFER
	BGT	20$		; PROCESS IF MORE IN BUFFER

150$:	CALL	AREAD		; READ NEXT BLOCK IN
	BCS	190$		; CARRY SET MEANS WE'RE DONE
	MOV	IOSB+2,RDLEN	; GET NO. BYTES IN BUFFER
	BEQ	150$		; TRY AGAIN IF NOTHING READ
	JMP	10$		; ELSE START ON THIS ACCOUNT ENTRY

190$:	CLC			; INDICATE SUCCESS
199$:	MOV	R5,R0		; COPY POINTER BACK TO R0
	MOV	(SP)+,R5	; CLEAN STACK (DON'T AFFECT CARRY)
	RETURN			; RETURN FROM CALLER

	.END