.PAGE
	.SBTTL	TIMER - TIMER EXPIRED SIGNAL

;
; WHEN THE TIMER EXPIRES, ALL OF THE CONECTION BLOCKS (CCBS) ARE SCANNED
; AND INACTIVE BLOCKS ARE RELEASED.  ALL PORT TABLES ARE ALSO SCANNED
; TO DETECT 1822 PORTS WHICH ARE NO LONGER DOWN.  IF THE PORT IS NOW
; DOWN (AS INDICATED BY PT.DWN = -1), THE PT.UPC IS INCREMENTED.  IF THE
; RESULTANT VALUE OF PT.UPC IS 2, THE PORT IS DECLARED "UP" AND THE 
; INITIALIATION SEQUENCE  IS STARTED.  FOR IMP-TYPE PORTS, 4 NOP MESSAGES
; ARE QUEUED FOR TRANSMISSION.  FOR HOST-TYPE PORTS, 3 NOP MESSAGES AND 1
; INTERFACE-RESET MESSAGE IS QUEUED FOR TRANSMISSION.
;

;
; FIRST, SEARCH THE CONNECTION BLOCKS
;

TIMER:	MOV	#CCBTBL,R4		;GET ADDR OF CB HASH TABLE
	MOV	-2(R4),R3		;  AND ITS LENGTH
1$:	MOV	R4,R1			;SET PREVIOUS POINTER
	MOV	(R4)+,R2		;GET FIRST CCB IN COLLISION CHAIN
	BEQ	4$			;IF ZERO, SKIP
2$:	TSTB	CB.CNT(R2)		;ANY MSGS OUTSTANDING?
	BNE	3$			;IF SO, NOT IDLE, SKIP
	TST	CB.BLK(R2)		;ANY BLOCKED IORB'S?
	BNE	3$			;IF SO, NOT IDLE
	INCB	CB.IDL(R2)		;INCREMENT IDLE COUNTER IN CCB
	CMPB	CB.IDL(R2),#3		;BEEN IDLE TOO LONG?
	BLO	3$			;IF NOT, SKIP
	MOV	CB.LNK(R2),@R1		;DELINK THIS CCB
	$FVS	#CB.LEN,R2		;DEALLOCATE ITS STORAGE
	INC	CCBDEL			;COUNT # OF CCBS FREED
	MOV	R1,R2			;AND RESET CCB PTR TO PREVIOUS ONE
3$:	MOV	R2,R1			;REMEMBER CURRENT CCB
	MOV	CB.LNK(R2),R2		;AND GET LINK TO NEXT
	BNE	2$			;IF NON-ZERO, CHECK IT
4$:	$LOOP	R3,1$			;AND SCAN COMPLETE TABLE

;
; NOW SCAN THE PORT TABLES
;

	MOV	#PRTTBL,R4		;GET PORT VECTOR TABLE
	MOV	(R4)+,R3		;AND NUMBER OF PORT DEFINED
5$:	MOV	(R4)+,PRT		;GET PORT STATUS TABLE ADDR
	BIT	#PT.OFL,PT.FLG(PRT)	;INTERFACE HARDWARE OFFLINE?
	BNE	7$			;IF SO, SKIP
	BIT	#PT.DWN,PT.FLG(PRT)	;INTERFACE DOWN?
	BEQ	7$			;IF NOT, SKIP
	BIT	#PT.ERR,PT.FLG(PRT)	;WAS LAST I/O REQUEST IN ERROR?
	BEQ	6$			;IF NOT, SKIP
	BIC	#PT.ERR,PT.FLG(PRT)	;RESET I/O ERROR FLAG
	CLR	PT.UPC(PRT)		;RESET THE UP COUNTER
	$AVS	#PKTLEN+IORBL		;ALLOCATE A PACKET
	JSR	PC,INITRB		;INIT IORB FOR A READ
	$SIO	IORB			;START A READ
	BR	7$
