Retro1.org codex

*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<BPGEN> = LOC(URLBUF[0]);  # USER RETRY LIMIT MESSAGE     #
            LNGTH    = LMSG20$;        # LENGTH OF MESSAGE             #
            END 
          ELSE                         # ILLEGAL MANDATORY FAM AND USR #
            BEGIN 
            P<BPGEN> = LOC(LNPBUF[0]);  # LOGIN NOT POSSIBLE MESSAGE   #
            LNGTH    = LMSG50$;        # LENGTH OF MESAGE              #
            END 
 
          END 
        ELSE                           # REISSUE FAMILY/USER PROMPT    #
          BEGIN 
          P<BPGEN> = LOC(ILMBUF[0]);   # IMPROPER LOGIN MESSAGE        #
          LNGTH    = LMSG30$;          # LENGTH OF MESSAGE             #
          NVFUMQE(P<CTQ>,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<CRQBUF> = 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<CPMRQ>,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<BPGEN> = 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<BPGEN> = 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<BPGEN> = 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<BPGEN> = 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<CTQ>,BPGEN[0],APPTTX$,ADDR,LNGTH);  # MESSAGE TO QUEUE #
      P<BPGEN> = 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<BPGEN> = LOC(ARLBUF[0]);   # APPL RETRY LIMIT MESSAGE      #
          LNGTH    = LMSG30$;          # LENGTH OF MESSAGE             #
          END 
        ELSE                 # ILLEGAL MANDATORY/IMPLIED MANDATORY APP #
          BEGIN 
          P<BPGEN> = 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<CTQ>,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<CTQ>,BPGEN[0],APPTTX$,ADDR,LNGTH);  # MESSAGE TO Q   #
        P<BPGEN> = LOC(LOMBUF[0]);     # LOGGED OUT MESSAGE            #
        GOTO ENDSWT;
        END 
      ELSE                             # REISSUE APPLICATION PROMPT    #
        BEGIN 
        P<BPGEN> = LOC(IAMBUF[0]);     # ILLEGAL APPLICATION MESSAGE   #
        LNGTH    = LMSG40$;            # LENGTH OF MESSAGE             #
        NVFUMQE(P<CTQ>,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<CTQ>,BPGEN[0],APPTTX$,ADDR,LNGTH);  # MESSAGE TO QUEUE #
      NVFTETC(PT);                     # END TERMINAL CONNECTION       #
 
      END  # END NVFTPUV #
 
TERM