*DECK FFSUVUI 
USETEXT TEXTFFS 
PROC FFSUVUI ((FAM$), (USER$), PASS$, VSTATUS) ;
*CALL COPYRITE
# TITLE FFSUVUI - VALIDATE USER INDEX PROCESSOR.                 #
  
      BEGIN  # FFSUVUI #
  
# 
**    FFSUVUI - VALIDATE USER INDEX PROCESSOR.
* 
*     'FFSUVUI' PROVIDES AN INTERFACE TO THE NOS VALIDATION SYSTEM. 
*     IT VALIDATES THE USER  AND PASSWORD ENTERED IN THE SERVER MODE, 
*     AND THE USER WITHOUT PASSWORD IN CLIENT MODE. 
*     IT MUST BE CALLED FROM A SYSTEM JOB.  THE JOB MUST BE IN THE
*     PRE-PRIMARY USER STATE THE FIRST TIME IT IS CALLED. 
* 
*     PROC FFSUVUI ((FAM$), (USER$), PASS$, VSTATUS)
* 
*     ENTRY      (FAMILY)   = 1-7 CHARACTER, ZERO-FILLED FAMILY NAME
*                             OF DESIRED ACCOUNT.  SHOULD BE EMPTY
*                             (ALL ZERO-FILL) IF DEFAULT FAMILY.
*                (USERNUM)  = 1-7 CHARACTER, ZERO-FILLED USER NAME
*                             OF DESIRED ACCOUNT.  THIS IS ALWAYS 
*                             REQUIRED. 
*                PASSWORD   = 1-7 CHARACTER, ZERO-FILLED PASSWORD 
*                             OF DESIRED ACCOUNT.  IF THIS IS ALL 
*                             BLANKS, THE USER/FAMILY WILL BE 
*                             VALIDATED WITHOUT THE PASSWORD - CARE 
*                             MUST BE TAKEN BY THE CALLING PROGRAM
*                             TO ENSURE THAT THIS CANNOT BE USED TO 
*                             TO BYPASS SYSTEM SECURITY.
*                VAL$RETRY  = DEFINED IN 'VAL$COM' COMMON BLOCK.
*                             NUMBER OF TRIES AVAILABLE TO ENTER
*                             CORRECT FAMILY/USER/PASSWORD.  WHEN 
*                             'FFSUVUI' IS FIRST CALLED, THIS MUST
*                             BE INITIALIZED TO THE MAXIMUM RETRIES 
*                             ALLOWED.  RETRIES ONLY APPLY TO THE 
*                             PRIMARY USER, NOT TO SECONDARY USER 
*                             REQUESTS.  RETRY IS DECREMENTED AFTER 
*                             EACH UNSUCCESSFUL USER ATTEMPT. 
*                VAL$STATE  = DEFINED IN 'VAL$COM' COMMON BLOCK.
*                             CURRENT VALIDATION STATE.  WHEN 
*                             'FFSUVUI' IS FIRST CALLED, THIS MUST
*                             BE INITIALIZED TO 'VST$BEGIN'.  IT IS 
*                             SUBSEQUENTLY MAINTAINED BY 'FFSUVUI' AND
*                             'FFSUSUC'.
*                CPA          (CONTROL POINT AREA).  ON THE FIRST 
*                             OR PRIMARY USER REQUEST, THE USER NUMBER
*                             AND USER INDEX MUST NOT BE DEFINED (OR
*                             DEFINED AS 'SYSTEMX').
* 
*     EXIT       PASSWORD     CLEARED TO ZERO FOR SECURITY. 
*                VSTATUS      SET TO RETURN STATUS AS DEFINED BY
*                             'VRS$STATUS' IN 'COMVVAL'.
*                PFM$TEXT     ERROR MESSAGE IF UNSUCCESSFUL.
*                VAL$RETRY    COUNT DECREMENTED IF PRIMARY USER 
*                             REQUEST FAILED. 
*                VAL$STATE    UPDATED TO NEW VALIDATION STATE.
*                CPA          (CONTROL POINT AREA).  NEW USER/CHARGE
*                             DEFINED IF REQUEST SUCCESSFUL, INCLUDING
*                             UPDATED ACCOUNT ACCESS AND PERMANENT FILE 
*                             RESOURCE LIMITS.
*                ACCOUNT FILE ACCOUNTING MESSAGES ISSUES FOR ALL USER/
*                             CHARGE NOS ACCOUNTING STATE CHANGES.
* 
* 
*     DESCRIPTION.
* 
*     SET RETURN STATUS TO OKAY.
* 
*     PROCESSING IS BASED UPON CURRENT VALIDATION STATE.
*       CASE OF STATE = ERROR (USER PREVIOUSLY DECLARED INVALID). 
*         ABORT PROGRAM TO AVOID SECURITY LOOPHOLES.
*       CASE OF STATE = BEGIN (NO USER HAS YET BEEN VALIDATED). 
*         POSITION ARRAY TEMPLATES. 
*         GET CURRENT PERM FILE AND CHARGE PARAMETERS.
*         IF THE PRIMARY USER HAS ALREADY BEEN ESTABLISHED, THIS
*           INDICATES A PROCEDURAL ERROR BY THE CALLING PROGRAM OR
*           IN NOS CCL, SO ABORT PROGRAM. 
*       CASE OF STATE = USER OR CHARGE (USER HAS BEEN VALIDATED). 
*         GET SYSTEM STATUS WORD. 
*         IF SECONDARY USERS HAVE BEEN DISABLED IN SYSTEM STATUS THEN 
*           SET RETURN STATUS TO SECONDARY USERS DISABLED.
*       END OF CASE ON VALIDATION STATE.
* 
*     IF NO ERRORS HAVE BEEN DETECTED THEN
*       SET VALIDATION BLOCK WITH NEW USER PARAMETERS.
*       IF SERVER THEN DISALLOW SPECIAL USER INDICES. 
*       POSITION ARRAY TEMPLATES. 
*       IF PASSWORD HAS NOT BEEN GIVEN THEN 
*         SET FLAG TO NOT VALIDATE PASSWORD (NOTE - THIS IS INTENDED
*         FOR CASES WHERE THE USER IS OBTAINED BY SECURE MEANS AND IT 
*         HAS ALREADY BEEN VALIDATED (EG CONTROL STATEMENT).
*       ELSE IF PASSWORD HAS BEEN GIVEN THEN
*         SET FLAG TO VALIDATE PASSWORD.
*       ISSUE USER DAYFILE MESSAGE. 
*       CALL VALID$ TO VALIDATE USER/FAMILY/PASSWORD. 
*       CLEAR PASSWORD FOR SECURITY PURPOSES. 
*       (WARNING - THE ORDER OF THE FOLLOWING TESTS IS IMPORTANT, 
*        AND SHOULD PROCEED IN ORDER OF DECREASING SEVERITY)
*       IF USERS SECURITY COUNT IS EXHAUSTED THEN 
*         SET RETURN STATUS TO SECURITY COUNT EXHAUSTED.
*       ELSE IF VALIDATION FAILED THEN
*         SET RETURN STATUS TO NOT VALIDATED. 
*       ELSE IF USER NOT VALIDATED FOR INTER-HOST TRANSFERS THEN
*         SET RETURN STATUS TO NOT VALIDATED. 
* 
*     IF USER VALIDATION SUCCEEDED THEN 
*       IF PRIMARY USER THEN
*         ENABLE SRU ACCUMULATION.
*         ISSUE ABUN AND ABIC ACCOUNT FILE MESSAGES.
*       IF SECONDARY USER THEN
*         ISSUE ACUN ACCOUNT FILE MESSAGE.
*       IF CHARGE IS REQUIRED AND DEFAULT CHARGE EXISTS THEN
*         ISSUE THE DEFAULT CHARGE. 
*         IF THE DEFAULT CHARGE FAILED THEN 
*           ISSUE THE ERROR MESSAGE.
*           IF CHARGE IS RESTRICTED TO DEFAULT THEN 
*             SET RETURN STATUS TO RETRY LIMIT EXCEEDED.
*       SET VAL$STATE TO PRIMARY USER ESTABLISHED.
*       GET NOS CSPW WORD FROM CONTROL POINT AREA.
*       IF CSPW INDICATES CHARGE IS REQUIRED THEN 
*         SET VAL$STATE TO USER VALID, CHARGE REQUIRED. 
*         SET RETURN STATUS TO CHARGE REQUIRED. 
* 
*     IF ERRORS OCCURRED DURING VALIDATION THEN 
*       (NOTE - THE ORDER OF THE FOLLOWING TESTS IS IMPORTANT, THEY 
*        MUST APPEAR IN ORDER OF INCREASING IMPORTANCE.)
*       IF RETRY LIMIT HAS BEEN EXCEEDED THEN 
*         SET RETURN STATUS TO RETRY LIMIT EXCEEDED.
*       IF PASSWORD WAS NOT SUPPLIED, BUT VALIDATION FAILED ANYWAY
*       (THIS INDICATES THAT THE 'SECURE' SOURCE OF THE USER DATA 
*       WAS IN ERROR) THEN
*         SET RETURN STATUS TO FAILED WITHOUT PASSWORD. 
* 
*       IF ERROR WAS GREATER THAN MAXIMUM VALID ERRORS (I.E. SECURITY 
*       COUNT EXHAUSTED, PASSWORD RETRY LIMIT, FAILURE WITHOUT PASSWORD)
*       THEN
*         SET VALIDATION STATE TO INVALID USER. 
*       ISSUE ERROR MESSAGE TO DAYFILE. 
* 
*     RETURN. 
* 
# 
  
                                               CONTROL LIST;
  
      ITEM FAM$       C(7);          # FAMILY NAME                    # 
      ITEM USER$      C(7);          # USER NUMBER                    # 
      ITEM PASS$      C(7);          # USER PASSWORD                  # 
      ITEM VSTATUS    S:VRS$STATUS;  #           RETURN STATUS        # 
  
      XREF
        BEGIN 
        PROC ABORT ;                 # SYSTEM MACRO TO ABORT          # 
        PROC DECRSC;                 # DECREMENT SECURITY COUNT       # 
        PROC RENSR;                  # ENABLE SRU ACCUMULATION        # 
        FUNC FFSUTBZ C(240);         # CONVERT TRAILING BLANKS TO ZERO# 
        PROC GET$CHG;                # GET CURRENT CHARGE/PROJECT     # 
        PROC GET$CSP;                # GET NOS CSPW WORD FROM CPA     # 
        PROC GETPFP;                 # GET PERMANENT FILE PARAMETERS  # 
        PROC GET$SST;                # GET NOS SYSTEM STATUS WORD     # 
        PROC MESSAGE ;               # ISSUE DAYFILE MESSAGE          # 
        PROC SETCHG;                 # SET NEW CHARGE/PROJECT         # 
        PROC VALID$;                 # VALIDATE USER/FAMILY           # 
        PROC XSNM;                   # SET NAME IN MESSAGE            # 
        END 
  
      ITEM ADDR$MSG U;               # MESSAGE ADDRESS FROM 'SETCHG'  # 
      ITEM DEFAULT  B;               # CHARGE IS USER DEFAULT         # 
  
      ARRAY DECRBLK [00:00] S(3);    # PARAMETER BLK FOR CPM 114 CALL # 
        BEGIN 
        ITEM DECRUSR  C(00,00,07);   # USER NAME                      # 
        ITEM DECRWD0  U(00,00,60) = [0]; # WORD 0                     # 
        ITEM DECRWD1  U(01,00,60) = [0]; # WORD 1                     # 
        ITEM DECRFAM  C(02,00,07);   # FAMILY                         # 
        ITEM DECRWD2  U(02,00,60) = [0]; # WORD 2                     # 
        END 
  
      ARRAY ZEROFILL S(1) ; 
        BEGIN 
        ITEM ZEROWORD C(00,00,10) ; 
        ITEM ZERO     U(00,00,60) = [0] ; 
        END 
  
      ITEM MSG$BUFF   C(80);         # ACCOUNT/DAYFILE MESSAGE BUFFER # 
      ITEM MSG$ABIC   C(80) =        # ABIC ACCOUNT MESSAGE TEMPLATE  # 
                            "ABIC, !!!!!!!!!!, ++++++++++----------.";
      ITEM MSG$ABUN   C(80) =        # ABUN ACCOUNT MESSAGE TEMPLATE  # 
                            "ABUN, !!!!!!!, +++++++, -------."; 
      ITEM MSG$ACUN   C(80) =        # ACUN ACCOUNT MESSAGE TEMPLATE  # 
                            "ACUN, !!!!!!!, +++++++.";
      ITEM MSG$USER   C(80) =        # USER DAYFILE MESSAGE TEMPLATE  # 
                            "USER,!!!!!!!,,+++++++."; 
      ITEM MSG$DCHG   C(80) =        # DEFAULT CHARGE DAYFILE MESSAGE # 
                         "*  CHARGE,!!!!!!!!!!,++++++++++----------.";
      ITEM MSG$ACHG   C(80) =        # ACTIVATED CHARGE DAYFILE MSG   # 
               "CHARGE = !!!!!!!!!!, PROJECT = ++++++++++----------.";
      ARRAY UVUI$MSG [0:1] S(5) ; 
        BEGIN 
        ITEM UVUI$M$T C(00,00,48) = [ 
                " FFSUVUI-USER/CHARGE EXTERNALLY DEFINED.        ", 
                " FFSUVUI-VST$ERROR STATE ENCOUNTERED.           ",] ;
        ITEM UVUI$M$Z U(04,48,12) ; 
        END 
  
      BASED ARRAY CHG$MSGA [0:0] S(8); # CHARGE MESSAGE TEMPLATE      # 
        BEGIN 
        ITEM CHG$MSG  C(00,00,80);   # CHARGE MESSAGE STRING          # 
        END 
      BASED ARRAY DUMMYBA[0:0] ;; 
                                               CONTROL EJECT; 
  
      PFM$T[0] = 0; 
  
# 
*     PRESET THE RETURN STATUS TO VALID.
# 
  
      VSTATUS = S"VRS$VALID";        # SET RETURN STATUS TO OKAY      # 
  
# 
*     VERIFY CORRECT ENTRY CONDITIONS, DEPENDING ON CURRENT VALIDATION
*     STATE.
# 
  
# 
*     IF THE ENTRY STATE IS ERROR, THEN ABORT TO AVOID SECURITY 
*     LOOPHOLES.
# 
  
      IF VAL$STATE EQ S"VST$ERROR"
      THEN
        BEGIN 
        UVUI$M$Z[1] = 0;             # SET ZERO BYTE                  # 
        MESSAGE (UVUI$M$T[1], 0);    # ISSUE REASON                   # 
        ABORT;                       # ABORT THE PROGRAM              # 
        END 
  
# 
*     VERIFY THAT NO USER IS DEFINED PRIOR TO FIRST CALL TO 'FFSUVUI'.
*     THIS IS REQUIRED TO ENSURE THAT THE VALIDATION LIMITS AND 
*     PRIVILEGES ARE THOSE OF THE PRIMARY USER ENTERED BY THE USER. 
# 
  
      IF VAL$STATE EQ S"VST$BEGIN"
      THEN
        BEGIN                        # CHECK FOR PRIMARY USER DEFINED # 
        GET$CSP (CSPW);              # GET NOS CSP WORD FROM CPA      # 
        IF CSP$PUP
        THEN                         #PRIMARY USER ALREADY ESTABLISHED# 
          BEGIN 
          UVUI$M$Z[0] = 0 ; 
          MESSAGE (UVUI$M$T[0],0) ; 
          ABORT ; 
          END 
        END                          # CHECK FOR PRIMARY USER DEFINED # 
  
# 
*     IF THE PRIMARY USER NAME IS ALREADY ESTABLISHED THEN CHECK IF 
*     SECONDARY USER STATEMENTS ARE ENABLED.
# 
  
      IF VAL$STATE NQ S"VST$BEGIN"
      THEN
        BEGIN                        # CHECK IF 2NDARY USERS ALLOWED  # 
        GET$SST (SSTL);              # FETCH SSTL WORD FROM LOW CORE  # 
        IF SST$DSUSER 
        THEN
          BEGIN                      # 2NDARY USER COMMANDS DISABLED  # 
          VSTATUS = S"VRS$USER2";    # SECONDARY USER NOT ALLOWED     # 
          PFM$TEXT  = 
          "SECONDARY USER CMDS DISABLED. "; 
          MSG$BUFF =
          " SECONDARY USER COMMANDS DISABLED."; 
          MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
          END                        # 2NDARY USER COMMANDS DISABLED  # 
        ELSE
          BEGIN                      # 2NDARY USER COMMANDS ENABLED   # 
          IF NOT AAC$CSAF 
          THEN
            BEGIN                    # ALTERNATE FAMILY NOT ALLOWED   # 
            IF (VAL$FAMILY NQ FAM$) AND (FAM$ NQ 0) 
            THEN
              BEGIN                  # DIFFERENT FAMILY IS SPECIFIED  # 
              VSTATUS = S"VRS$USER2";# SECONDARY USER NOT ALLOWED     # 
              PFM$TEXT  = 
              "ALTERNATE FAMILY NOT ALLOWED. "; 
              MSG$BUFF  = 
              " ALTERNATE FAMILY NOT ALLOWED. ";
              MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
              END                    # DIFFERENT FAMILY IS SPECIFIED  # 
            END                      # ALTERNATE FAMILY NOT ALLOWED   # 
          END                        # 2NDARY USER COMMANDS ENABLED   # 
        END                          # CHECK IF 2NDARY USERS ALLOWED  # 
  
# 
*     IF ENTRY CONDITIONS ARE CORRECT, VALIDATE USER. 
# 
  
      IF VSTATUS EQ S"VRS$VALID"
      THEN                           # ENTRY CONDITIONS CORRECT       # 
        BEGIN 
        P<VAL$BLOCK> = LOC (JOB$VAL); # POSITION VALIDATION TEMPLATE  # 
        VAL$FAMILY = FAM$ ;          # SET FAMILY TO VALIDATE         # 
        VAL$USER   = USER$ ;         # SET USER NUMBER TO VALIDATE    # 
        VAL$PASS   = PASS$ ;         # SET PASSWORD TO VALIDATE       # 
  
        IF EPTFLAG EQ FTPC$ 
        THEN
          BEGIN                      # CLIENT MODE                    # 
          VAL$AUIMX = TRUE;          # ALLOW SPECIAL USER INDICES     # 
          END 
        ELSE
          BEGIN                      # SERVER MODE                    # 
          VAL$AUIMX = FALSE;         # DISALLOW SPECIAL USER INDICES  # 
          END 
  
        VAL$NOABT  = TRUE;           # DO NOT ABORT IF UNSUCCESSFUL   # 
  
        C<0, 80>MSG$BUFF = FFSUTBZ(MSG$USER, 80); 
        XSNM (MSG$BUFF, "!", FFSUTBZ(VAL$USER, 10), MSG$BUFF);
        XSNM (MSG$BUFF, "+", FFSUTBZ(VAL$FAMILY, 10), MSG$BUFF);
        MESSAGE (MSG$BUFF,0) ;       # ISSUE USER DAYFILE MESSAGE     # 
        P<SSJ$FMT> = LOC (SSJ$BLK);  # POSITION SSJ= TEMPLATE         # 
  
        VAL$ALMW = SSJ$ALMW;         # INITIALIZE ACCOUNT LIMIT INDEX # 
        VAL$ACLS = SSJ$ACLS;         # INITIALIZE COUNTING LIMIT      # 
        VAL$AACW = SSJ$AACW;         # INITIALIZE ACCESS CONTROLS     # 
  
        IF PASS$ EQ "       " 
        THEN                         # PASSWORD IS NOT TO BE CHECKED  # 
          BEGIN 
          VAL$NOPASS = TRUE;         # DO NOT CHECK PASSWORD          # 
          END 
  
        ELSE                         # PASSWORD MUST BE CHECKED       # 
          BEGIN 
          VAL$NOPASS = FALSE;        # CHECK PASSWORD                 # 
          END 
  
        VALID$ (JOB$VAL);            # VALIDATE FAMILY/USER/PASSWORD  # 
        VAL$PASS = ZEROWORD;         # CLEAR PASSWORD FOR SECURITY    # 
        PASS$ = ZEROWORD; 
        P<AACW>  = LOC (VAL$AACW);   # POSITION USER ACCESS TEMPLATE  # 
        IF VAL$EXAUST 
        THEN                         # SECURITY COUNT IS EXHAUSTED    # 
          BEGIN 
          VSTATUS = S"VRS$COUNT";    # SET COUNT EXHAUSTED STATUS     # 
          PFM$TEXT =
          "USER SECURITY COUNT EXHAUSTED."; 
          MSG$BUFF  = 
          " USER SECURITY COUNT EXHAUSTED. "; 
          MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
          END 
  
        ELSE
          IF VAL$INDEX EQ 0 
          THEN                       # USER NOT VALIDATED             # 
            BEGIN 
            DECRUSR[0] = USER$; 
            DECRFAM[0] = FAM$;
            DECRSC (DECRBLK);        # CALL CPM TO DECREMENT SEC. CNT.# 
            VSTATUS = S"VRS$NOTVAL"; # SET NOT VALIDATED STATUS       # 
            PFM$TEXT =
            "INCORRECT USER COMMAND.       "; 
            IF (VAL$STATE EQ S"VST$BEGIN") AND
               (VAL$RETRY GR 0) 
            THEN                     # IF PRIMARY USER ATTEMPT        # 
              BEGIN 
              VAL$RETRY = VAL$RETRY - 1; # DECREMENT RETRY COUNT      # 
              END 
  
            END  # USER NOT VALIDATED # 
  
          ELSE
            IF NOT AAC$CPLK 
            THEN                     # NOT VALIDATED FOR INTER-HOST   # 
              BEGIN 
              VSTATUS = S"VRS$RETRY"; # FORCE NO MORE ATTEMPTS ALLOWED# 
              PFM$TEXT =
              "NO INTER-HOST VALIDATION      "; 
              MSG$BUFF  = 
              " NO INTER-HOST VALIDATION.      "; 
              MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
              END 
  
        END  # VALIDATE USER #
  
  
  
# 
*     IF USER VALIDATION SUCCEEDED ...
# 
  
      IF VSTATUS EQ S"VRS$VALID"
      THEN
        BEGIN                        # VALIDATION SUCCEEDED           # 
  
# 
*       MAINTAIN THE SSJ= BLOCK TO SUPPORT NOS PP ACCESS. 
# 
  
        SSJ$UIDW = VAL$UIDW;         # USER IDENTIFICATION WORD       # 
        SSJ$ALMW = VAL$ALMW;         # ACCOUNT LIMIT                  # 
        SSJ$ACLS = VAL$ACLS;         # COUNTING LIMIT                 # 
        SSJ$AACW = VAL$AACW;         # ACCESS CONTROL                 # 
  
# 
*       ENABLE SRU ACCUMULATION WHICH WAS TURNED OFF WHILE LISTENING
*       TO THE SOCKET WAITING FOR A CONNECTION. 
# 
  
        IF NOT VAL$SECOND 
        THEN
          BEGIN                      # PRIMARY USER JUST VALIDATED    # 
          RENSR;                     # ENABLE SRU ACCUMULATION        # 
          END 
  
# 
*       ISSUE ACCOUNT MESSAGES. 
# 
  
        IF NOT VAL$SECOND 
        THEN
          BEGIN                      # PRIMARY USER COMMAND           # 
          C<0, 80>MSG$BUFF = FFSUTBZ(MSG$ABUN, 80); 
          XSNM (MSG$BUFF, "!", FFSUTBZ(VAL$USER, 10), MSG$BUFF);
          XSNM (MSG$BUFF, "+", FFSUTBZ(VAL$FAMILY, 10), MSG$BUFF);
          XSNM (MSG$BUFF, "-", FFSUTBZ(VAL$TMNAME, 10), MSG$BUFF);
          MESSAGE (MSG$BUFF,5) ;     # ISSUE ABUN ACCOUNT MESSAGE     # 
  
          IF VAL$CHARGE NQ ZEROWORD 
          THEN
            BEGIN                    # ISSUE ABIC ACCOUNT MESSAGE     # 
            C<0, 80>MSG$BUFF =  FFSUTBZ(MSG$ABIC, 80);
            XSNM  (MSG$BUFF, "!", FFSUTBZ(VAL$CHARGE, 10), MSG$BUFF); 
            XSNM  (MSG$BUFF, "+", FFSUTBZ(VAL$PROJCT, 10), MSG$BUFF); 
            XSNM  (MSG$BUFF, "-", FFSUTBZ(VAL$PROJC2, 10), MSG$BUFF); 
            MESSAGE (MSG$BUFF, 5);   # ISSUE ABIC ACCOUNT MESSAGE     # 
            END                      # ISSUE ABIC ACCOUNT MESSAGE     # 
  
          END                        # PRIMARY USER COMMAND           # 
  
        ELSE
          BEGIN                      # SECONDARY USER COMMAND         # 
          C<0, 80>MSG$BUFF = FFSUTBZ(MSG$ACUN, 80); 
          XSNM (MSG$BUFF, "!", FFSUTBZ(VAL$USER, 10), MSG$BUFF);
          XSNM (MSG$BUFF, "+", FFSUTBZ(VAL$FAMILY, 10), MSG$BUFF);
          MESSAGE (MSG$BUFF,5) ;     # ISSUE ACUN ACCOUNT MESSAGE     # 
          END                        # SECONDARY USER COMMAND         # 
  
# 
*       IF CHARGE IS REQUIRED AND THE DEFAULT CHARGE EXISTS, THEN 
*       ISSUE THE DEFAULT CHARGE. 
# 
  
        IF (NOT AAC$CCNR) AND (FFSUTBZ(VAL$CHARGE, 10) NQ 0)
        THEN
          BEGIN                      # ISSUE DEFAULT CHARGE/PROJECT   # 
          DEFAULT = TRUE;            # SET DEFAULT CHARGE INDICATOR   # 
          ADDR$MSG = 0 ;
          JBC$VALID  = FALSE;        # CHARGE NOT YET VALIDATED       # 
          JBC$CHARGE = FFSUTBZ(VAL$CHARGE, 10);   # SET CHARGE        # 
          JBC$PROJCT = FFSUTBZ(VAL$PROJCT, 10);   # SET PROJECT       # 
          JBC$PROJC2 = FFSUTBZ(VAL$PROJC2, 10);   # SET PROJECT WORD 2# 
          C<0, 80>MSG$BUFF = FFSUTBZ(MSG$DCHG, 80); 
          XSNM (MSG$BUFF, "!", JBC$CHARGE, MSG$BUFF); 
          XSNM (MSG$BUFF, "+", JBC$PROJCT, MSG$BUFF); 
          XSNM (MSG$BUFF, "-", JBC$PROJC2, MSG$BUFF); 
          MESSAGE (MSG$BUFF, 0);       # ISSUE CHARGE TO DAYFILE      # 
  
          P<DUMMYBA> = LOC(VAL$PROJCT); 
          SETCHG (JBC$CHARGE, DUMMYBA, FFSUTBZ(VAL$USER, 10), 
                  DEFAULT, ADDR$MSG); 
  
          IF ADDR$MSG EQ 0
          THEN
            BEGIN                    # DEFAULT CHARGE WAS SUCCESSFUL  # 
            C<0, 80>MSG$BUFF = FFSUTBZ(MSG$ACHG, 80); 
            XSNM (MSG$BUFF, "!", JBC$CHARGE, MSG$BUFF); 
            XSNM (MSG$BUFF, "+", JBC$PROJCT, MSG$BUFF); 
            XSNM (MSG$BUFF, "-", JBC$PROJC2, MSG$BUFF); 
            MESSAGE (MSG$BUFF, 0);   # ISSUE ACTIVE CHARGE TO DAYFILE # 
            END                      # DEFAULT CHARGE WAS SUCCESSFUL  # 
  
          ELSE
            BEGIN                    # DEFAULT CHARGE REQUEST FAILED  # 
            P<CHG$MSGA> = ADDR$MSG;  # POSITION MESSAGE TEMPLATE      # 
            MESSAGE (CHG$MSG, 0);    # ISSUE MESSAGE FROM CHARGE PROC # 
            IF NOT AAC$CNRD 
            THEN                     # CHARGE IS RESTRICTED TO DEFAULT# 
                                     # AND IT IS INVALID - TERMINATE  # 
              BEGIN 
              VSTATUS = S"VRS$RETRY";# FORCE NO MORE ATTEMPTS ALLOWED # 
              PFM$TEXT =
              "THE CHARGE REQUIRED IS INVALID"; 
              MSG$BUFF =
              " THE CHARGE REQUIRED IS INVALID."; 
              MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
              END 
            END                      # DEFAULT CHARGE REQUEST FAILED  # 
  
          END                        # ISSUE DEFAULT CHARGE/PROJECT   # 
  
# 
*       USER IS VALIDATED.  DETERMINE IF A CHARGE IS STILL REQUIRED.
# 
  
        VAL$STATE = S"VST$USER";     # PRIMARY USER ESTABLISHED       # 
        GET$CSP (CSPW);              # GET NOS CSPW WORD FROM CPA     # 
        IF CSP$CCR
        THEN                         # CHARGE COMMAND REQUIRED        # 
          BEGIN 
          VAL$STATE = S"VST$CHARGE"; # USER VALID, CHARGE REQUIRED    # 
          IF VSTATUS NQ S"VRS$RETRY" # DON-T LOSE FORCED TERMINATION  # 
          THEN
            BEGIN 
            VSTATUS = S"VRS$CHGREQ"; # RETURN CHARGE REQUIRED STATUS  # 
            END 
          END 
  
        END                          # VALIDATION SUCCEEDED           # 
  
# 
*     IF USER VALIDATION FAILED, DETERMINE IF INVALID (MALICIOUS) USER. 
# 
  
      ELSE                           # USER VALIDATION FAILED         # 
        BEGIN                        # USER NOT VALIDATED             # 
        IF VAL$RETRY EQ 0 
        THEN                         # USER RETRY LIMIT EXCEEDED      # 
          BEGIN 
          VSTATUS = S"VRS$RETRY";    # SET RETRY LIMIT STATUS         # 
          PFM$TEXT =
          "USER RETRY LIMIT EXCEEDED.    "; 
          MSG$BUFF  = 
          " USER RETRY LIMIT EXCEEDED.     "; 
          MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
          END 
  
        IF PASS$ EQ ZEROWORD
        THEN                         # FAILED DESPITE NO PASSWORD     # 
          BEGIN 
          VSTATUS = S"VRS$NOPASS";   # SET W/O PASSWORD FAILED STATUS # 
          PFM$TEXT =
          "INCORRECT USER COMMAND.       "; 
          MSG$BUFF  = 
          " INCORRECT USER COMMAND.        "; 
          MESSAGE (FFSUTBZ(MSG$BUFF,80), 0);
          END 
  
        IF VSTATUS GR S"VRS$ERROR"
        THEN                         # INVALID/MALICIOUS USER         # 
          BEGIN 
          VAL$STATE = S"VST$ERROR";  # DECLARE USER INVALID           # 
          END 
  
        END                          # USER NOT VALIDATED             # 
  
      RETURN; 
      END    # FFSUVUI #
  
      TERM