6$:	INC	PT.UPC(PRT)		;INCREMENT THE UP COUNTER
	CMP	PT.UPC(PRT),#2		;GOTTEN "DOWN" INTERRUPT RECENTLY?
	BEQ	7$			;IF SO, DON'T BRING UP
	CALL	@PT.INI(PRT)		;ELSE, RESET THE PORT & BRING IT UP
7$:	$LOOP	R3,5$
	$STIME	#OP.TIM,#0,#60.*3.	;SET TIMER FOR 3 SECONDS
	RET


	.PAGE
	.SBTTL	CCB UTILITY ROUTINES
	.SBTTL	.	RSTCCB - RESET THE CONNECTION CONTROL BLOCKS

;
; THE CONNECTION CONTROL BLOCKS ARE RESET WHENEVER A TYPE 10 (INTERFACE
; RESET MESSAGE) COMES IN FROM THE IMP.  THE ROUTINE GOES THROUGH THE
; CCB HASH TABLE RELEASING ALLOCATED CCBS AND CLEARING THE HASH TABLE.
;

RSTCCB:	$PUSH	R0,R1,R2,R3
;
; R1 - LENGTH OF CCB HASH TABLE
; R2 - POINTER TO CCB
; R3 - POINTER INTO CCB HASH TABLE
;
	MOV	#CCBTBL,R3		;GET ADDR OF CCB HASH TABLE
	MOV	-2(R3),R1		;LENGTH OF TABLE IS -2 ENTRY
1$:	MOV	(R3),R2			;GET POINTER TO CCB CHAIN
	BEQ	3$			;IF EMPTY, SKIP
	MOV	(R2),(R3)		;DELINK CCB FROM HEAD OF LIST
	$FVS	#CB.LEN,R2		;RELEASE CCB STORAGE
	BR	1$			;AND GET NEXT ELEMENT
3$:	$LOOP	R1,1$
	$POP	R3,R2,R1,R0
	RET


	.PAGE
	.SBTTL	.	FNDCCB - FIND A MATCHING CONNECTION CONTROL BLOCK

;
; CALLED WITH:	PKT - ADDRESS OF PACKET HEADER
;
; RETURNS WITH:	CCB - ADDRESS OF CCB
;			= 0, IF NO CCB ALLOCATED
;

FNDCCB:	$PUSH	R0
	MOVB	AH.IMP+1(PKT),R0	;GET DESTINATION IMP NUMBER
	BIC	#^C77,R0		;CONVERT TO IMP NUMBER
	ASL	R0			;CONVERT TO TABLE INDEX
	MOV	CCBTBL(R0),CCB		;GET CCB LINK
	BEQ	3$			;IF ZERO, NO CCB, EXIT
1$:	CMPB	AH.HST(PKT),CB.HST(CCB)	;DESTINATION HOST IDS MATCH?
	BNE	2$			;IF NOT, ADVANCE TO NEXT CCB
	CMP	AH.IMP(PKT),CB.IMP(CCB)	;DESTINATION IMP IDS MATCH?
	BEQ	3$			;IF SO, EXIT W/ MATCHING CCB ADDR
2$:	MOV	CB.LNK(CCB),CCB		;GET LINK TO NEXT CCB
	BNE	1$			;AND CHECK IT
3$:	$POP	R0
	RTS	PC			;IF SO, RETURN CCB ADDRESS


	.PAGE
	.SBTTL	.	INICCB - ALLOCATE AND INITIALIZE CCB

;
; THIS ROUTINE ALLOCATES AND INITIALIZES A CONNECTION BLOCK.
;
; CALLED WITH:	PKT - ADDRESS OF PACKET 
;
; RETURNS WITH:	CCB - ADDRESS OF CCB
;

INICCB:	$PUSH	R0,R2
	$AVS	#CB.LEN			;ALLOCATE A CCB
	MOV	R2,CCB
	MOVB	AH.IMP+1(PKT),R0	;GET DESTINATION IMP ID
	BIC	#^C77,R0		;CONVERT TO IMP NUMBER
	ASL	R0			;CONVERT TO TABLE INDEX
	MOV	CCBTBL(R0),CB.LNK(CCB)	;LINK NEW CCB TO ALL THE OTHERS
	BEQ	1$			;IF ONLY CCB, SKIP
	INC	CCBCOL			;COUNT NUMBER OF CCB HASH COLLISIONS
