Retro1.org codex

*DECK     NVFTPSV 
USETEXT          TEXTNVF
USETEXT          TEXTSS 
USETEXT          TXTANVF
USETEXT          TXTAPSS
USETEXT          TXSMNVF
PROC NVFTPSV((PT)); 
# TITLE NVFTPSV - PROCESS SUCCESSFUL VALIDATION                        #
 
      BEGIN  # NVFTPSV #
# 
**    NVFTPSV - PROCESS SUCCESSFUL VALIDATION.
* 
*     E. THAVIKULWAT    81/10/19
* 
*     THIS PROCEDURE'S MAIN FUNCTION IS TO UPDATE *PTAC* ENTRY UPON A 
*     SUCCESSFUL USER OR APPLICATION VALIDATION.  IT IS CALLED INTO 
*     EXECUTION BY THE FOLLOWING PROCEDURES:  
*       *NVFTETI*   *NVFTVAA*  *NVFTVVD*
* 
*     PROC NVFTPSV((PT))
* 
*     ENTRY:  
*       PT  =  POINTER TO *PTAC* ENTRY
* 
*     EXIT: 
*       *PTAC* TABLE UPDATED TO REFLECT SUCCESSFUL USER OR APPLICATION
*       VALIDATION. 
* 
*     NOTES:  
*       INCREMENT FAMILY COUNT IS SET ONLY FOR INITIAL USER VALIDATION. 
*       USER VALIDATION DUE TO A CR/RCN REQUEST IS NOT CONSIDERED 
*       INITIAL AND FAMILY COUNT IS NOT INCREMENTED.
* 
*     METHOD: 
*       FOR APPLICATION VALIDATION, CALL *NVFTDSP* TO DETERMINE IF
*       SWITCH IS POSSIBLE.  FOR INITIAL USER VALIDATION, CALL *NVFTIAM*
*TEXT 
*       TO ISSUE *ABUN* AND *ABIC* ACCOUNT MESSAGE, AND 
*       DETERMINE IF THERE IS AN IMPLIED MANDATORY
*       APPLICATION FROM THE *VALIDUS* FILE.  IF THERE
*ENDTEXT
*       IS AN IMPLIED MANDATORY APPLICATION, SET STATE OF TERMINAL TO 
*       AWAIT VALIDATE APPLICATION ACCESS.  OTHERWISE, CALL *NVFTILP* TO
*       ISSUE APPLICATION PROMPT.  ON AN INTIAL LOGIN IF THE USER IS
*       NOT ALLOWED MULTIPLE CONCURRENT LOGINS, CREATE AN ENTRY IN THE
*       *RML* TABLE INORDER TO RESTRICT THE USER. 
# 
 
# 
****  PROC NVFTPSV - XREF LIST. 
# 
 
      XREF
        BEGIN 
        PROC NVFTDAD;        # DETERMINE ADDITIONAL DIALOGUE           #
        PROC NVFTDSP;        # DETERMINE SWITCH POSSIBILITY            #
        PROC NVFTIAM;        # ISSUE ACCOUNTING MESSAGE                #
        PROC NVFTILP;        # ISSUE LOGIN PROMPT                      #
        PROC NVFUMQE;        # MAKE QUEUE ENTRY                        #
        PROC SSTAQE;         # ACCEPT QUEUE ENTRY                      #
        PROC SSTETS;         # ENLARGE TABLE SPACE                     #
        END 
 
# 
****
# 
      DEF  LENGTH$ #10#;     # NUMBER OF CHARACTERS IN CLRSCRN ARRAY   #
 
      ITEM BPOS       I;     # BIT POSITN WITHIN WORD (COMPASS NOTATN) #
      ITEM COUNT      I;     # COUNT OF THE NUMBER OF 1'S BITS         #
      ITEM I          I;     # LOOP VARIABLE                           #
      ITEM INUSERV    B;     # INITIAL USER VALIDATIONS FLAG           #
      ITEM MATCH      B;     # EXIT LOOP VARIABLE                      #
      ITEM NENTRY     I;     # NUMBER OF ENTRIES IN TABLE              #
      ITEM PT         I;     # SUBSCRIPT FOR ARRAY PTAC                #
      ITEM RM         I;     # SUBSCRIPT FOR ARRAY RML                 #
 
# 
*     CLRSCRN - A "MESSAGE" SENT TO THE TERMINAL TO CLEAR THE SCREEN. 
# 
      ARRAY CLRSCRN [00:00] S(1); 
        BEGIN 
        ITEM CLRWORD  C(00,00,01) = ["1"];
        ITEM CLRZERO  U(00,06,54) = [0];
        END 
 
 
 
      IF PTA$PROMPT[PT] EQ AWTAPP$
      THEN                             # SUCCESSFUL APPL VALIDATION    #
        BEGIN 
        PTA$APPLCT[PT] = 0;            # CLEAR APPLICATION RETRY COUNT #
        PTA$AFF[PT]    = FALSE;        # CLEAR APPLICATION FAILED FLAG #
        NVFTDSP(PT,0);                 # DETERMINE SWITCH POSSIBILITY  #
        END 
      ELSE                             # SUCCESSFUL USER VALIDATION    #
        BEGIN 
        PTA$USERCT[PT] = 0;            # CLEAR USER RETRY COUNT        #
        INUSERV = PTA$IUVF[PT]; 
        IF INUSERV
        THEN                           # INITIAL USER VALIDATION       #
          BEGIN 
          PTA$CNTIME[PT] = CTM$PDT[0];  # SAVE CONNECTION TIME         #
          NVFTIAM(PT,ABUN$);           # ISSUE *ABUN* ACCOUNTING MSG   #
          IF PTA$CHGNUM[PT] NQ NULL$   #  CHARGE NUMBER EXISTS         #
          THEN
            BEGIN 
            NVFTIAM(PT,ABIC$);         # ISSUE *ABIC* MESSAGE          #
            END 
          IF PTA$PID[PT] NQ NULL$      #  PERSONAL IDENTIFIER EXISTS   #
          THEN
            BEGIN 
            NVFTIAM(PT,SIPI$);         # ISSUE *SIPI* MESSAGE          #
            END 
          PTA$IUVF[PT] = FALSE; 
          END 
 
