*DECK NVFTPUV USETEXT TEXTNVF USETEXT TEXTSS USETEXT TXTANVF USETEXT TXSMNVF USETEXT TXTAPSS PROC NVFTPUV((PT)); # TITLE NVFTPUV - PROCESS UNSUCCESSFUL VALIDATION # BEGIN # NVFTPUV # # ** NVFTPUV - PROCESS UNSUCCESSFUL VALIDATION. * * E. THAVIKULWAT 81/10/23 * C. BRION 83/10/10 * * THIS PROCEDURE'S MAIN FUNCTION IS TO ISSUE APPROPRIATE ERROR * MESSAGE AND DETERMINE WHETHER TERMINAL SHOULD BE PROMPTED AGAIN * UPON A UNSUCCESSFUL USER OR APPLICATION VALIDATION. IT IS CALLED * INTO EXECUTION BY THE FOLLOWING PROCEDURES: * *NVFTETI* *NVFTVAA* *NVFTVVD* * * PROC NVFTPUV((PT)) * * ENTRY: * PT = POINTER TO PTAC ENTRY * * EXIT: * APPROPRIATE ERROR MESSAGE ISSUED TO THE TERMINAL. * * NOTES: * FOR UNSUCCESSFUL USER VALIDATION, NO FURTHER PROMPTS ARE * ISSUED IF ANY OF THE FOLLOWING IS TRUE: * 1) FAMILY AND USER ARE BOTH MANDATORY * 2) SECURITY COUNT EXHAUSTED * 3) USER NOT VALIDATED FOR ANY APPLICATION * 4) USER RETRY LIMIT EXCEEDED * * FOR UNSUCCESSFUL APPLICATION VALIDATION, NO FURTHER APPLICATION * PROMPT IS ISSUED IF ANY OF THE FOLLOWING IS TRUE: * 1) APPLICATION IS MANDATORY OR IMPLIED MANDATORY * 2) APPLICATION RETRY LIMIT EXCEEDED * * IF APPLICATION FAILED OR NETTED OFF WITH CONNECTIONS * OUTSTANDING, THE APPLICATION RETRY LIMIT IS INCREASED TO 25. * * METHOD: * INCREMENT APPROPRIATE RETRY COUNT BY 1. DETERMINE IF PROMPT * SHOULD BE REISSUED. IF NOT, SEND ERROR MESSAGE TO TERMINAL AND * CALL *NVFTETC* TO END TERMINAL CONNECTION. OTHERWISE, SEND * ERROR MESSAGE TO TERMINAL AND CALL *NVFTILP* TO REISSUE PROMPT. # # **** PROC NVFTPUV - XREF LIST. # XREF BEGIN PROC NVFTETC; # END TERMINAL CONNECTION # PROC NVFTILP; # ISSUE LOGIN PROMPT # PROC NVFTIAM; # ISSUE ACCOUNTING MESSAGES # PROC NVFUMQE; # TRANSFER TEXT TO QUEUE # PROC NVFTRLC; # REFUSE LOAN CONNECTION # END # **** # DEF MAFTRY$ #25#; # MAX NUM OF APPL RETRIES IF APPL FAILED # *CALL TMSGNVF *CALL TERMCLS ITEM ADDR I; # ADDRESSING INFORMATION FOR ABH # ITEM I I; # LOOP VARIABLE # ITEM LNGTH I; # LENGTH OF MESSAGE # ITEM MXAPTRY I; # VARIABLE FOR MAX NUM OF APPL RETRIES # ITEM PSUB I; # SUBSCRIPT FOR GOTO SWITCH # ITEM PT I; # SUBSCRIPT FOR ARRAY PTAC # ITEM SMOUT B; # SM TYPE RESPONSE FOR LOAN REQUEST # # * THE FOLLOWING BASED ARRAY IS FOR GENERAL PURPOSE USAGE # BASED ARRAY BPGEN[00:00] S(1); BEGIN ITEM BPG$WORD U(00,00,60); # FULL WORD REFERENCE # ITEM BPG$NAME U(00,00,42); # REF NAME PORTION OF WORD # END SWITCH PRMTSWT LLUNAPP, # LABEL FOR UNSUCCESSFUL APPLICATION # LLUNUSR, # LABEL FOR UNSUCCESSFUL PERSONAL ID # LLUNUSR, # LABEL FOR UNSUCCESSFUL PASSWORD # LLUNUSR, # LABEL FOR UNSUCCESSFUL USER/PASSWORD # LLUNUSR; # LABEL FOR UNSUCCESSFUL FAMILY/USER/PW # ADDR = PTA$ACN[PT]; # APPLICATION CONNECTION NUMBER # PSUB = PTA$PROMPT[PT] - 1; # OFFSET TO BEGIN WITH 0 # GOTO PRMTSWT[PSUB]; # BRANCH TO APPROPRIATE LABEL # LLUNUSR: # UNSUCCESSFUL USER VALIDATION PROCESSING # NVFTIAM(PT, ABER$); # ISSUE "ABER" ACCOUNTING MSG # PTA$USERCT[PT] = PTA$USERCT[PT] + 1; # INCREMENT USER RETRY CNT # IF PTA$LRC[PT] EQ RCRC"LSA" THEN BEGIN # * LOAN REQUEST TYPE OF CONNECTION. RETURN TO PRIMARY APPLICATION * WITH CR/RCN/A SM. # SMOUT = TRUE; PTA$LRC[PT] = RCRC"UVS"; NVFTRLC(PT,SMOUT,PTA$LRC[PT]); RETURN; END # * IF USER VALIDATION WAS UNSUCCESSFUL DUE TO ERROR IN RESPONSE TO A * PROMPT (I.E., NAME TOO LONG), THE CPM VALIDATE REQUEST (56B) * INDICATES AN INVALID LOGIN CONDITION, OR THE PERSONAL IDENTIFIER * ENTERED IS INVALID, THEN FURTHER CHECKING IS NEEDED TO * DETERMINE WHETHER TERMINAL SHOULD BE PROMPTED AGAIN. IF USER * VALIDATION WAS UNSUCCESSFUL DUE TO SECURITY COUNT EXHAUSTED OR NO * APPLICATION DEFINED FOR THIS USER, NO FURTHER PROMPTS ARE ISSUED * AND THE CONNECTION IS TERMINATED. # IF (PTA$INVLF[PT]) OR (PTA$INVPID[PT]) THEN # ERROR IN RSP TO PROMPT OR INVALID LOGIN # BEGIN IF (PTA$FAMIND[PT] EQ MNDATRY$ AND PTA$USRIND[PT] EQ MNDATRY$) OR (PTA$USERCT[PT] GQ LLVAL) THEN # NO MORE PROMPT CAN BE ISSUED # BEGIN # SET BASED ARRAY TO ERROR MSG # IF (PTA$USERCT[PT] GQ LLVAL) THEN # EXCEEDED LOGIN RETRY LIMIT # BEGIN P = LOC(URLBUF[0]); # USER RETRY LIMIT MESSAGE # LNGTH = LMSG20$; # LENGTH OF MESSAGE # END ELSE # ILLEGAL MANDATORY FAM AND USR # BEGIN P = LOC(LNPBUF[0]); # LOGIN NOT POSSIBLE MESSAGE # LNGTH = LMSG50$; # LENGTH OF MESAGE # END END ELSE # REISSUE FAMILY/USER PROMPT # BEGIN P = LOC(ILMBUF[0]); # IMPROPER LOGIN MESSAGE # LNGTH = LMSG30$; # LENGTH OF MESSAGE # NVFUMQE(P,BPGEN[0],APPTTX$,ADDR,LNGTH); # MESSAGE TO Q # # * IF THE LOGIN WAS UNSUCCESSFUL DUE TO AN INVALID PERSONAL ID * DECREMENT THE FAMILY COUNT. # IF PTA$INVPID[PT] THEN BEGIN P = LOC(MSGBUF[0]) + ((NMSGBUF$ + 1) / 2); CRQ$FCWORD[0] = 0; # CLEAR CPM REQUEST BUFFER # CRQ$FWORD[0] = 0; CRQ$FC[0] = CPM73B$; # DECREMENT FAMILY COUNT # CRQ$ACN[0] = 0; CRQ$FNAM[0] = PTA$FNAM[PT]; LNGTH = CRQDSIZ$ * 10; NVFUMQE(P,CRQBUF[0],APPTTX$,0,LNGTH); END # * SET PROMPT STATE TO AWAIT FAMILY PROMPT AND CLEAR APPROPIATE * FIELDS OF PTAC ENTRY. # PTA$PROMPT[PT] = AWTFAM$; # SET TO AWAIT FAMILY PROMPT # P = LOC(PTA$FWORD[PT]); # 1ST WORD OF VALIDATION DATA# FOR I = 0 STEP 1 UNTIL 9 DO BEGIN BPG$WORD[I] = 0; # CLEAR VALIDATION DATA FIELDS # END P = LOC(PTA$VLTFAM[PT]); # 1ST WORD OF VLTEERED INFO # FOR I = 0 STEP 1 UNTIL 3 DO BEGIN BPG$NAME[I] = 0; # CLEAR VOLUNTEERED NAME FIELDS # END P = LOC(PTA$PID[PT]); # CLEAR PERSONAL ID FIELD # BPG$WORD[0] = 0; BPG$WORD[1] = 0; PTA$VLTF[PT] = 0; # CLEAR ALL VOLUNTEERED FLAGS # PTA$INVAF[PT] = FALSE; # CLEAR INVALID APPL FLAG # PTA$INVPID[PT] = FALSE; # CLEAR INVALID PERSONAL ID FLAG# PTA$PWEXPF[PT] = FALSE; # CLEAR PW EXPIRE MESSAGE # NVFTILP(PT); # ISSUE FAMILY/USER PROMPT # RETURN; # EXIT # END END ELSE # SECURITY COUNT EXHAUSTED OR NO APPL # BEGIN # SET BASED ARRAY TO ERROR MSG # LNGTH = LMSG60$; # LENGTH OF MESSAGE # P = LOC(UANPBUF[0]); # ILLEGAL USER ACCESS MESSAGE # PTA$CACA[PT] = TRUE; # DON'T SEARCH *RML* TABLE # END # * NO FURTHER PROMPTS ARE TO BE ISSUED. SEND ERROR MESSAGE THAT * WAS PREVIOUSLY SET UP TO TERMINAL. SET BASED ARRAY TO "LOGIN * TERMINATED" MESSAGE AND PROCEED TO COMMON CODE TO END TERMINAL * CONNECTION. # NVFUMQE(P,BPGEN[0],APPTTX$,ADDR,LNGTH); # MESSAGE TO QUEUE # P = LOC(LTMBUF[0]); GOTO ENDSWT; LLUNAPP: # UNSUCCESSFUL APPL VALIDATION PROCESSING # PTA$APPLCT[PT] = PTA$APPLCT[PT] + 1; # INCREMENT APPL RETRY CNT # # * IF APPLICATION VALIDATION WAS UNSUCCESSFUL DUE TO APPLICATION * FAILED CONDITION, THE APPLICATION RETRY LIMIT IS INCREASED TO * 25. # MXAPTRY = LLVAL; # NORMAL APPL RETRY LIMIT # IF (PTA$AFF[PT]) THEN # APPLICATION FAILED # BEGIN MXAPTRY = MAFTRY$; # APPL FAILED RETRY LIMIT # END IF PTA$LRC[PT] EQ RCRC"LSA" THEN BEGIN # * LOAN REQUEST TYPE OF CONNECTION. RETURN TO PRIMARY APPLICATION * WITH CR/RCN/A SM. # SMOUT = TRUE; PTA$LRC[PT] = RCRC"UVS"; NVFTRLC(PT,SMOUT,PTA$LRC[PT]); RETURN; END # * DETERMINE WHETHER TERMINAL USER SHOULD BE PROMPTED AGAIN FOR * APPLICATION NAME. # IF (PTA$APPIND[PT] EQ MNDATRY$) OR (PTA$VDSF[PT]) OR (PTA$APPLCT[PT] GQ MXAPTRY) THEN # NO MORE PROMPT CAN BE ISSUED # BEGIN # SET BASED ARRAY TO ERROR MSG # IF (PTA$APPLCT[PT] GQ MXAPTRY) THEN # EXCEEDED APPL RETRY LIMIT # BEGIN P = LOC(ARLBUF[0]); # APPL RETRY LIMIT MESSAGE # LNGTH = LMSG30$; # LENGTH OF MESSAGE # END ELSE # ILLEGAL MANDATORY/IMPLIED MANDATORY APP # BEGIN P = LOC(UANPBUF[0]); # USER ACCESS NOT POSSIBLE MSG # LNGTH = LMSG60$; # LENGTH OF MESSAGE # END # * NO FURTHER PROMPTS ARE TO BE ISSUED. CHECK TERMINAL CLASS TO * SEE IF NVF SHOULD SEND A CTR/CHAR. # GOTO TERMCLS [PTA$TC[PT]]; SENDCTRCHAR: # * SEND CTR/CHAR TO FORCE TERMINAL TO BE IN NON-TRANSPARENT INPUT * MODE. # PFCSFC[1] = CTRCHAR; CTRSTR[1] = 0; # CLEAR REST OF WORD 0 # B<0,16>CTRSTR[1] = NOXPAR$; # ADD FN/FV PAIR FOR NON-XPARENT# NVFUMQE(P,APSM[1],APPPR$,ADDR,LCTRLO$); # TRANSFER TO Q # NOCTRCHAR: # * SEND ERROR MESSAGE THAT WAS PREVIOUSLY SET UP TO THE TERMINAL. * SET BASED ARRAY TO "LOGGED OUT" MESSAGE AND PROCEED TO COMMON * CODE TO END TERMINAL CONNECTION. # NVFUMQE(P,BPGEN[0],APPTTX$,ADDR,LNGTH); # MESSAGE TO Q # P = LOC(LOMBUF[0]); # LOGGED OUT MESSAGE # GOTO ENDSWT; END ELSE # REISSUE APPLICATION PROMPT # BEGIN P = LOC(IAMBUF[0]); # ILLEGAL APPLICATION MESSAGE # LNGTH = LMSG40$; # LENGTH OF MESSAGE # NVFUMQE(P,BPGEN[0],APPTTX$,ADDR,LNGTH); # MESSAGE TO Q # # * CLEAR APPROPRIATE FIELDS OF PTAC ENTRY AND CALL *NVFTILP* TO * REISSUE APPLICATION PROMPT. # PTA$AWORD[PT] = 0; # CLEAR SWITCH APPLICATION WORD # PTA$VAF[PT] = FALSE; # CLEAR VOLUNTEERED APPL FLAG # PTA$VAWORD[PT] = 0; # CLEAR VOLUNTEERED APPL WORD # NVFTILP(PT); # ISSUE APPLICATION PROMPT # RETURN; # EXIT # END ENDSWT: # COMMON END PROCESSING # # * NO FURTHER PROMPTS ARE TO BE ISSUED. SEND MESSAGE THAT WAS SET * UP PREVIOUSLY TO THE TERMINAL AND CALL *NVFTETC* TO END TERMINAL * CONNECTION. # LNGTH = LMSG20$; # COMMON LENGTH OF TRM MESSAGE # NVFUMQE(P,BPGEN[0],APPTTX$,ADDR,LNGTH); # MESSAGE TO QUEUE # NVFTETC(PT); # END TERMINAL CONNECTION # END # END NVFTPUV # TERM