1$:	MOV	CCB,CCBTBL(R0)		;AND PUT IN LINK TO NEW CCB
	MOVB	AH.HST(PKT),CB.HST(CCB)	;SET DESTINATION HOST ID
	MOV	AH.IMP(PKT),CB.IMP(CCB)	;  AND IMP ID IN CCB
	CLRB	CB.CNT(CCB)		;RESET MESSAGE OUTSTANDING COUNT
	CLR	CB.BLK(CCB)		;RESET BLOCKED IORB LIST HEAD
	MOV	CCB,CB.BLK+2(CCB)	; AND TAIL POINTER
	ADD	#CB.BLK,CB.BLK+2(CCB)
	CLRB	CB.IDL(CCB)		;RESET IDLE FLAG
	$POP	R2,R0
	RTS	PC

	.PAGE
	.SBTTL	SNDCPY - SEND A COPY OF A PACKET

;
; THIS ROUTINE IS USED TO SEND A COPY OF AN ARPANET MESSAGE TO A SELECTED
; PORT.  A PACKET BUFFER IS ALLOCATED, THE IORB INITIALIZED, THE TEXT OF 
; THE PACKET IS COPIED INTO THE PACKET BUFFER, AND THE PACKET IS QUEUE FOR
; TRANSMISSION ON THE PORT
;
; CALLED WITH:	IORB - ADDR OF IORB/PACKET TO BE COPIED
;		PRT  - ADDR OF PORT TABLE
;

SNDCPY:	$PUSH	R0,IORB,PKT		;SAVE R0, R2, & R3
	MOV	IORB,R3			;GET IORB
	$AVS	#PKTLEN+IORBL		;ALLOCATE A NEW PACKET & IORB
	MOV	IORB,IRUVA(IORB)
	ADD	#IORBL,IRUVA(IORB)	;SET-UP PACKET ADDRESS
	MOV	IRBX(R3),IRBX(IORB)	;COPY BYTE TRANSFERRED COUNT
	$PUSH	R2,R3
	MOV	IRBX(IORB),R0
	ASR	R0			;GET WORD COUNT OF PKT TEXT
	MOV	IRUVA(R3),R3		;GET SOURCE PKT ADDR
	MOV	IRUVA(IORB),IORB	;GET TARGET PKT ADDR
1$:	MOV	(R3)+,(R2)+		;COPY TEXT OF ORIGINAL MSG
	$LOOP	R0,1$
	$POP	R3,R2
	JSR	PC,SNDPKT		;SEND PACKET
	$POP	PKT,IORB,R0
	RTS	PC

	.PAGE
	.SBTTL	SNDPKT - SEND THE PACKET TO THE SPECIFIED PORT

;
; SNDPKT SENDS THE PKT TO THE SPECIFIED PORT.  
;
; CALLED WITH:	IORB - ADDR OF IORB TO SEND
;		PRT  - ADDR OF OUTPUT PORT TABLE
;

	BRIDGE = 5			; ADDRESS OF BRIDGE


SNDPKT:	$PUSH	R0
	MOV	PT.OUT(PRT),IRDEV(IORB)	;SET OUTPUT PORT DEVICE NUMBER
	MOV	#OP.OUT,IROPC(IORB)	;SET OPCODE TO "OUTPUT"
	ADD	PT.ID(PRT),IROPC(IORB)	;AND ADD IN PORT NUMBER
	MOV	IRBX(IORB),IRBR(IORB)	;SET BYTES REQUESTED TO AMT XFERRED
	MOV	IRUVA(IORB),R0		;GET PKT POINTER
	MOVB	AH.TYP(R0),R0		;GET MESSAGE TYPE
	BIC	#^C17,R0
	ASL	R0			;CONVERT TO WORD INDEX
	ADD	PRT,R0
	INC	PT.SC(R0)		;COUNT MESSAGES BY TYPE
	INCB	PT.PKO(PRT)		;INDICATE OUTPUT PENDING ON PORT

	TST	PT.TYP(PRT)		;IF LNI, HACK UP
	BEQ	10$
	MOV	IRUVA(IORB),R0		;GET PKT POINTER
	TSTB	AH.TYP(R0)
	BEQ	1$			;IF NOT DATA, PUNT
	DECB	PT.PKO(PRT)		;MARK AS SENT
	$FVS	#PKTLEN+IORBL,IORB	;THROW AWAY PACKET
	BR	11$