# 
*       IF MULTIPLE CONCURRENT LOGINS ARE PROHIBITED, CHECK THE *RML* 
*       TABLE FOR A DUPLICATE USER. IF A DUPLICATE IS FOUND CALL
*       *NVFTDAD* AND END THE CONNECTION.  IF NO DUPLICATE, CREATE A
*       TABLE ENTRY IN THE *RML* TABLE TO RESTRICT THE USER.
# 
        IF INUSERV AND (NOT PTA$CACA[PT]) 
        THEN
          BEGIN                        # INTIAL LOGIN, RESTRICTED USER #
          FOR I = 0 STEP 1 UNTIL (RMLLNGTH - 1) 
          DO
            BEGIN 
            IF (RML$UIDX[I] EQ PTA$UIDX[PT]) AND
               (RML$FNAM[I] EQ PTA$FNAM[PT])
            THEN
              BEGIN                    # MULTIPLE CONCURRENT LOGINS    #
              NVFTDAD(PT,ECCANA$);     # ISSUE ERROR AND END CONNECT   #
              RETURN; 
 
              END 
            END 
          RM = RMLLNGTH;               # CREATE NEW *RML* TABLE ENTRY  #
          SSTETS (P<RML>,RM,RMLSIZ$); 
          RML$UIDX[RM] = PTA$UIDX[PT];
          RML$FNAM[RM] = PTA$FNAM[PT];
          END 
# 
*       SEARCH APPLICATION BITS FIELD OF *AAWC* TO DETERMINE IF A 
*       MANDATORY APPLICATION IS SPECIFIED IN THE *VALIDUS* FILE FOR
*       THIS USER (ONLY ONE BIT SET). 
# 
        COUNT = 0;
        FOR I = 12 STEP 1 WHILE (COUNT LS 2 AND I LQ 59)
        DO
          BEGIN 
          IF B<I,1>PTA$AAVW[PT] EQ 1
          THEN
            BEGIN 
            COUNT = COUNT + 1;         # INCREMENT NUMBER OF 1'S       #
            BPOS  = 59 - I;            # BIT POSITION WITHIN WORD(CMP) #
            END 
          END 
 
        IF COUNT EQ 1 
        THEN                           # MANDATORY APPL IN VALIDUS     #
          BEGIN 
# 
*         IMPLIED MANDATORY APPLICATION IS SPECIFIED IN THE *VALIDUS* 
*         FILE.  HAVE TO FURTHER CHECK IF BIT IS UNIQUE TO THIS 
*         APPLICATION.  IF BIT IS NOT UNIQUE, APPLICATION IS NOT
*         CONSIDERED A MANDATORY APPLICATION. 
# 
          MATCH   = FALSE;
          NENTRY  = ASTLNGTH / ASTSIZ$; 
          FOR I = 0 STEP 1 WHILE (NOT MATCH AND I LS NENTRY)
          DO
            BEGIN 
            IF AST$AWBP[I] EQ BPOS
            THEN                       # FOUND APPLICATION             #
              BEGIN 
              IF NOT AST$BNUF[I]
              THEN                     # APPLICATION BIT IS UNIQUE     #
                BEGIN 
                PTA$VDSAPP[  PT] = AST$ANAM[I];  # SAVE APPL NAME      #
                PTA$VDSF[  PT]   = TRUE;      # SET VALIDUS APPL FLAG  #
                END 
              MATCH = TRUE;            # SET EXIT LOOP CONDITION       #
              END 
            END 
          END 
 
# 
*       FOR BOTH INITIAL AND NON-INITIAL USER VALIDATION, DETERMINE IF
*       USER NEEDS TO BE PROMPTED FOR AN APPLICATION NAME.  NO PROMPT 
*       IS REQUIRED IF THERE IS AN IMPLIED MANDATORY APPLICATION NAME 
*       OR IF USER HAS ALREADY SUPPLIED THE APPLICATION NAME. 
# 
        PTA$PROMPT[PT] = AWTAPP$; 
        IF ((PTA$VAF[PT]) AND (PTA$APPIND[PT] NQ PRIMARY$)) 
          OR (PTA$VDSF[PT]) 
        THEN                           # NO APPLICATION PROMPT         #
          BEGIN 
          PTA$STATE[PT] = PTACST"AWTVAA";  # AWAIT VALIDAT APPL ACCESS #
          END 
        ELSE                           # APPLICATION PROMPT REQUIRED   #
          BEGIN 
          NVFTILP(PT);                 # ISSUE APPLICATION PROMPT      #
          END 
        END 
 
      END  # END NVFTPSV #
 
TERM