*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$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 = 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 = 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 = 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 = BMEM$WORD[OLDWP]; TEMP3 = TEMP1/10; # WRD INDEX # TEMP1 = TEMP1 - TEMP3*10; # CHR IDX# NEWCHAR = BCONVW[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 BWSA$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 = 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 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