1$:	$PUSH	R1			;GET ADDR OF IN PKT
	MOV	R0,R1			;IN R1
	ADD	#AH.LEN,R1
	SUB	#LN.LEN-AH.LEN,R0	;R0 POINTS TO NEW LNI HEADER
	MOV	R0,IRUVA(IORB)		;MAKE IORB POINT TO LNI HDR
	ADD	#LN.LEN-AH.LEN,IRBR(IORB)	;AND MENTION EXTRA WORD IN OP
	CLR	LN.DML(R0)		;SET UP LNI HEADER
	CLR	LN.DMH(R0)
	MOVB	#1,LN.PR(R0)		;INTERNAL INTERNET
	MOVB	@#NETID+1,LN.SNT(R0)	;NOW THE ADDRESS
	CMPB	IH.DN(R1),@#NETID	;FOR THIS NET
	BNE	2$			;NOPE, SEND TO BR
	CMPB	IH.DTH(R1),@#NETID+1	;FOR THIS NET
	BNE	2$			;LIKEWISE
	MOVB	IH.DT+1(R1),LN.HST(R0)	;YES, STORE HOST
	BR	3$
2$:	MOVB	#BRIDGE,LN.HST(R0)	;STORE BR
3$:	CLRB	LN.RSD(R0)		;RSD IS ZERO
	CLR	LN.OPH(R0)		;SRC ADDR IS CLEARED
	CLR	LN.OPL(R0)
	MOV	IRBR(IORB),LN.ML(R0)	;NOW THE PKT LEN
	SUB	#LN.LEN,LN.ML(R0)	;WHICH DOESN'T INCLUDE THE LNI HDR
	$POP	R1

10$:	$SIO	IORB			;AND START I/O
11$:	$POP	R0
	RTS	PC

	.PAGE
	.SBTTL	INITRB - INITIALIZE I/O REQUEST BLOCK

;
;   THIS ROUTINE INITIALIZES AN I/O REQUEST BLOCK FOR INPUT FROM THE
; SPECIFIED PORT
;
; CALLED WITH:	IORB - ADDR OF IORB
;		PRT  - ADDR OF PORT TABLE
;

INITRB:	MOV	PT.IN(PRT),IRDEV(IORB)	;SET TO PORT INPUT DEVICE
	MOV	#OP.IN,IROPC(IORB)	;INIT OPCODE
	ADD	PT.ID(PRT),IROPC(IORB)	;AND ADD IN PORT NUMBER
	MOV	IORB,IRUVA(IORB)	;SET-UP BUFFER POINTER 
	ADD	#IORBL,IRUVA(IORB)	;... TO RIGHT AFTER IORB
	TST	PT.TYP(PRT)		;IS IT AN 1822?
	BNE	1$
	ADD	#2,IRUVA(IORB)		;YAH, BUMP TO LEAVE ROOM FOR LNI HDR
1$:	MOV	#PKTLEN-2,IRBR(IORB)	;REQUEST A COMPLETE PACKET TRANSFER
	RTS	PC

	.IF NE,	SW.MON
	.PAGE
	.SBTTL	PACKET TRACING UTILITIES
	.SBTTL	.	TRACE - CONSTRUCT A TRACE QUEUE ELEMENT

