*DECK QTGET
USETEXT AIPDEF
USETEXT QTRMBUF
USETEXT QTRMNIT
PROC QTGET(WSA);
*IF,DEF,IMS
#
*1DC QTGET
*
* 1. PROC NAME AUTHOR DATE
* QTGET D. P. OCONNELL 78/12/12
*
* 2. FUNCTION DESCRIPTION
* GET DATA MESSAGE FROM NETWORK AND PLACE IN
* USERS MESSAGE BUFFER UNLESS A CONDITION ARISES
* THAT THE USER SHOULD BE INFORMED OF. IN ANY
* CASE INFORM THE USER OF WHAT WAS ACCOMPLISHED
* BY PROVIDING A RETURN CODE.
*
* 3. METHOD USED
* IF NETON NOT SUCCESSFUL YET,
* CALL NP$ERR TO ISSUE DAYFILE MSG AND ABORT APP.
* ELSE (NETON COMPLETED),
* CALCULATE SIZE OF APPLICATION BUFFER.
* LOOP UNTIL NECESSARY TO SEND RETURN CODE TO APP.
* IF CONNECTION POLLING IS IN EFFECT AND CONNECTION NUMBER
* IS NONZERO,
* SET NULL BLOCK IN APP BLOCK HEADER WORD.
* ELSE (NEED TO GET ASYNCH SUPERVISORY MESSAGES IF ANY),
* CALL NETGET WITH ACN = 0 TO PICK UP ASYNC SUP MSGS.
* IF VALID BLOCK TYPE IN APP BLOCK HEADER WORD,
* IF RECEIVED ASYNCHRONOUS SUP MSG,
* LOOP CHECKING FOR PFC RECOGNIZED BY QTRM.
* IF RECOGNIZED PFC,
* JUMP ACCORDING TO TYPE OF PFC:
*
* CON: IF CON/REQ SUP MSG,
* IF DEVICE TYPE FOR NEW CONNECTION SUPPORTED,
* SET UP NIT CONNECTION ENTRY.
* IF APP WANTS TO BE INFORMED ABOUT CON/REQ,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* IF DATA FROM PREVIOUS APP WHICH HAD CON,
* COPY DATA TO APPLICATION BUFFER.
* ELSE (APP DOES NOT SUPPORT THIS DEVICE TYPE),
* REJECT CONNECTION.
* ELSE (NOT CON/REQ SUP MSG),
* IF CON/CB SUP MSG,
* IF OKAY TO SEND CON/END SUP MSG,
* CALL QTENDT TO TERMINATE CONNECTION.
* IF APP KNOWS ABOUT CONNECTION,
* SET FLAG TO STOP LOOPING AND INFORM AP.
* ELSE (APP NO LONGER HAS CONNECTION),
* IF NOT TERMINATED CONNECTION,
* SET FLAG TO STOP LOOPING AND INFORM AP.
* ELSE (NOT CON/CB OR CON/REQ SUP MSG),
* IF CON/ACRQ/A SUP MSG,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* ELSE (MUST BE CON/END/N SUP MSG),
* INIT NIT CONNECTION ENTRY.
*
* ERR: SET FLAG TO STOP LOOPING AND INFORM APP.
*
* FC: JUMP ACCORDING TO TYPE OF SFC:
*
* ACK: UPDATE NIT CONNECTION ENTRY.
* IF RO/MARK NEEDS TO BE SENT DOWNLINE,
* BUILD RO/MARK SYNC SUP MSG.
* CALL QTTIP TO SEND RO/MARK SUP MSG.
* ELSE (DO NOT NEED TO SEND RO/MARK),
* IF TO/MARK NEEDS TO BE SENT DOWNLINE,
* BUILD TO/MARK SYNC SUP MSG.
* CALL QTTIP TO SEND TO/MARK SUP MSG.
*
* BRK: IF CONNECTION HAS NOT BEEN TERMINATED,
* UPDATE NIT CONNECTION ENTRY.
* BUILD FC/RST SUP MSG.
* CALL NETPUT TO SEND FC/RST SUP MSG TO NAM.
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* INACT: IF APPLICATION STILL HAS CONNECTION,
* IF APPLICATION KNOWS ABOUT CONNECTION,
* IF APPLICATION WANTS TO BE INFORMED,
* SET FLAG TO STOP LOOPING AND INFORM AP.
* ELSE (APP DOES NOT KNOW ABOUT CONNECTION),
* CALL QTENDT TO TERMINATE CONNECTION.
*
* INIT: IF WAITING FOR FC/INIT/R SUP MSG,
* BUILD FC/INIT/N FROM FC/INIT/R.
* CALL NETPUT TO SEND FC/INIT/N TO NAM.
* UPDATE NIT CONNECTION ENTRY.
* IF PRU/ON PROCESSING,
* BUILD PRU/ON/R SUP MSG.
* CALL NETPUT TO SEND PRU/ON/R TO NAM.
* ELSE (NO PRU/ON SUP MSG PROCESSING),
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* NAK: IF CONNECTION HAS NOT BEEN TERMINATED,
* CALL QTENDT TO TERMINATE CONNECTION.
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* RST: IF EXPECTING FC/RST SUP MSG,
* UPDATE NIT CONNECTION ENTRY.
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* SHUT: IF FORCED SHUTDOWN,
* CALL NETOFF TO TERMINATE LINK TO NAM.
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* TCH: UPDATE NIT CONNECTION ENTRY.
*
* INTR: IF INTR/RSP SUP MSG,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* ELSE (MUST BE INTR/USR RECEIVED),
* IF CONNECTION HAS NOT BEEN TERMINATED,
* IF USER BREAK FROM TERMINAL,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* UPDATE NIT CONNECTION ENTRY.
* IF QTRM NEEDS TO SEND RO/MARK SUP MSG,
* BUILD RO/MARK SYNC SUP MSG.
* CALL QTTIP TO SEND RO/MARK SUP MSG.
* ELSE (NOT USER BREAK FROM TERMINAL),
* UPDATE NIT CONNECTION ENTRY.
* BUILD INTR/RSP SUP MSG.
* CALL NETPUT TO SEND SUP MSG TO NAM.
*
* HOP: SET FLAG TO STOP LOOPING.
* JUMP ACCORDING TO TYPE OF SFC:
*
* BRK: IF APPLICATION SUPPORTS K-DISPLAY,
* SET RETURN CODE TO INFORM APP.
* ELSE (APP DOES NOT SUPPORT K-DISPLAY,
* CLEAR FLAG TO CONTINUE LOOPING.
*
* CMD: IF APPLICATION SUPPORTS K-DISPLAY,
* SET RETURN CODE TO INFORM APP.
* UPDATE NIT.
* COPY OPERATOR TYPEIN TO APP BUFFER.
* ELSE (APP DOES NOT SUPPORT K-DISPLAY,
* CLEAR FLAG TO CONTINUE LOOPING.
*
* TRCE: CALL NETDBG TO TURN ON AIP TRACING.
* CLEAR FLAG TO CONTINUE LOOPING.
*
* DU: SET RETURN CODE TO INFORM APP.
*
* IG: SET INTERNAL FLAG TO NOT SEND HOP/ALT.
* CLEAR FLAG TO CONTINUE LOOPING.
*
* STRT: CLEAR INTERNAL FLAG TO NOT SEND HOP/ALT.
* IF APPLICATION SUPPORTS K-DISPLAY,
* SET RETURN CODE TO INFORM APP.
* COPY SCREEN SIZES TO APP BUFFER.
* ELSE (APP DOES NOT SUPPORT K-DISPLAY),
* CLEAR FLAG TO CONTINUE LOOPING.
*
* END: IF APPLICATION SUPPORTS K-DISPLAY,
* SET RETURN CODE TO INFORM APP.
* ELSE (APP DOES NOT SUPPORT K-DISPLAY),
* CLEAR FLAG TO CONTINUE LOOPING.
*
* NOTR: CALL NETDBG TO TURN OFF AIP TRACING.
* CLEAR FLAG TO CONTINUE LOOPING.
*
* RS: SET RETURN CODE TO INFORM APP.
*
* PAGE: IF APPLICATION SUPPORTS K-DISPLAY,
* SET RETURN CODE TO INFORM APP.
* ELSE (APP DOES NOT SUPPORT K-DISPLAY),
* CLEAR FLAG TO CONTINUE LOOPING.
*
* REL: SET RETURN CODE TO INFORM APP.
*
* DB: SET RETURN CODE TO INFORM APP.
*
* DE: SET RETURN CODE TO INFORM APP.
*
* OFC: IF CONNECTION STILL ESTABLISHED,
* SET FLAG TO STOP LOOPING.
* IF OFC/ABORT/N RECEIVED,
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* RETURN ACCTNG AND LFN INFO TO APP.
* ELSE (NOT OFC/ABORT/N),
* IF OFC/DATA/N RECEIVED,
* IF WAITING FOR END OF OUTPUT JOB,
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* ELSE (INFORM APP ABOUT OFC/DATA/N),
* SET RETURN CODE TO INFORM APP.
* ELSE (IF NOT OFC/ABORT/N NOR OFC/DATA/N),
* IF OFC/EOO RECEIVED,
* IF WAITING FOR END OF OUTPUT JOB,
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* ELSE (INFORM APP ABOUT END OF OUTPUT),
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* RETURN ACCTNG AND LFN INFO TO APP.
* ELSE (EITHER OFC/STPD OR OFC/STP/N),
* RETURN CURRENT PRU POSITION TO APP.
* IF OFC/STPD RECEIVED,
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* IF PM MESSAGE,
* IF APP WANTS PM MSG IN DISPLAY CD,
* IF PM MSG IS TOO LARGE FOR BUF,
* SET TRUCATION FLAG IN NIT.
* REDUCE NO OF CHARS TO CONVERT.
* EXTRACT EACH CHAR IN PM MSG.
* CONVERT EACH CHAR TO DISPLAY CD.
* STORE DISPLAY CODE CHAR IN BUF.
* ELSE (APP WANTS PM MSG AS IS),
* IF PM MSG IS TOO LARGE FOR BUF,
* SET TRUCATION FLAG IN NIT.
* REDUCE NO OF WORDS TO COPY.
* COPY PM MSG TO APP BUFFER.
* STORE SIZE OF PM MSG IN NIT.
* ELSE (MUST BE OFC/STP/N RECEIVED),
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
*
* PRU: SET FLAG TO STOP LOOPING.
* IF ABNORMAL RESPONSE RECEIVED,
* IF PRU/ON PROCESSING ON,
* CALL QTENDT TO TERMINATE CONNECTION.
* SET FLAG TO RESUME LOOPING.
* ELSE (APP SENT PRU/ON SUP MSG),
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
* ELSE (PRU CONNECTION ESTABLISHED),
* UPDATE CONNECTION STATE IN NIT.
* SET RETURN CODE TO INFORM APP.
*
* ELSE (NO SUPERVISORY MESSAGE RECEIVED),
* IF CONNECTION POLLING IS IN EFFECT,
* IF CONNECTION NUMBER IS NOT VALID,
* SKIP TO END AND REJECT QTGET CALL.
* ELSE (VALID CONNECTION NUMBER WAS SPECIFIED),
* CALL NETGET WITH SPECIFIED ACN TO PICK UP DATA.
* ELSE (LIST PROCESSING IS IN EFFECT),
* CALL NETGETL TO PICK UP DATA.
* JUMP ACCORDING TO BLOCK TYPE IN ABH:
*
* NULL: IF SLEEP IS ZERO,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* ELSE (CALL NETWAIT IF NOTHING TO DO),
* IF SLEEP IS NEGATIVE,
* CALL NETWAIT FOR MAXIMUM TIME INTERVAL.
* ELSE (SLEEP IS POSITIVE DIGIT),
* IF NETWAIT HAS ALREADY BEEN CALLED,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* ELSE (NETWAIT HAS NOT BEEN CALLED YET),
* CALL NETWAIT FOR SLEEP TIME INTERVAL.
*
* CMD: IF BI/MARK SYNC SUP MSG RECEIVED,
* IF CONNECTION HAS NOT BEEN TERMINATED
* AND APP WANTS TO BE INFORMED,
* SET FLAG TO STOP LOOPING AND INFORM APP.
* ELSE (SYNC SUP MSG NOT BI/MARK),
* CONTINUE PROCESSING AS DATA BLOCK.
*
* BLK:
* MSG:
* QBLK:
* QMSG: IF CANCEL BIT NOT SET IN ABH,
* UPDATE NIT CONNECTION ENTRY.
* IF IBU BIT SET IN ABH,
* CALL QTENDT TO TERMINATE CONNECTION.
* SET FLAG TO STOP LOOPING AND INFORM APP.
* IF QTRM IS IN MIDDLE OF AUTO BREAK PROCESSING,
* IGNORE BLOCK.
* ELSE (OKAY TO INFORM APP ABOUT DATA BLOCK),
* IF DATA IS IN DISPLAY CODE,
* BLANK FILL LAST WORD OF DATA.
* IF ASCII DATA ON A-A DISPLAY CODE CONNECTION,
* IF DATA BLOCK IS WRONG SIZE,
* CALL QTENDT TO TERMINATE CONNECTION.
* ELSE (DATA BLOCK IS RIGHT SIZE),
* CONVERT COUNT OF CHARS TO DISPLAY CODE VAL.
* SET FLAG TO STOP LOOPING AND INFORM APP.
*
* 4. ENTRY CONDITIONS
* WSA STARTING ADDRESS OF BUFFER AREA IN APPLICATION
* WHERE DATA IS TO BE DELIVERED TO.
*
* 5. EXIT CONDITIONS
* NIT FIELDS UPDATED DEPENDING ON THE RETURN CODE.
* NIT$RC RESPONSE RETURN CODE.
*
* 6. COMDECKS CALLED AND SYMPL TEXTS USED.
* AIPDEF NP$CRT QTRMBUF QTRMCOM
* QTRMNIT
*
* 7. ROUTINES CALLED
* NETDBG AIP TURN AIP TRACE ON/OFF.
* NETGET AIP INPUT FROM NETWORK.
* NETGETL AIP INPUT (LIST) FROM NETWORK.
* NETOFF AIP DISCONNECT FROM NETWORK.
* NETPUT AIP OUTPUT TO NETWORK.
* NETWAIT AIP SUSPEND PROCESSING.
* NP$ERR AIP ERROR DAYFILE ROUTINE.
* QTENDT QTRM END CONNECTION.
* QTTIP QTRM ROUTINE TO SEND SYNC SUP MSG
*
* 8. DAYFILE MESSAGES
* NETWORK APPLICATION ABORTED, RC = 71.
* QTGET: REQUEST INVALID BEFORE QTOPEN.
*
* NETWORK APPLICATION ABORTED, RC = 99.
* QTGET: NETWORK LOGICAL ERROR.
*
*
#
*ENDIF
#
CONTROL DEFINITIONS
#
CONTROL PRESET;
CONTROL PACK;
CONTROL DISJOINT;
CONTROL INERT;
CONTROL FASTLOOP;
#
ROUTINES CALLED
#
XREF
BEGIN
PROC NP$ERR; # AIP ROUTINE TO DAYFILE ERROR MESSAGE #
PROC NETDBG; # AIP ROUTINE TO TURN ON/OFF AIP TRACING #
PROC NETGET; # AIP PROCEDURE TO GET A BLOCK #
PROC NETGETL; # AIP PROCEDURE TO GET A BLOCK ON LIST #
PROC NETPUT; # AIP PROCEDURE TO OUTPUT A BLOCK #
PROC NETOFF; # AIP PROCEDURE TO TERMINATE NAM ACCESS #
PROC NETWAIT; # AIP PROCEDURE TO SUSPEND PROCESSING #
PROC QTENDT; # END A CONNECTION #
PROC QTTIP; # QTRM ROUTINE TO ISSUE SYNC SUP MSG #
END
#
STANDARD DEFS
#
*CALL CRCOM
*CALL QTRMCOM
#
INPUT VARIABLES.
#
ARRAY WSA [0:0] S(1);
# STARTING ADDRESS OF BUFFER IN #
# USER AREA WHERE DATA BLOCK SHOULD #
# BE RETURNED #
BEGIN
ITEM WSA$WORD U(00,00,60); # WHOLE WORD #
ITEM WSA$FC U(00,00,16); # PFC/SFC FOR SYNCHRONOUS COMMANDS #
ITEM WSA$PC U(00,00,08); # PFC FOR SYN COMMAND IN ACT=2 #
ITEM WSA$SC U(00,10,06); # SFC FOR SYN COMMAND IN ACT=2 #
ITEM WSA$P1 U(00,00,12); # PFC FOR SYN COMMAND IN ACT=3 #
ITEM WSA$S1 U(00,14,10); # SFC FOR SYN COMMAND IN ACT=3 #
END
#
LOCAL VARIABLES
#
ARRAY PFC$ARRAY [0:8];
BEGIN
ITEM PFC$VALUE U(0,0,60) = [CON,ERR,FC,SHUT,TCH,INTR,HOP,OFC,
PRU];
END
ITEM RESPONSE B; # EXIT CONTROL VARIABLE #
ITEM NOSLEEP B; # POSITIVE SLEEP CONTROL VARIABLE#
ITEM SLEEP I; #INTERMEDIATE SLEEP VARIABLE#
ITEM MAXWORDS U; # LENGTH USER BUFFER AREA (WORDS)#
ITEM TEMP1 I; # TEMPORARY VARIABLES #
ITEM TEMP2 I; # REASON FOR BREAK #
ITEM TEMP3 I; # TEMPORARY VARIABLE #
ITEM WORDS I; # NUMBER OF FULL WORDS IN BLOCK #
ITEM CHARS I; # NUMBER OF CHARACTORS IN LAST WORD #
ITEM CHARSET I; # CURRENT INPUT CHARACTER SET #
ITEM ACN U; # APPLICATION CONNECTION NUMBER #
ITEM FOUNDMATCH B; # FLAG FOR FINDING MATCH ON PFC SCAN #
ITEM I I; # INDUCTION VARIABLE #
ITEM J I; # INDUCTION VARIABLE #
ITEM NEWCHAR I; # DISPLAY CODE CHAR FROM PM MESSAGE #
ITEM NEWCP I; # CHAR POSITION INDEX FOR PM MESSAGE #
ITEM NEWWP I; # WORD POSITION INDEX FOR PM MESSAGE #
ITEM OLDCP I; # CHAR POSITION INDEX FOR WSA BUFFER #
ITEM OLDWP I; # WORD POSITION INDEX FOR WSA BUFFER #
BASED ARRAY MEM [0:0] S(1); # BASED ARRAY FOR COPYING MEMORY #
BEGIN
ITEM MEM$WORD U(0,0,60); # ONE CENTRAL MEMORY WORD #
END
#
SWITCH DEFINITIONS
#
SWITCH SWTCH$ABT$L ABT$L$NULL, ABT$L$BLK, ABT$L$MSG, ABT$L$CMD,,,
ABT$L$QBLK,ABT$L$QMSG;
SWITCH SWTCH$PFC A$PFC$CON, A$PFC$ERR, A$PFC$FC,
A$PFC$SHUT,A$PFC$TCH,A$PFC$INTR,
A$PFC$HOP,A$PFC$OFC,A$PFC$PRU;
SWITCH SWTCH$FC FC$BRK,FC$RST,FC$ACK,FC$NAK,FC$INACT,,,FC$INIT;
SWITCH SWTCH$HOP HOP$BRK,HOP$CMD,HOP$TRCE,HOP$DU,HOP$IG,
HOP$STRT,HOP$END,HOP$NOTR,HOP$RS,,,,
HOP$PAGE,HOP$REL,HOP$DB,HOP$DE;
CONTROL EJECT;
#
BEGIN QTGET PROCEDURE
#
BEGIN
IF NOT NETON$STATUS # CHECK IF NETON WAS COMPLETED #
THEN
NP$ERR("71"); # REQUEST INVALID BEFORE QTOPEN.#
RESPONSE = FALSE; # INITIALIZE RESPONSE FLAG #
NOSLEEP = FALSE; # PRESET POSITIVE SLEEP OK. #
P<NIT> = NIT$ADDR; # ADDRESS OF NIT TABLE #
NIT$CTLC[0] = 0; # INIT TEXT LENGTH RECEIVED FIELD #
NIT$TRUNC[0] = 0; # INIT TRUNCATION FLAG TO FALSE #
#
DETERMINE APPLICATION BUFFER LENGTH IN WORDS
#
MAXWORDS = NIT$MTLC[0]; # MAX BUF LENGTH IN CHARACTER SET LENGTH#
IF ICTD[0] EQ CT8ASCII
THEN # CHARACTER SET IS 8 BIT ASCII #
BEGIN
MAXWORDS = (NIT$MTLC[0] * 2) / 15; # NO OF CM WORDS #
END
ELSE # NOT 8 BIT ASCII CHARACTER SET #
BEGIN
IF ICTD[0] EQ CT12ASCII
THEN # CHARACTER SET IS 12 BIT ASCII #
BEGIN
MAXWORDS = NIT$MTLC[0] / 5; # NO OF CM WORDS #
END
ELSE # NOT 12 BIT ASCII CHARACTER SET EITHER #
BEGIN
IF ICTD[0] EQ CT6DISPLAY
THEN # CHARACTER SET IS 6 BIT DISPLAY CODE #
BEGIN
MAXWORDS = NIT$MTLC[0] / 10; # NO OF CM WORDS #
END
END
END
#
LOOP UNTIL SOME RESPONSE IS AVAILABLE FOR USER
#
FOR TEMP1=TEMP1 WHILE NOT RESPONSE DO
BEGIN # BEGIN RESPONSE CONTROLLED LOOP #
#
IF CONNECTION POLLING IS IN EFFECT AND THE CONNECTION NUMBER
SPECIFIED WAS NONZERO, THEN WE DO NOT WANT TO GET ANY
ASYNCHRONOUS SUPERVISORY MESSAGES. OTHERWISE, GET ASYNCHRONOUS
SUPERVISORY MESSAGES.
#
IF (CONPOLL ) AND # CONNECTION POLLING IN EFFECT #
(NIT$CON[0] NQ 0) # CONNECTION NUMBER IS NONZERO #
THEN
BEGIN
ABHABT[0] = APPNULL; # ASSUME NO SUP MSG WAS FOUND #
END
ELSE # NEED TO GET ASYNC SUP MSGS #
BEGIN
NETGET(0,HEADER,SUP$MES,63); # GET ASYNC SUP MSGS #
END
# CHECK FOR VALID BLOCK TYPE #
IF ABHABT[0] EQ APPNULL OR ABHABT[0] EQ APPCMD
THEN
BEGIN
# CHECK IF BLOCK TYPE IS SUP OR NULL #
IF ABHABT[0] EQ APPCMD
THEN
#
ASYNC SUPERVISORY MESSAGE BLOCK PROCESSING.
#
BEGIN
FOUNDMATCH = FALSE; # INIT TO NO MATCH ON PFC SCAN #
FOR I = 0 STEP 1 WHILE (I LQ 8 ) AND
(NOT FOUNDMATCH)
DO # CHECK FOR VALID PFC-S #
BEGIN
IF PFC[0] EQ PFC$VALUE[I]
THEN # VALID PFC #
BEGIN
GOTO SWTCH$PFC[I];
A$PFC$CON:
#
SUPERVISORY CONNECTION MESSAGE RECIEVED
#
BEGIN
ACN = CONACN[0]; # APPLICATION CONNECTION NUMBER #
NIT$CON[0] = ACN;
# CHECK IF CON/REQ OR OTHER CON #
IF SFC[0] EQ REQ
THEN
BEGIN
#
CHECK IF DEVICE TYPE OF THIS CONNECTION IS SUPPORTED
#
IF ((SUPDTW[0] LAN 2**(COND[0])) NQ 0)
THEN # THIS DEVICE TYPE IS SUPPORTED #
BEGIN # SET UP NIT ENTRY FOR NEW CON #
NIT$WD0[ACN] = 0;
NIT$WD1[ACN] = 0;
NIT$WD2[ACN] = 0;
NIT$WD3[ACN] = 0;
NIT$WD4[ACN] = 0;
NIT$WD5[ACN] = 0;
NIT$WD6[ACN] = 0;
NIT$WD7[ACN] = 0;
NIT$WD8[ACN] = 0;
NIT$WD9[ACN] = 0;
NIT$STATE[ACN] = S"LIMBO";
NIT$RC[0] = S"CON$REQ"; # SET NIT RETURN CODE #
NIT$DEVTYP[ACN] = COND[0];
NIT$SL[ACN] = CONSL[0]; # SECURITY LEVEL #
NIT$ICT[ACN] = ICTD[0]; # ICT FOR DATA #
NIT$SICT[ACN] = CT8ASCII; # ICT FOR SYNC SUP MSG#
NIT$CDCNT[ACN] = CONNET[0];# CDCNET FLAG #
NIT$UPS[ACN] = CONUPS[0]; # UPLINE BLOCK SIZE #
NIT$DPS[ACN] = CONDPS[0]; # DOWNLINE BLOCK SIZE #
IF ( (COND[0] NQ DT$INTA) AND # INTRAHOST A-A #
(COND[0] NQ DT$INTE) ) # INTERHOST A-A #
THEN
BEGIN
NIT$TNAME[ACN] = CONTNM[0];
NIT$TC[ACN] = CONT[0];
NIT$PW[ACN] = CONPW[0];
NIT$PL[ACN] = CONPL[0];
NIT$FAMNAME[ACN]=CONFAM[0]; # FAMILY NAME #
NIT$USERNAME[ACN]=CONUSE[0]; # USER NAME #
IF CONLST[0] EQ 8
THEN # THIS IS A LOANED CONNECTION #
BEGIN
NIT$LOAN[ACN] = 1; # SET LOAN FLAG #
END
ELSE # NOT SEC APP RECEIVING LOANED CONNECTION#
BEGIN
IF (CONLST[0] GQ 16) AND
(CONLST[0] LQ 23)
THEN # RECONNECTION OF LOANED CONNECTION #
BEGIN
NIT$STATE[ACN] = S"LENDRET"; # SET CON ST #
NIT$RC[0] = S"LEND$RET"; # SET RETURN CODE#
NIT$SB$RC[0] = CONLST[0]; # SET SEC RC #
END
END
CONACT[0] = ICTD[0]; # INPUT CHARACTER TYPE #
END
ELSE # APPL TO APPL CONNECTION #
BEGIN
IF CONABN[0] NQ 0
THEN
BEGIN
NIT$STATE[ACN] = S"POSE";
REQAA = FALSE;
END
NIT$HOSTID[ACN] = CONHID[0]; # APP NAME #
CONACT[0] = ICTD[0]; # INPUT CHARACTER TYPE #
IF ICTD[0] EQ CT6DISPLAY
THEN # INPUT CHAR TYPE IS DISPLAY CODE #
BEGIN
CONACT[0] = CT8ASCII; # ICT IS 8 BIT ASCII #
END
END
CONNXP[0] = NOT ICTX[0]; # REJECT TRANS INPUT #
NIT$ABL[ACN] = CONABL[0];
NIT$BSZ[ACN] = CONDBZ[0] ;
CONALN[0] = 1; # PUT TERMINAL ON LIST = 1 #
RB[0] = TRUE;
IF CONINIT
THEN # APP WANTS TO BE INFORMED ABOUT CON/REQ #
BEGIN
RESPONSE = TRUE;
TEMP2 = ABHTLC[0] - LCONREQ; # LENGTH OF DATA #
IF TEMP2 NQ 0
THEN # DATA WAS PASSED FROM PREVIOUS APP #
BEGIN
IF MAXWORDS GR TEMP2
THEN # WSA BUFFER IS BIG ENOUGH FOR DATA #
BEGIN
NIT$CTLC[0] = TEMP2; # LENGTH OF DATA #
END
ELSE # WSA BUFFER WAS NOT BIG ENOUGH #
BEGIN
NIT$CTLC[0] = MAXWORDS; # LENGTH OF BUF #
NIT$TRUNC[0] = 1; # DATA TRUNCATED FLAG #
TEMP2 = MAXWORDS; # NO OF WORDS TO COPY #
END
P<MEM> = LOC(SUP$MES); # ADDR OF SUP MSG #
FOR J = 0 STEP 1 UNTIL TEMP2 - 1
DO # COPY PASSED DATA TO WSA BUFFER #
BEGIN
WSA$WORD[J] = MEM$WORD[J + LCONREQ];
END
END
END
END
ELSE # REJECT BATCH OR A-A CONNECTION #
BEGIN
EB[0] = TRUE;
CONRRA[0] = S"REJ";
END
CONSCT[0] = FALSE; # SET SYNC SUP MSG ACT = 2 #
ABHTLC[0] = LCORQR;
NETPUT(HEADER,SUP$MES);
END
ELSE # NOT CON/REQ SUPERVISORY MESSAGE #
BEGIN
# CHECK FOR CON/END, CON/CB OR CON/ACRQ/A #
IF SFC[0] EQ CB
THEN # CLEAN UP TABLES FOR BROKEN CONNECTION #
BEGIN
# CHECK IF USER SHOULD BE INFORMED #
TEMP1 = NIT$STATE[ACN];
TEMP3 = RC[0];
IF (TEMP1 NQ STATE"LEND") AND
(TEMP1 NQ STATE"LENT") AND
(TEMP1 NQ STATE"WCONENDN")
THEN # OKAY TO ISSUE CON/END SUP MSG #
BEGIN
NIT$PARMADR[0] = 0; # INIT DATA ADDR #
QTENDT; # END A BROKEN CONNECTION #
IF (CONINIT ) OR
( (TEMP1 NQ STATE"LIMBO" ) AND
(TEMP1 NQ STATE"WAITPRU") )
THEN # INFORM APP ABOUT CONNECTION BROKEN #
BEGIN
RESPONSE = TRUE;
END
IF TEMP1 EQ STATE"POSE"
THEN # BAD CON/REQ RESPONSE CAUSED CON/CB #
BEGIN
NIT$RC[0] = S"ACRQ$ERR";
NIT$S$RC[0] = TEMP3 + 32; # ADJUST SEC RC #
END
ELSE # NORMAL CONNECTION BROKEN #
BEGIN
NIT$RC[0] = S"CON$BROKEN";
NIT$S$RC[0] = S"NORMRET"; # SET SEC-RC FIELD#
NIT$SB$RC[0] = TEMP3; # RC FROM CON/CB #
END
END
ELSE # APP DOES NOT HAVE CONNECTION #
BEGIN
IF TEMP1 NQ STATE"WCONENDN"
THEN # NEED TO INFORM APP AND INIT NIT ENTRY #
BEGIN
RESPONSE = TRUE;
NIT$RC[0] = S"LEND$CB";
NIT$S$RC[0] = S"NORMRET"; # SET SEC-RC FIELD#
NIT$SB$RC[0] = TEMP3; # RC FROM CON/CB #
NIT$STATE[ACN] = S"NULL"; # INIT NIT ENTRY #
END
END
END
ELSE
IF SFC[0] EQ ACRQ
THEN # RECEIVED CON/ACRQ/A SUPERVISORY MESSAGE #
BEGIN
NIT$RC[0] = S"ACRQ$ERR";
NIT$SB$RC = CONRAC[0]; # CON/ACRQ/A RC #
NIT$SEC$RC = CONRAC2[0]; # CON/ACRQ/A SUB RC #
REQAA = FALSE;
NIT$CON[0] = 0;
RESPONSE = TRUE;
END
ELSE # MUST BE CON/END/N SUPERVISORY MESSAGE #
BEGIN
IF NIT$STATE[ACN] EQ S"WCONENDN"
THEN # TERMINATED CONNECTION #
BEGIN
NIT$STATE[ACN] = S"NULL";
END
ELSE # LOANED CONNECTION #
BEGIN
NIT$STATE[ACN] = S"LENT";
END
END
END
GOTO END$A$PFC;
END
A$PFC$ERR:
#
SUPERVISORY ERR MESSAGE BLOCK PROCESSING.
#
BEGIN
#ERROR NETWORK LOGICAL ERROR ENCOUNTERED#
NIT$RC[0] = S"LOGICERR"; # SET RETURN CODE #
NIT$SEC$RC[0] = ERRRLG[0]; # SET SECONDARY RC #
IF NOABTERRLGL
THEN # DO NOT ABORT ON ERR/LGL SUP MSG #
BEGIN
RESPONSE = TRUE;
END
ELSE # ABORT APP WHEN WE RECEIVE ERR/LGL S M #
BEGIN
NP$ERR("99");
END
GOTO END$A$PFC;
END
A$PFC$FC:
#
SUPERVISORY FLOW OF CONTROL
MESSAGE BLOCK PROCESSING.
#
BEGIN
ACN = FCACN[0];
GOTO SWTCH$FC [SFC[0]];
FC$ACK:
#
PROCESS AN ACKNOWLEDGEMENT.
#
BEGIN
NIT$ACK$ABN[ACN] = FCABN[0];
NIT$C$ABL[ACN] = NIT$C$ABL[ACN] + 1;
NOSLEEP = TRUE; # POSITIVE SLEEP NOT OK. #
IF (NIT$STATE[ACN] EQ S"WROMARK") OR
(NIT$STATE[ACN] EQ S"WBIROMK") OR
(NIT$STATE[ACN] EQ S"WTOMARK")
THEN # WAITING FOR FC/ACK TO SEND SYNC SUP MSG #
BEGIN
CHARSET = NIT$CHAR$SET[0]; # SAVE OLD CHAR SET #
NIT$CHAR$SET[0] = CT8ASCII; # APPL CHAR TYPE #
NIT$CON[0] = ACN; # CONNECTION NUMBER #
SPMSG0[0] = 0;
IF NIT$STATE[ACN] EQ S"WTOMARK"
THEN # WAITING TO SEND TO/MARK SUP MSG #
BEGIN
PFCSFC[0] = TOMARK; # PFC/SFC VALUE #
NIT$CTLC[0] = LTOMARK; # LENGTH OF SUP MSG #
END
ELSE # WAITING TO SEND RO/MARK SUP MSG #
BEGIN
PFCSFC[0] = ROMARK; # PFC/SFC VALUE #
NIT$CTLC[0] = LROMARK; # LENGTH OF SUP MSG #
END
QTTIP(SUP$MES); # SEND SYNC SUP MSG #
NIT$CHAR$SET[0] = CHARSET; # RESTORE CHAR SET #
IF (NIT$STATE[ACN] EQ S"WROMARK") OR
(NIT$STATE[ACN] EQ S"WTOMARK")
THEN # ONLY WAITING TO SEND SYNC SUP MSG #
BEGIN
NIT$STATE[ACN] = S"OK"; # SET STATE TO NORMAL #
END
ELSE # STILL WAITING FOR BI/MARK SUP MSG #
BEGIN
NIT$STATE[ACN] = S"USRBRK"; # CHANGE STATE #
END
END
GOTO END$FC;
END
FC$BRK:
#
PROCESS AN UPLINE BREAK ( FOR A-A CONNECTION ONLY )
#
BEGIN
# CHECK IF TERMINAL IS KNOWN TO USER. #
# BRK CAN NOT OCCUR IN LIMBO STATE. #
IF NIT$STATE[ACN] NQ S"WCONENDN"
THEN
BEGIN
RESPONSE = TRUE;
NIT$CON[0] = ACN;
NIT$ABN[ACN] = NIT$ACK$ABN[ACN];
NIT$C$ABL[ACN] = NIT$ABL[ACN];
NIT$RC[0] = S"FC$BRK"; # NIT RETURN CODE #
NIT$SB$RC[0] = FCRBR[0]; # BREAK REASON CODE #
ABHWORD[0] = 0;
ABHABT[0] = APPCMD;
ABHACT[0] = ACFC;
ABHTLC[0] = LFCRST;
SPMSG0[0] = 0;
PFCSFC[0] = FCRST;
FCACN[0] = ACN;
NETPUT(HEADER,SUP$MES); # SEND FC/RST #
END
GOTO END$FC;
END
FC$INACT:
#
PROCESS AN FC/INACT SUPERVISORY MESSAGE
#
BEGIN
IF (NIT$STATE[ACN] NQ S"WCONENDN") AND
(NIT$STATE[ACN] NQ S"LEND")
THEN # CONNECTION HAS NOT BEEN TERMINATED #
BEGIN
NIT$CON[0] = ACN; # APPL CONNECTION NUMBER #
IF (CONINIT) OR
( (NIT$STATE[ACN] NQ S"LIMBO") AND
(NIT$STATE[ACN] NQ S"POSE") AND
(NIT$STATE[ACN] NQ STATE"WAITPRU") AND
(NIT$STATE[ACN] NQ S"LENDRET") )
THEN # APP KNOWS ABOUT CONNECTION #
BEGIN
IF INACTIVE
THEN # APP WANTS TO BE INFORMED ABOUT FC/INACT #
BEGIN
NIT$RC[0] = S"FC$INACT"; # SET RC FIELD #
NIT$SB$RCB[0] = FCATF[0]; # APP SPECIFIED #
# TIMEOUT FLAG #
RESPONSE = TRUE;
END
END
ELSE # APP DOES NOT KNOW ABOUT CONNECTION #
BEGIN
NIT$PARMADR[0] = 0;
QTENDT; # END CN THAT DID NOT RECEIVE FC/INIT #
END
END
GOTO END$FC;
END
FC$INIT:
#
PROCESS AN INITIALIZE.
#
BEGIN
IF (NIT$STATE[ACN] EQ S"LIMBO") OR
(NIT$STATE[ACN] EQ S"POSE") OR
(NIT$STATE[ACN] EQ S"LENDRET")
THEN # EXPECTING FC/INIT/R SUP MSG #
BEGIN
RB[0] = TRUE;
NETPUT(HEADER,SUP$MES); #NORMAL RESP TO FC INIT#
NIT$C$ABL[ACN] = NIT$ABL[ACN];
IF NIT$STATE[ACN] EQ S"POSE"
THEN # A-A CONNECTION REQUEST RESPONSE FC/INIT #
BEGIN
NIT$RC[0] = S"ACRQ$COMPL";
END
ELSE # RECONNECT OR NEW CONNECTION #
BEGIN
IF NIT$STATE[ACN] EQ S"LIMBO"
THEN # NEW CONNECTION #
BEGIN
NIT$RC[0] = S"NEW$CON";
END
ELSE # RECONNECT OF LOANED CONNECTION #
BEGIN
NIT$RC[0] = S"NEW$RECON";
END
END
IF ((PRUDTW[0] LAN 2**(NIT$DEVTYP[ACN])) NQ 0)
THEN # QTRM IS TO SEND PRU/ON SUP MSG #
BEGIN
ABHWORD[0] = 0; # INITIALIZE ABH WORD #
ABHABT[0] = APPCMD; # APPLICATION BLOCK TYPE #
ABHACT[0] = ACPRU; # APPLICATION CHAR TYPE #
ABHTLC[0] = LPRU; # LENGTH OF PRU/ON SUP MSG#
SPMSG0[0] = 0; # INITIALIZE SUP MSG WORD #
PFCSFC[0] = PRUON; # PFC/SFC FOR PRU/ON S M #
PRUACN[0] = ACN; # CN FOR PRU/ON SUP MSG #
IF NIT$DEVTYP[ACN] EQ DT$CR
THEN # UPLINE (INPUT) DEVICE #
BEGIN
PRUUPS[0] = NIT$UPS[ACN]; # UPLINE PRU SIZE #
END
ELSE # DOWNLINE (OUTPUT) DEVICE#
BEGIN
PRUDPS[0] = NIT$DPS[ACN]; # DOWNLINE PRU SIZ#
END
NETPUT(HEADER,SUP$MES); # SEND PRU/ON SUP MSG #
NIT$STATE[ACN] = STATE"WAITPRU"; #CHANGE STATE#
END
ELSE # INFORM APP ABOUT NEW CONNECTION NOW #
BEGIN
RESPONSE = TRUE; # TERMINATE LOOP #
NIT$STATE[ACN] = STATE"OK"; # CHANGE STATE #
NIT$CON[0] = ACN; # APP CONNECTION NUMBER #
END
END
GOTO END$FC;
END
FC$NAK:
#
PROCESS A NAK.
#
BEGIN
IF NIT$STATE[ACN] NQ S"WCONENDN"
THEN
BEGIN
RESPONSE = TRUE;
NIT$CON[0] = ACN;
NIT$PARMADR[0] = 0;
QTENDT; # END CONNECTION WHICH HAD THE NAK #
NIT$RC[0] = S"CON$BROKEN";
NIT$S$RC[0] = S"RECNAK"; # SET SEC-RC FIELD #
END
GOTO END$FC;
END
FC$RST:
#
PROCESS AN RESET RESPONSE
#
BEGIN
IF NIT$STATE[ACN] EQ S"FCBRK"
THEN # CONNECTION HAS NOT BEEN ENDED #
BEGIN
NIT$STATE[ACN] = S"OK"; # BACK TO NORMAL STATE #
NIT$RC[0] = S"FC$RST"; # SET RETURN CODE FIELD #
NIT$CON[0] = ACN; # CONNECTION NUMBER #
NIT$C$ABL[ACN] = NIT$ABL[ACN];
RESPONSE = TRUE;
END
GOTO END$FC; # GO TO END OF FC CASE STATEMENT #
END
END$FC:
GOTO END$A$PFC;
END
A$PFC$SHUT:
#
SUPERVISORY SHUTDOWN MESSAGE BLOCK PROCESSING.
#
BEGIN
IF SFC[0] EQ INSD
THEN
BEGIN
IF SHUTF[0]
# IF A FORCED SHUTDOWN #
THEN
BEGIN
NETOFF;
NIT$RC[0] = S"SHUTDOWN";
RESPONSE = TRUE;
END
ELSE
BEGIN
NIT$RC[0] = S"IDLEDOWN";
RESPONSE = TRUE;
END
END
GOTO END$A$PFC;
END
A$PFC$TCH:
#
SUPERVISORY CHANGE TERMINAL CHARACTERISTIC
MESSAGE BLOCK PROCESSING.
#
BEGIN
ACN = TCHACN[0]; # APPLICATION CONNECTION NUMBER #
NIT$PW[ACN] = TCHPW[0]; # PAGE WIDTH #
NIT$PL[ACN] = TCHPL[0]; # PAGE LENGTH #
NIT$TC[ACN] = TCHTCL[0]; # TERMINAL CLASS #
GOTO END$A$PFC;
END
A$PFC$INTR:
#
INTRRUPT PROCESSING
#
BEGIN
TEMP2 = INTRCHR[0]; # USER INTERRUPT CHARACTER #
ACN = INTRACN[0]; # APPLICATION CONNECTION NUMBER #
NIT$CON[0] = ACN;
IF (NIT$STATE[ACN] EQ S"INTRRSP") AND
(SFC[0] EQ RSP)
THEN # INTERRUPT RESPONSE RECEIVED #
BEGIN
NIT$STATE[ACN] = S"OK"; # SET TO NORMAL STATE #
NIT$RC[0] = S"INTR$RSP"; # SET RETURN CODE IN NIT #
RESPONSE = TRUE;
END
ELSE # INTERRUPT USER RECEIVED #
BEGIN
IF (NIT$STATE[ACN] NQ S"WCONENDN") AND
(NIT$STATE[ACN] NQ S"LEND")
THEN # CONNECTION HAS NOT BEEN TERMINATED #
BEGIN
IF (NIT$DEVTYP[ACN] EQ 0) AND
((TEMP2 EQ RIR"UB1") OR
(TEMP2 EQ RIR"UB2"))
THEN # USER BREAK ENTERED FROM TERMINAL #
BEGIN
NIT$STATE[ACN] = S"USRBRK"; # UPDATE STATE #
IF (NOT BREAKMARK) AND
(NIT$C$ABL[ACN] NQ 0)
THEN # QTRM NEEDS TO SEND RO/MARK FOR APP #
BEGIN
CHARSET = NIT$CHAR$SET[0]; # SAVE CHAR SET #
NIT$CHAR$SET[0] = CT8ASCII; # APPL CHAR TYPE#
NIT$CTLC[0] = LROMARK; # LENGTH OF SUP MSG #
SPMSG0[0] = 0;
PFCSFC[0] = ROMARK; # PFC/SFC VALUE #
QTTIP(SUP$MES); # SEND SYNC SUP MSG #
NIT$CHAR$SET[0] = CHARSET; # RESTORE CHR SET#
END
ELSE # CANNOT SEND RO/MARK SUP MSG #
BEGIN
IF NOT BREAKMARK
THEN # QTRM WILL SEND RO/MARK AFTER FC/ACK #
BEGIN
NIT$STATE[ACN] = S"WBIROMK"; # NEW STATE #
END
END
IF NOT AUTOBREAK
THEN # NEED TO INFORM APP ABOUT USER BREAK #
BEGIN
IF TEMP2 EQ RIR"UB1"
THEN # USER BREAK ONE OCCURRED #
BEGIN
NIT$RC[0] = S"USER$B1"; # SET RETURN CODE #
END
ELSE # USER BREAK TWO OCCURRED #
BEGIN
NIT$RC[0] = S"USER$B2"; # SET RETURN CODE #
END
RESPONSE = TRUE;
END
END
ELSE # USER OR APPLICATION INTERRUPT OCCURRED #
BEGIN
NIT$SB$RC[0] = INTRCHR[0]; # INTERRUPT CHAR #
IF USERINTR
THEN # INFORM APP ABOUT USER/APPLICATION INTR #
BEGIN
NIT$RC[0] = S"USR$INTR"; # SET RETURN CODE #
RESPONSE = TRUE;
END
END
ABHWORD[0] = 0;
ABHABT[0] = APPCMD; # APPLICATION BLOCK TYPE #
ABHACT[0] = ACINTR; # APPLICATION CHARACTER TYPE#
ABHTLC[0] = LINTR; # LENGTH OF SUPERVISORY MSG #
SPMSG0[0] = 0;
PFCSFC[0] = INTRRSP; # PFC/SFC VALUE FOR INTR/RS#
INTRACN[0] = ACN; # APPLICATION CONNECTION NUM #
NETPUT(HEADER,SUP$MES); # SEND INTR/RSP SUP MSG #
END
END
GOTO END$A$PFC;
END
A$PFC$HOP:
#
HOST OPERATOR COMMAND PROCESSING
#
BEGIN
RESPONSE = TRUE; # INFORM APP UNLESS OTHERWISE #
GOTO SWTCH$HOP [SFC[0]];
HOP$BRK:
#
PROCESS AN OPERATOR BREAK
#
BEGIN
IF KDISPLAY
THEN # APP SUPPORTS K-DISPLAY #
BEGIN
NIT$RC[0] = S"HOP$BRK"; # SET RETURN CODE #
END
ELSE # IGNORE SUPERVISORY MESSAGE #
BEGIN
RESPONSE = FALSE; # DO NOT INFORM APP #
END
GOTO END$HOP;
END
HOP$CMD:
#
PROCESS AN OPERATOR TYPEIN
#
BEGIN
IF KDISPLAY
THEN # APP SUPPORTS K-DISPLAY #
BEGIN
NIT$RC[0] = S"HOP$CMD"; # SET RETURN CODE #
TEMP2 = ABHTLC[0] - 1; # NO OF CM WDS OF TYPE IN#
IF MAXWORDS GR TEMP2
THEN # WSA BUFFER IS BIG ENOUGH FOR TYPE IN #
BEGIN
NIT$CTLC[0] = HOPDTL[0]; # NO OF CHARS TYPED #
END
ELSE # WSA BUFFER IS NOT LONG ENOUGH #
BEGIN
NIT$TRUNC[0] = 1; # SET SUP MSG TRUNCATED FLAG#
NIT$CTLC[0] = MAXWORDS * 10; # NO OF CHARS #
TEMP2 = MAXWORDS; # NO OF WORDS TO COPY TO BUF#
END
P<MEM> = LOC(SUP$MES); # ADDRESS OF SUP MSG #
FOR J = 0 STEP 1 UNTIL TEMP2 - 1
DO # COPY OPERATOR TYPEIN TO WSA BUFFER #
BEGIN
WSA$WORD[J] = MEM$WORD[J+1]; # OPER TYPEIN TXT#
END
END
ELSE # IGNORE SUPERVISORY MESSAGE #
BEGIN
RESPONSE = FALSE; # DO NOT INFORM APP #
END
GOTO END$HOP;
END
HOP$TRCE:
#
PROCESS AN OPERATOR REQUEST TO BEGIN AIP TRACING
#
BEGIN
NETDBG(1,1,SUP$MES); # TURN AIP TRACING ON #
RESPONSE = FALSE;
GOTO END$HOP;
END
HOP$DU:
#
PROCESS AN OPERATOR REQUEST TO DUMP FIELD LENGTH
#
BEGIN
NIT$RC[0] = S"HOP$DU"; # SET RETURN CODE #
GOTO END$HOP;
END
HOP$IG:
#
PROCESS AN OPERATOR REQUEST TO NOT SEND ALERTS
#
BEGIN
IGNORE = TRUE; # SET FLAG TO NOT SEND HOP/ALT #
RESPONSE = FALSE;
GOTO END$HOP;
END
HOP$STRT:
#
PROCESS OPERATOR ASSIGNMENT OF K-DISPLAY TO THIS APP
#
BEGIN
IGNORE = FALSE; # CLEAR FLAG TO NOT SEND HOP/ALT #
IF KDISPLAY
THEN # APPLICATION SUPPORTS K-DISPLAY #
BEGIN
KDISAS = TRUE; # SET K-DISPLAY ASSIGNED FLAG #
NIT$RC[0] = S"HOP$START"; # SET RETURN CODE #
IF MAXWORDS NQ 0
THEN # WSA BUFFER IS AT LEAST ONE WORD LONG #
BEGIN
WSA$WORD[0] = SPMSG0[0]; # 1ST WD OF SUP MSG #
END
ELSE # WSA BUFFER IS ZERO WORDS LONG #
BEGIN
NIT$TRUNC[0] = 1; # SET SUP MSG TRUNCATED FLAG#
END
END
ELSE # DO NOT INFORM APPLICATION #
BEGIN
RESPONSE = FALSE;
END
GOTO END$HOP;
END
HOP$END:
#
PROCESS OPERATOR TERMINATION OF K-DISPLAY ASSIGNMENT
#
BEGIN
IF KDISPLAY
THEN # APPLICATION SUPPORTS K-DISPLAY #
BEGIN
KDISAS = FALSE; # CLEAR K-DISPLAY ASSIGNED FLAG #
NIT$RC[0] = S"HOP$END"; # SET RETURN CODE #
END
ELSE # DO NOT INFORM APPLICATION #
BEGIN
RESPONSE = FALSE;
END
GOTO END$HOP;
END
HOP$NOTR:
#
PROCESS AN OPERATOR REQUEST TO END AIP TRACING
#
BEGIN
NETDBG(0,0,SUP$MES); # TURN AIP TRACING OFF #
RESPONSE = FALSE;
GOTO END$HOP;
END
HOP$RS:
#
PROCESS AN OPERATOR REQUEST TO RESET STATISTICS
#
BEGIN
NIT$RC[0] = S"HOP$RS"; # SET RETURN CODE #
GOTO END$HOP;
END
HOP$PAGE:
#
PROCESS AN OPERATOR REQUEST TO CHANGE PAGING
#
BEGIN
IF KDISPLAY
THEN # APPLICATION SUPPORTS K-DISPLAY #
BEGIN
NIT$RC[0] = S"HOP$PAGE"; # SET RETURN CODE #
NIT$SBC$RC[0] = HOPPC[0]; # PAGE CHARACTER #
END
ELSE # DO NOT INFORM APPLICATION #
BEGIN
RESPONSE = FALSE;
END
GOTO END$HOP;
END
HOP$REL:
#
PROCESS AN OPERATOR REQUEST TO RELEASE AIP DEBUG
LOG FILE
#
BEGIN
NIT$RC[0] = S"HOP$REL"; # SET RETURN CODE #
GOTO END$HOP;
END
HOP$DB:
#
PROCESS AN OPERATOR REQUEST TO TURN ON DEBUG CODE
#
BEGIN
NIT$RC[0] = S"HOP$DB"; # SET RETURN CODE #
GOTO END$HOP;
END
HOP$DE:
#
PROCESS AN OPERATOR REQUEST TO TURN OFF DEBUG CODE
#
BEGIN
NIT$RC[0] = S"HOP$DE"; # SET RETURN CODE #
GOTO END$HOP;
END
END$HOP: # END OF HOP CASE STATEMENT #
GOTO END$A$PFC;
END
A$PFC$OFC:
#
PRU OUTPUT DEVICE SUPERVISORY MESSAGE PROCESSING
#
BEGIN
ACN = OFCACN[0]; # ACN FROM OFC SUP MSG #
NIT$CON[0] = ACN; # APPLICATION CONNECTION NUMBER #
IF NIT$STATE[ACN] NQ STATE"WCONENDN" AND
NIT$STATE[ACN] NQ STATE"LEND"
THEN # APP STILL NOWS ABOUT CONNECTION #
BEGIN
RESPONSE = TRUE; # INFORM APP UNLESS OTHERWISE #
IF SFC[0] EQ ABRT
THEN # RECEIVED OFC/ABT/N SUP MSG #
BEGIN
NIT$STATE[ACN] = STATE"PRUEOO"; # CHANGE STATE #
NIT$RC[0] = NITRTC"OFCABTN"; # NIT RETURN CODE #
WSA$WORD[0] = OFCCURP[0]; # ACCOUNTING DATA #
WSA$WORD[1] = OFCPAR[0]; # LFN AND FNT ADR #
END
ELSE # DID NOT RECEIVE OFC/ABT/N SUP MSG #
BEGIN
IF SFC[0] EQ DATA
THEN # RECEIVED OFC/DATA/N SUP MSG #
BEGIN
IF NIT$STATE[ACN] EQ STATE"PRUEOO"
THEN # OFC/DATA/N WAS RESPONSE TO ACCTNG MSG #
BEGIN # OUTPUT JOB HAS ENDED #
NIT$STATE[ACN] = STATE"PRUCN"; # CHG STATE #
NIT$RC[0] = NITRTC"OFCEOJ"; # NIT RETURN CODE#
END
ELSE # OFC/DATA/N WAS RESPONSE TO BANNER MSG #
BEGIN
NIT$RC[0] = NITRTC"OFCDATAN"; # NIT RC #
END
END
ELSE # DID NOT RECEIVE OFC/DATA/N NOR OFC/ABT/N#
BEGIN
IF SFC[0] EQ EOO
THEN # RECEIVED OFC/EOO SUP MSG #
BEGIN
IF NIT$STATE[ACN] EQ STATE"PRUEOO"
THEN # COMPLETED TRANSFR OF OUTPUT JB#
BEGIN
NIT$STATE[ACN] = STATE"PRUCN"; # CHG STATE#
NIT$RC[0] = NITRTC"OFCEOJ"; # NIT RC #
END
ELSE # COMPLETED TRANSFR OF OUTPUT FL#
BEGIN
NIT$STATE[ACN] = STATE"PRUEOO"; # CHG STATE#
NIT$RC[0] = NITRTC"OFCEOO"; # NIT RC #
WSA$WORD[0] = OFCACNT[0]; # ACCOUNTING DATA#
WSA$WORD[1] = OFCPAR[0]; # LFN AND FNT ADR #
END
END
ELSE # RECEIVED OFC/STPD OR OFC/STP/N#
BEGIN
WSA$WORD[0] = OFCCURP[0]; # CURRENT PRU POS #
IF SFC[0] EQ STPD
THEN # RECEIVED OFC/STPD SUP MSG #
BEGIN
NIT$RC[0] = NITRTC"OFCSTPD"; # NIT RC #
NIT$SB$RC[0] = OFCRC[0]; # RC FOR STPD CON#
IF OFCRC[0] EQ ROS"MSE"
THEN # PIP STOPPED PRU TRAFFIC #
BEGIN
NIT$STATE[ACN] = STATE"PRUSTPP";
END
ELSE # NETWORK STOPPED PRU TRAFFIC #
BEGIN
NIT$STATE[ACN] = STATE"PRUSTPD";
IF OFCRC[0] EQ ROS"PMI"
THEN # PM MESSAGE TO COPY TO WSA #
BEGIN
TEMP2 = OFCPMCC[0]; # NO OF CHARS #
IF PMCONV NQ 0
THEN # NEED TO CONVERT PM MESSAGE #
BEGIN
IF MAXWORDS LS TEMP2/10
THEN # WSA BUFFER IS NOT BIG ENOUGH #
BEGIN
NIT$TRUNC[0] = 1; # PM MSG TRUNCATD#
TEMP2 = MAXWORDS*10; # SIZE OF PM #
END
OLDCP = 5; # INIT CHAR POS IN PM MSG #
OLDWP = 2; # INIT WORD POS IN PM MSG #
NEWCP = 0; # INIT CHAR POS IN WSA #
NEWWP = 1; # INIT WORD POS IN WSA #
P<MEM> = LOC(SUP$MES);
#
PM MESSAGES ARE ASSUMED TO BE IN 8/12
ASCII. IF CDCNET IS LATER ENHANCED
TO SEND PM MESSAGES IN 6/12 DISPLAY
CODE OR A QTRM APPLICATION IS USING
PRU INTERFACE ON 2550 NETWORK, THEN
THIS CODE WILL NEED TO BE CHANGED TO
SUPPORT PM MESSAGES IN 6/12 DISPLAY
CODE.
#
FOR J = 1 STEP 1 UNTIL TEMP2
DO # CONVERT CHARS ONE AT A TIME #
BEGIN
TEMP1 =
B<OLDCP
,7>MEM
$WORD
[OLDWP
]; TEMP3 = TEMP1/10; # WRD INDEX #
TEMP1 = TEMP1 - TEMP3*10; # CHR IDX#
NEWCHAR = B<TEMP1*6,6>CONVW[TEMP3];
IF PMCONV EQ 2
THEN # CONVERT TO CONSOLE DISPLAY #
BEGIN
IF NEWCHAR GQ O"60"
THEN # NEED TO BLANK SPECIAL CHR#
BEGIN
NEWCHAR = O"55"; # BLANK CHAR #
END
END
B<NEWCP,6>WSA$WORD[NEWWP] = NEWCHAR;
OLDCP = OLDCP + 12; # NEXT PM CHAR#
IF OLDCP GQ 65
THEN # REACHED END OF THIS PM WORD#
BEGIN
OLDCP = 5; # INIT CHAR POS IN PM #
OLDWP = OLDWP + 1; # NEXT PM WORD#
END
NEWCP = NEWCP + 6; # NEXT WSA POS #
IF NEWCP GQ 60
THEN # REACHED END OF THS WSA WORD#
BEGIN
NEWCP = 0; # INIT CHAR POS IN WSA#
NEWWP = NEWWP + 1; # NEXT WSA WRD#
END
END
END
ELSE # COPY PM MSG TO WSA AS IS #
BEGIN
TEMP3 = ABHTLC[0] - 2; # NO OF WDS #
IF MAXWORDS LS TEMP3
THEN # WSA BUFFER IS NOT BIG ENOUGH #
BEGIN
NIT$TRUNC[0] = 1; # PM MSG TRUNCATD#
TEMP2 = MAXWORDS*5; # NO OF CHARS #
TEMP3 = MAXWORDS; # NO OF WDS #
END
P<MEM> = LOC(SUP$MES) + 1;
FOR J = 1 STEP 1 UNTIL TEMP3
DO # COPY PM MESSAGE TO WSA BUFFER #
BEGIN
WSA$WORD[J] = MEM$WORD[J];
END
END
NIT$CTLC[0] = TEMP2; # SIZE OF PM MSG #
END
END
END
ELSE # RECEIVED OFC/STP/N SUP MSG #
BEGIN
NIT$STATE[ACN] = STATE"PRUSTPN";
NIT$RC[0] = NITRTC"OFCSTPN"; # NIT RC #
END
END
END
END
END
GOTO END$A$PFC; # GO TO END OF CASE STATEMENT #
END
A$PFC$PRU:
#
PRU CONNECTION ESTABLISHMENT PROCESSING
#
BEGIN
ACN = PRUACN[0]; # ACN FROM PRU SUP MSG #
NIT$CON[0] = ACN; # APPLICATION CONNECTION NUMBER #
RESPONSE = TRUE; # SET FLAG TO STOP LOOPING #
IF EB[0]
THEN # ABNORMAL RESPONSE RECEIVED #
BEGIN
IF NIT$STATE[ACN] EQ STATE"WAITPRU"
THEN # APPLICATION DOES NOT KNOW ABOUT CON #
BEGIN
NIT$PARMADR[0] = 0;
QTENDT;
RESPONSE = FALSE;# CLEAR FLAG TO CONTINUE LOOPING#
END
ELSE # INFORM APP THAT PRU CON NOT ESTABLISHED #
BEGIN
NIT$STATE[ACN] = STATE"OK";
NIT$RC[0] = NITRTC"PRUONA"; # SET RETURN CODE #
NIT$SB$RC[0] = PRURC[0]; # RC FROM PRU/ON/A #
END
END
ELSE # PRU CONNECTION ESTABLISHED #
BEGIN
NIT$STATE[ACN] = STATE"PRUCN";
NIT$RC[0] = NITRTC"PRUONN"; # SET RETURN CODE #
END
GOTO END$A$PFC; # GO TO END OF CASE STATEMENT #
END
END$A$PFC:
FOUNDMATCH = TRUE; # END FOR LOOP FOR PFC SCAN #
END
END
IF (CONPOLL ) AND
(NOT RESPONSE)
THEN
BEGIN
NIT$CON[0] = 0; # RESET POLLING TO ASYNC #
END
END
ELSE
#
NO ASYNCHRONOUS SUPERVISORY MESSAGE HAS BEEN PROCESSED.
TRY TO GET DATA FOR APPLICATION.
#
BEGIN
#
IF CONNECTION POLLING IS IN EFFECT, THE CONNECTION NUMBER
MUST BE CHECKED BEFORE WE ISSUE THE NETGET CALL. IF AN
INVALID CONNECTION NUMBER WAS SPECIFIED, THE QTGET CALL IS
REJECTED.
#
IF CONPOLL
THEN # CONNECTION POLLING IS IN EFFECT #
BEGIN
IF NIT$CON[0] NQ 0
THEN # NONZERO CONNECTION NUMBER WAS SPECIFIED #
BEGIN
#
CHECK IF SPECIFIED CONNECTION NUMBER IS VALID
#
IF (NIT$CON[0] GR NIT$NO$TERMS[0] ) OR
(NIT$STATE[NIT$CON[0]] EQ S"NULL" ) OR
(NIT$STATE[NIT$CON[0]] EQ S"LEND" ) OR
(NIT$STATE[NIT$CON[0]] EQ S"LENT" ) OR
(NIT$STATE[NIT$CON[0]] EQ S"WCONENDN")
THEN # BAD CONNECTION NUMBER WAS SPECIFIED #
BEGIN
NIT$RC[0] = S"QTGETREJ"; # SET QTGET REJECT RC #
IF (NIT$STATE[NIT$CON[0]] EQ S"LEND" ) OR
(NIT$STATE[NIT$CON[0]] EQ S"LENT" )
THEN # CONNECTION HAS BEEN LOANED TO ANOTHER AP#
BEGIN
NIT$S$RC[0] = S"CONLOANED"; # STORE REASON FOR REJ#
END
ELSE # BAD CONNECTION NUMBER WAS SPECIFIED #
BEGIN
NIT$S$RC[0] = S"BADCN"; # STORE REASON FOR BAD CAL#
END
RESPONSE = TRUE; # TERMINATE LOOPING AND RETURN #
GOTO END$ABT$L;
END
ELSE # OKAY TO GET DATA FOR GIVEN CONNECTION NO#
BEGIN
NETGET(NIT$CON[0],HEADER,WSA,MAXWORDS); # GET DATA #
END
END
END
ELSE # LIST PROCESSING IS IN EFFECT #
BEGIN
#
TRY TO GET DATA MESSAGE FROM ANY CONNECTION
ALL CONNECTIONS ARE ON LIST = 1.
#
NETGETL(1,HEADER,WSA,MAXWORDS); # GET DATA FROM LIST #
END
BEGIN # BEGIN LIST = 1 ABT CASES #
GOTO SWTCH$ABT$L [ABHABT[0]];
ABT$L$NULL:
#
NO MESSAGE BLOCKS ARE AVAILABLE
#
BEGIN
NIT$RC[0] = S"NOBLK"; #PRESET RC TO NO BLOCK AVAIL #
IF NIT$SLEEP NQ 0
THEN
SLEEP = NIT$SLEEP;
ELSE
SLEEP = NIT$XSLEEP;
IF SLEEP EQ 0
THEN
BEGIN
RESPONSE = TRUE;
END
ELSE # IF SLEEP NQ 0 #
BEGIN
IF SLEEP LS 0
THEN
BEGIN
NETWAIT(4095,0); #WAIT UNTIL INPUT BLOCK AVAIL#
END
ELSE # IF SLEEP GT 0 #
BEGIN
IF NOSLEEP
THEN
RESPONSE = TRUE;
ELSE
BEGIN
NETWAIT(SLEEP,0);
NOSLEEP = TRUE; #ONLY SLEEP ONCE#
END;
END; #SLEEP GT 0 #
END; #IF SLEEP NQ 0#
GOTO END$ABT$L;
END
ABT$L$CMD:
#
SYNCHRONOUS COMMAND BLOCK PROCESSING
#
BEGIN
IF (ABHACT[0] EQ CT8ASCII
AND WSA$FC[0] EQ BIMARK)
OR (ABHACT[0] EQ CT12ASCII
AND WSA$P1[0] EQ BI
AND WSA$S1[0] EQ MARK)
THEN # RECEIVED BREAK MARKER SYNC SUP MSG #
BEGIN
ACN = ABHADR[0]; # APPLICATION CONNECTION NUMBER #
NIT$CON[0] = ACN;
IF (NIT$STATE[ACN] NQ S"WCONENDN") AND
(NOT AUTOBREAK) AND
(BREAKMARK)
THEN # INFORM APPLICATION ABOUT BREAK MARKER #
BEGIN
NIT$RC[0] = S"BI$MARK"; # SET RETURN CODE IN NIT#
RESPONSE = TRUE;
END
IF (NIT$STATE[ACN] EQ S"USRBRK") OR
(BREAKMARK)
THEN # WAITING FOR BI/MARK STATE #
BEGIN
NIT$STATE[ACN] = S"OK"; # BACK TO NORMAL STATE #
END
ELSE # WAITING FOR BI/MARK AND TO SEND RO/MARK #
BEGIN
NIT$STATE[ACN] = S"WROMARK"; # CHANGE STATE #
END
GOTO END$ABT$L;
END
END
ABT$L$BLK:
#
BLOCK BLOCK PROCESSING
#
ABT$L$MSG:
#
MESSAGE BLOCK PROCESSING
#
ABT$L$QBLK:
#
QUALIFIED BLOCK BLOCK PROCESSING
#
ABT$L$QMSG:
#
QUALIFIED MESSAGE BLOCK PROCESSING
#
IF ABHCAN NQ 0
THEN
GOTO END$ABT$L ; # IGNORE THIS MSG BLOCK AND #
# GO GET ANOTHER ONE #
BEGIN
ACN = ABHADR[0]; # APPLICATION CONNECTION NUMBER #
NIT$CON[0] = ACN;
# IF INPUT BLOCK UNDELIVERABLE OR #
IF ABHIBU[0] EQ 1
THEN # BREAK OFFENDING CONNECTION #
BEGIN
NIT$PARMADR[0] = 0;
QTENDT;
NIT$RC[0] = S"CON$BROKEN";
NIT$S$RC[0] = S"IBUSET"; # SET SEC RC FIELD IN NIT #
END
ELSE # DATA BLOCK WAS DELIVERED FROM NIP #
BEGIN
IF (AUTOBREAK) AND
( (NIT$STATE[ACN] EQ S"USRBRK") OR
(NIT$STATE[ACN] EQ S"WBIROMK") )
THEN
BEGIN
GOTO END$ABT$L; # IGNORE THIS MSG BLOCK AND #
# GO GET ANOTHER ONE #
END
IF ABHABT[0] EQ APPCMD # SYNCHRONOUS SUPERVISORY #
THEN # MESSAGE #
BEGIN
NIT$RC[0] = S"UNS$SCMD"; # REASON CODE 29 #
END
ELSE
BEGIN
NIT$RC[0] = S"OK"; # REGULAR DATA MESSAGE #
END
NIT$UP$ABH[NIT$CON[0]] = ABHWORD[0];
NIT$CTLC[0] = ABHTLC[0];
IF ABHTRU[0] NQ 0
THEN # DATA HAS BEEN TRUNCATED #
BEGIN
NIT$TRUNC[0] = 1; # SET TRUNCATION FLAG IN NIT #
END
IF ABHACT[0] EQ CT6DISPLAY
THEN
BEGIN
WORDS = ABHTLC[0] / WC;
CHARS = ABHTLC[0] - (WORDS * WC);
FOR TEMP3 = CHARS STEP 1 UNTIL 9 DO
BEGIN
C<TEMP3,1> WSA$WORD[WORDS] = " ";
END
END
ELSE
BEGIN
IF (ABHACT[0] EQ CT8ASCII) AND
(ICTD[0] EQ CT6DISPLAY) AND
(ABHABT[0] NQ APPCMD) AND
(NIT$DEVTYP[ACN] NQ 0)
THEN # NEED TO CHECK AND CONVERT SIZE OF MSG #
BEGIN
TEMP3 = ABHTLC[0] - (ABHTLC[0]/3)*3;
IF TEMP3 NQ 0
THEN # APP RECEIVED WRONG SIZE BLOCK FROM APP #
BEGIN
NIT$PARMADR[0] = 0;
QTENDT; # TERMINATE CONNECTION #
NIT$RC[0] = S"CON$BROKEN"; # STORE RETURN CODE#
NIT$S$RC[0] = S"RECBSZ"; # SET SEC RC FIELD #
END
ELSE # DIS CODE BLOCK ON A-A CON HAD RIGHT SIZE#
BEGIN
NIT$CTLC[0] = (ABHTLC[0]/3)*4; # NO OF CHARS #
END
END
END
END
RESPONSE = TRUE;
GOTO END$ABT$L;
END
END$ABT$L:
END
END
END # END ACN = 0 CASES #
END # END RESPONCE CONTROLLED LOOP #
RETURN;
END
TERM