;
; CONSTRUCT A TRACE QUEUE ELEMENT.  FORMAT OF TRACE QUEUE ELEMENTS ARE:
;
;	QUEUE POINTER (USED BY $TRACE)
;	LENGTH OF BLOCK
;	PRINTING ROUTINE
;	DIRECTION MESSAGE
;	PORT TABLE ADDR
; 	SOURCE ADDR
;	    "
;	DESTN ADDR
;	    "
;
; THIS ELEMENT IS ADDED TO THE TRACE QUEUE TO BE PRINTED OUT BY THE
; PKTPNT ROUTINE
;
; CALLED WITH:	R1  - TRANSFER DIRECTION
;		PKT - PACKET POINTER
;		PRT - ADDR OF PORT BLOCK
;

TRACE:	TST	TRCFLG			;TRACING TURNED ON?
	BEQ	3$			;IF NOT, SKIP
	$PUSH	R0,R2
	$AVS	#9.*2			;ALLOCATE TRACE BLOCK
	MOV	R2,R0			;R0 - TRACE ELEMENT
	$PUSH	R0			;REMEMBER BLOCK POINTER
	CLR	(R0)+			;CLEAR LINK FIELD
	MOV	#9.*2,(R0)+		;PUT LENGTH IN BLOCK
	MOV	#PKTPNT,(R0)+		;PUT ADDR OF PRINTING ROUTINE
	MOV	R1,(R0)+		;INCLUDE DIRECTION MESSAGE ADDR
	MOV	PRT,(R0)+		;ADDR OF PORT TABLE
	CMPB	AH.LEN+IH.IHL(PKT),#IH.VAL	;OLD OR NEW INET HEADER?
	BLO	1$			;IF OLD HEADER, SKIP
	MOV	AH.LEN+IH.SN(PKT),(R0)+	;COPY SOURCE ADDR INTO BUFFER
	MOV	AH.LEN+IH.ST(PKT),(R0)+
	MOV	AH.LEN+IH.DN(PKT),(R0)+	;COPY DESTINATION ADDR INTO PACKET
	MOV	AH.LEN+IH.DT(PKT),(R0)+	
	BR	2$

1$:	MOV	AH.LEN+OH.SN(PKT),(R0)+	;COPY SOURCE ADDR
	MOV	AH.LEN+OH.ST(PKT),(R0)+
	MOV	AH.LEN+OH.DN(PKT),(R0)+	;AND DESTINATION ADDR
	MOV	AH.LEN+OH.DT(PKT),(R0)+

2$:	$POP	R0
	CALL	$TRACE			;ADD TRACE BUFFER TO QUEUE
	$POP	R2,R0
3$:	RET

	.PAGE
	.SBTTL	.	MTYPE - ADD A STATUS MESSAGE TO TRACE QUEUE

;
; CALLED WITH:	R0  - ADDR OF ASCIZ STATUS MESSAGE
;		PRT - ACTIVE PORT
;

MTYPE:	TST	MSGFLG			;STATUS MSGS ENALED
	BEQ	3$			;IF NOT, EXIT
	$PUSH	R0,R1,R2
	$PUSH	R0			;SAVE MSG POINTER
	CLR	R1			;CLEAR CHAR COUNTER
1$:	INC	R1			;BUMP CHARACTER COUNT
	TSTB	(R0)+			;REACHED END OF MESSAGE?
	BNE	1$			;IF NOT, COUNT CHARACTER
	MOV	R1,R0
	ADD	#4*2+1,R0		;INCLUDE TRACE BUFFER HEADER
	BIC	#1,R0			;ROUND CHARACTER COUNT TO WORDS
	$AVS	R0			;ALLOCATE TRACE BUFFER
	MOV	R0,2(R2)		;SAVE BUFFER LENGTH
	$POP	R0			;RECOVER STRNG POINTER
	$PUSH	R2			;SAVE BUFFER POINTER
	CLR	(R2)+			;CLEAR LINK FIELD
	TST	(R2)+			;SKIP PAST LENGTH
	MOV	#MSGPNT,(R2)+		;PUT IN ADDR OF MSG PRINTING ROUTINE
	MOV	PRT,(R2)+		;INCLUDE PORT TABLE POINTER
	MOV	R1,(R2)+		;  AND LENGTH OF STRING
2$:	MOVB	(R0)+,(R2)+		;TRANSFER MSG TO TRACE BUFFER
	BNE	2$			
	$POP	R2
	MOV	R2,R0			;GET BUFFER ADDR IN R0
	CALL	$TRACE			;ADD BUFFER TO TRACE QUEUE
	$POP	R2,R1,R0
3$:	RET

	.PAGE
	.SBTTL	.	PKTPNT - TRACE PACKET PRINTING ROUTINE

;
; CALLED WITH:	R0 - ADDR OF TRACE BUFFER
;

PKTPNT:	$PUSH	R0,R1,R2,R3,R4
	MOV	R0,R3			;GET R3 - ADDR OF TRACE BUFFER
	ADD	#6,R3			;ADVANCE TO DIRECTION FIELD
	$SOUT	(R3)+,#9.		;OUTPUT DIRECTION MESSAGE
	MOV	(R3)+,R0		;GET PORT TABLE ADDR
	BEQ	11$			;IF NO PORT, SKIP
	ADD	#PT.NAM,R0		;AND POINT TO PORT NAME FIELD
	$SOUT	R0,#6			;OUTPUT PORT NAME
11$:	$BOUT	#':			;OUTPUT ":" SEPARATOR
	MOV	#4,R4			;OUTPUT ADDR FIELD AS 4 NUMBER
	MOV	#8.,R2			;  IN OCTAL RADIX
1$:	$BOUT	#40			;OUTPUT A SPACE
	CLR	R0
	BISB	(R3)+,R0		;GET SOURCE NET ID
	CALL	$NOUT			;AND OUTPUT
	$LOOP	R4,1$
	$SOUT	#MSG1,#3		;OUTPUT " ->" ADDR FIELD SEPERATOR
	MOV	#4,R4			;OUTPUT ADDR FIELD AS 4 NUMBER
2$:	$BOUT	#40			;OUTPUT A SPACE
	CLR	R0
	BISB	(R3)+,R0		;GET SOURCE NET ID
	CALL	$NOUT			;AND OUTPUT
	$LOOP	R4,2$
	$SOUT	#MSGCR,#2		;ENDED WITH CR/LF
	$POP	R4,R3,R2,R1,R0
	RET

	.PAGE
	.SBTTL	.	MSGPNT - TRACE MESSAGE PRINT ROUTINE 

;
; CALLED WITH	R0 - ADDR OF TRACE BUFFER
;

MSGPNT:	$PUSH	R0,R1,R2
	MOV	R0,R2			;GET TRACE BUFFER ADDR
	ADD	#6,R2			;ADVANCE TO PORT TABLE ADDR
	MOV	(R2)+,R0		;GET PORT TABLE ADDR
	ADD	#PT.NAM,R0		;AND POINT TO PORT NAME FIELD
	$SOUT	R0,#6			;OUTPUT PORT NAME
	$SOUT	#MSG2,#3		;FOLLOWED BY " - "
	MOV	(R2)+,R1		;GET LENGTH OF MESSAGE STRING
	$SOUT	R2,R1			;  AND OUTPUT STATUS MESSAGE
	$POP	R2,R1,R0
	RET
	.ENDC

	.PAGE
	.SBTTL	ENQ & DEQ - QUEUE HANDLING ROUTINES


;
; CALLED WITH:	R2 - ADDRESS OF QUEUE HEAD/TAIL POINTER
;		R0 - ADDR OF ELEMENT TO ENQ AT TAIL
;

ENQ:	CLR	@R0			;CLEAR NEXT LINK OF NEW ELEMENT
	MOV	R0,@2(R2)		;LINK OLD TAIL TO NEW TAIL ELEMENT
	MOV	R0,2(R2)		;UPDATE TAIL POINTER
	RTS	PC




;
; CALLED WITH:	R2 - ADDRESS OF QUEUE HEAD/TAIL POINTER
;
; RETURNS WITH:	R0 - ADDRESS OF DEQUEUED ELEMENT
;

DEQ:	MOV	(R2),R0			;GET ELEMENT AT HEAD
	BEQ	1$			;IF EMPTY, RETURN
	MOV	(R0),(R2)		;UPDATE QUEUE HEAD POINTER
	BNE	1$			;IF NOT EMPTY, SKIP
	MOV	R2,2(R2)		;ELSE, POINT TAIL TOWARDS HEAD POINTER
1$:	RTS	PC


	.PAGE
	.SBTTL	DATA STORAGE

;
; TRCFLG IS SET TO NON-ZERO TO ENABLE PRINTING OF A PACKET TRACE

TRCFLG:	.WORD	SW.DBG

;
; MSGFLG IS SET TO NON-ZERO TO ENABLE PRINTING OF VARIOUS STATUS MESSAGES

MSGFLG:	.WORD	SW.MON

;
MSGCNT:	.WORD	9.			;MAX NUMBER OF QUEUED MESSAGES

;
; IMPPRT CONTAINS THE PORT NUMBER OF THE IMP

IMPPRT:	.WORD	0			;IMP PORT ID

;
; THE CONNECTION BLOCKS ARE SEARCHED VIA A HASH TABLE, WITH LINKED-LIST
; COLLISION RESOLUTION.  FOR NOW, THE HASH TABLE IS SIMPLY INDEXED BY
; DESTINATION IMP NUMBER (MOD 64) * 2.  

	.WORD	64.			;LENGTH OF CCB HASH TABLE 
CCBTBL:	.BLKW	64.			;CCB HASH TABLE

;
; STATISTICS COUNTERS
;

	.WORD	2			;LENGTH OF STATS TABLE
STATS:
CCBDEL:	.WORD	0			;# OF CCB FREED DUE TO LACK OF USE
CCBCOL:	.WORD	0			;# OF CCB HASH COLLISIONS

;
; IMP MESSAGE STORAGE
;

	.MACRO	IMPMSG	TYPE
..TMP=.
	.WORD	0,0,0
	.WORD	..TMP+IORBL
	.WORD	0,0,0
	.WORD	10.
	.WORD	0,0
	.BYTE	17,0,0,TYPE,0,0,0,54,0,0
	.ENDM


RSTMSG:	IMPMSG	10.			;IMP-TO-HOST INTERFACE RESET MSG

ERRMSG:	IMPMSG	1			;IMP-TO-HOST PKT ERROR MSG

NOPMSG:	IMPMSG	4			;IMP-HOST NOP MSG

	.IF NE,	SW.MON
;
; MESSAGE TEXT STORAGE
;

MSG1:	.ASCIZ	/ ->/			;SOURCE / DESTINATION FIELD SEPERATOR

MSG2:	.ASCIZ	/ - /			;PORT NAME & MESSAGE FIELD SEPERATOR

MSGRCV:	.ASCIZ	/Rcv from /

MSGSND:	.ASCIZ	/Sent to  /

MSGFSH:	.ASCIZ	/Discarded/

MSGCR:	.ASCIZ	<15><12>

MSGDN:	.ASCIZ	/Not ready/<15><12>	;PORT NOT READY MESSAGE

MSGUP:	.ASCIZ	/UP/<15><12>		;PORT UP MESSAGE

MSGTDY:	.ASCIZ	/Tardy/<15><12>		;PORT TARDY MESSAGE

MSGBAD:	.ASCIZ	/Old-style leader received/<15><12>	;32-BIT PKT RECEIVED

MSGINV:	.ASCIZ	/Invalid MSG type/<15><12>

MSGIT1:	.ASCIZ	/Error in leader/<15><12>

MSGIT2:	.ASCIZ	/IMP going down soon/<15><12>

MSGIT8:	.ASCIZ	/Error in data/<15><12>

MSGBLK:	.ASCIZ	/Interfaced blocked/<15><12>

MSGUNB:	.ASCIZ	/Interfaced unblocked/<15><12>

MSGRFN:	.ASCIZ	/No CB for RFNM/<15><12>

MSGBN:	.ASCIZ	/Net number out of range/<15><12>

MSGNG:	.ASCIZ	/No gateway for net/<15><12>

	.EVEN

	.ENDC

	.END