Retro1.org codex

*DECK     NVFTVVD 
USETEXT          TEXTNVF
USETEXT          TEXTSS 
USETEXT          TXSMNVF
USETEXT          TXTANVF
USETEXT          TXTAPSS
 
PROC NVFTVVD; 
# TITLE NVFTVVD - VERIFY VALIDATION DATA                               #
 
      BEGIN  # NVFTVVD #
# 
**    NVFTVVD - VERIFY VALIDATION DATA. 
* 
*     E. THAVIKULWAT    81/10/14
* 
*     THIS PROCEDURES' MAIN FUNCTION IS TO DETERMINE WHETHER OR NOT 
*     USER VERIFICATION WAS SUCCESSFUL.  IT IS CALLED INTO EXECUTION
*     BY PROCEDURE *NVFTDQE*. 
* 
*     PROC NVFTVVD
* 
*     ENTRY:  
*       WC IN *WCBUF* 
*       ABH IN *ABHBUF* 
*       VERIFICATION DATA IN *MSGBUF* 
* 
*     EXIT: 
*       PASSWORD OVERMASK IS ISSUED ON LOGIN FOR ASYNCHRONOUS 
*       TERMINAL CLASSES  AND ONE OF THE FOLLOWING: 
*         1) APPLICATION PROMPT ISSUED. 
*         2) CONNECTION SWITCHED TO APPROPRIATE APPLICATION.
*         3) CONNECTION TERMINATED. 
*         4) PERSONAL IDENTIFIER PROMPT ISSUED. 
* 
*     NOTES:  
*       SHOULD A CONNECTION-BROKEN OCCUR PRIOR TO THIS, NO FURTHER
*       PROCESSING OF THE DATA IS DONE AND THE TERMINATING ROUTINE
*       IS CALLED.  VERIFICATION IS SUCCESSFUL ONLY IF THE SECURITY 
*       COUNT IS NOT EXHAUSTED, FAMILY NAME, USER NAME, PASSWORD, AND 
*       PERSONAL ID ARE VALID, AND THE USER IS VALIDATED FOR AT LEAST 
*       ONE APPLICATION.
*       IF THE TERMINAL CLASS IS 8 OR UNDER (ASYNCHRONOUS) BUT NOT A
*       IBM2741, THE TERMINAL INPUT LINE CONTAINING THE PASSWORD WILL 
*       BE MASKED.  SEE FURTHER NOTES IN INTERNAL PROCEDURE *MASKINPUT*.
* 
*     METHOD: 
*       SEARCH PTAC TABLE FOR ENTRY THAT MATCHES ACN OF THIS REQUEST. 
*       IF MATCH, INITIAL LOGIN, AND THE TERMINAL IS OF THE 
*       ASYNCHRONOUS TERMINAL CLASS, ISSUE THE PASSWORD OVERMASK. 
*       COPY THE VALIDATION DATA INTO THE PTAC ENTRY.  IF 
*       CONNECTION-BROKEN OCCURRED PRIOR TO THIS, CALL *NVFTETC* AND
*       EXIT.  IF TERMINAL IS STILL CONNECTED, VERIFY VALIDATION DATA 
*       AND ROUTE CONTROL TO THE APPROPRIATE ROUTINE.  IF NO PTAC 
*       ENTRY IS FOUND FOR THIS ACN, SET UP DECREMENT FAMILY COUNT
*       (73B) AND EXIT. 
# 
 
# 
****  PROC NVFTVVD - XREF LIST. 
# 
 
      $BEGIN
      XREF
        BEGIN 
        PROC ABORT;          # ABORT JOB                               #
        PROC MESSAGE;        # SEND MESSAGE TO SYSTEM AND USER DAYFILE #
        END 
      $END
 
      XREF
        BEGIN 
        PROC NVFSCAD;        # COMPLETE APPLICATION DEPARTURE          #
        PROC NVFTETC;        # END TERMINAL CONNECTION                 #
        PROC NVFTILP;        # ISSUE LOGIN PROMPTS                     #
        PROC NVFTPSV;        # PROCESS SUCCESSFUL VALIDATION           #
        PROC NVFTPUV;        # PROCESS UNSUCCESSFUL VALIDATION         #
        PROC NVFTURT;        # UPDATE *RAU* TABLE                      #
        PROC NVFTVAA;        # VALIDATE USER'S RIGHT TO ACCESS APPL    #
        PROC NVFUMQE;        # TRANSFER TEXT QUEUE                     #
        PROC SSTAQE;         # ACCEPT QUEUE ENTRY                      #
        FUNC XSFW C(10);     # SPACE FILL WORD                         #
        END 
 
*CALL TMSGNVF 
 
 
# 
****
# 
      ITEM AS         I;     # SUBSCRIPT FOR ARRAY AST                 #
      ITEM ASENTRY    I;     # NUMBER OF AST ENTRIES                   #
      ITEM I          I;     # LOOP VARIABLE                           #
      ITEM J          I;     # LOOP VARIABLE                           #
      ITEM LNGTH      I;     # LENGTH OF MESSAGE                       #
      ITEM MATCH      B;     # EXIT LOOP VARIABLE                      #
      ITEM NENTRY     I;     # NUMBER OF ENTRIES IN TABLE              #
      ITEM PRIAPP     B;     # PRIMARY APPLICATION INDICATOR           #
      ITEM PT         I;     # SUBSCRIPT FOR ARRAY PTAC                #
      ITEM PTTC       I;     # TERMINAL CLASS                          #
 
      $BEGIN
# 
*     FOLLOWING ARRAY CONTAINS MESSAGE ISSUED TO THE DAYFILE UPON NOT 
*     FINDING AN EXPECTED PTAC ENTRY. 
# 
      ARRAY DAYMSG[00:00] S(4); 
        BEGIN 
        ITEM DAY$MSG1   C(00,00,27) = ["NVFTVVD - CANNOT FIND PTAC "];
        ITEM DAY$MSG2   C(02,42,05) = ["ENTRY"];
        END 
 
      $END
 
# 
*     THE FOLLOWING ARRAY WILL BE USED AS TEMPORARY STORAGE OF THE
*     PERSONAL ID 
# 
      ARRAY PIDENTRY[00:00] S(2); 
        BEGIN 
        ITEM PID$WRD1   U(00,00,60);
        ITEM PID$WRD2   U(01,00,60);
        ITEM PID$CHAR   C(00,00,20);
        END 
 
# 
*     THE FOLLOWING BASED ARRAY POINTER POINTS TO THE FIRST WORD OF 
*     THE VALIDATION DATA PORTION OF THE PTAC ENTRY.
# 
      BASED ARRAY BPTACVD[00:00] S(1);
        BEGIN 
        ITEM BPT$WORD   U(00,00,60);   # FULL WORD REFERENCE           #
        END 
 
# 
*     SEARCH PTAC TABLE FOR ENTRY THAT MATCHES ON ACN.
# 
      MATCH  = FALSE; 
      NENTRY = PTALNGTH / PTACSIZ$;    # CALCULATE NUMBER OF ENTRIES   #
      FOR PT = 0 STEP 1 WHILE (NOT MATCH AND PT LS NENTRY)
      DO
        BEGIN 
        IF PTA$VCB[PT] EQ ABHADR[0] 
        THEN                           # PTAC ENTRY FOUND              #
          BEGIN 
 
# 
*         COPY VALIDATION DATA FROM *MSGBUF* TO PTAC ENTRY. 
# 
          P<BPTACVD> = LOC(PTA$FWORD[PT]);   # POINTS TO FAMILY WORD   #
          FOR I = 0 STEP 1 UNTIL (WCB$WC[0] - 9)
          DO
            BEGIN 
            BPT$WORD[I] = MSG$WORD[I];
            END 
 
# 
*         COPY CHARGE AND PROJECT DATA FROM *MSGBUF* TO PTA ENTRY 
# 
 
          J = I;
          P<BPTACVD> = LOC(PTA$CHGNUM[PT]);  # POINTS TO CHARGE NUMBER #
          FOR I = 0 STEP 1 UNTIL 2
          DO
            BEGIN 
            BPT$WORD[I] = MSG$WORD[J+I];
            END 
 
# 
*     COPY THE PERSONAL IDENTIFIER *MSGBUF* TO A TEMPORARY LOCATION AND 
*     COPY THE PASSWORD EXPIRATION DATE FROM *MSGBUF* TO THE PTAC ENTRY.
# 
          J = J + I;
          PID$WRD1[0] = MSG$WORD[J];
          PID$WRD2[0] = MSG$WORD[J + 1];
          P<BPTACVD> = LOC(PTA$EXPDAT[PT]); 
          BPT$WORD[0] = MSG$WORD[J + 2];
# 
*         IF THIS IS A USER LOGIN, TERMINAL CLASS IS ANY ASYNCHRO-
*         NEOUS TYPE OTHER THAN TC2741, AND NEITHER A MANDATORY 
*         NOR A PRIMARY USER NAME HAS BEEN SPECIFIED IN NDL FOR 
*         THIS TERMINAL, THEN WE NEED TO SEND OUT A PASSWORD MASK.
# 
          PTTC = PTA$TC[PT];
          IF (PTA$IUVF[PT]) AND (PTTC LQ TCT4014$) AND (PTTC NQ TC2741$)
             AND (PTA$USRIND[PT] NQ MNDATRY$) 
             AND (PTA$USRIND[PT] NQ PRIMARY$) 
            AND (NOT PTA$WSV[PT]) 
         THEN 
            MASKINPUT(PTA$PROMPT[PT] - 1);
# 
*     IF THE PERSONAL IDENTIFIER IS NOT REQUIRED FOR THE USER, BUT IT 
*     WAS ASSUMED TO HAVE BEEN ENTERED, THE ENTRY WAS ACTUALLY THE
*     APPLICATION ENTRY.  THE ENTRY WILL BE MOVED TO THE APPLICATION
*     PORTION OF THE PTAC TABLE AND THE ZERO FILLED ENTRY WILL BE 
*     CHANGED TO BE A BLANK FILLED ENTRY. 
# 
          IF (PTA$COPI[PT] OR (PID$CHAR[0] EQ NULL$)) 
              AND PTA$VPIDF[PT] 
          THEN
            BEGIN 
            PTA$VLTAPP[PT] = XSFW(PTA$APPPID[PT]);
            PTA$PID[PT] = NULL$;
            PTA$VPIDF[PT] = FALSE;     # NO VOLUNTEERED PERSONAL ID    #
            PTA$VAF[PT] = TRUE;        # A VOLUNTEERED APPL EXISTS     #
            END 
 
# 
*         IF CONNECTION-BROKEN HAS OCCURRED, TERMINATE CONNECTION.
*         OTHERWISE, CHECK VALIDATION DATA AND ROUTE CONTROL TO THE 
*         APPROPRIATE ROUTINES. 
# 
          IF PTA$STATE[PT] EQ PTACST"CONBROK" 
          THEN                         # CONNECTION BROKEN OCCURRED    #
            BEGIN 
# 
*           IF THIS IS A LOAN REQUEST, LOCATE THE PRIMARY APPL *AST*
*           ENTRY AND DECREMENT THE NUMBER OF RESERVED CONNECTIONS. 
*           UPDATE THE *RAU* TABLE IF NECESSARY.
# 
            IF PTA$LRC[PT] GQ RCRC"LSA" 
            THEN
              BEGIN 
              PRIAPP = TRUE;
              NVFTURT(PTA$VCB[0],PT,PRIAPP);
 
              ASENTRY = ASTLNGTH/ASTSIZ$; 
              FOR AS = 0 STEP 1 WHILE 
                ((AS LS ASENTRY) AND
                 (AST$AN[AS] NQ PTA$PRIAN[PT])) 
              DO
                BEGIN 
                END 
              IF AS LS ASENTRY
              THEN
                BEGIN 
                AST$RACN[AS] = AST$RACN[AS] - 1;
                NVFSCAD(AS);
                END 
              END 
            NVFTETC(PT);               # END TERMINAL CONNECTION       #
            END 
          ELSE                         # TERMINAL STILL CONNECTED      #
            BEGIN 
# 
*     IF DEVICE ERROR FLAG IN PTAC IS SET, SEND "FAMILY NOT AVAILABLE,
*     TRY AGAIN LATER" MESSAGE TO TERMINAL AND END THE CONNECTION.
# 
            IF PTA$DVERR[PT]
            THEN
              BEGIN 
              NVFUMQE(P<CTQ>,FNABUF[0],APPTTX$,PTA$ACN[PT],LMSG50$);
              NVFTETC(PT);             # END TERMINAL CONNECTION       #
              RETURN; 
              END 
 
            IF (PTA$SCINV[PT] EQ 0) 
              AND ((PTA$AAVW[PT] LAN VAPMASK) NQ 0) 
            THEN                       # VALID LOGIN                   #
              BEGIN 
              IF (NOT PTA$WSV[PT])
              THEN
                BEGIN 
 
# 
*     THIS IS A ORIGINAL VALIDATION AND EVERYTHING IS VALID.
*     VALIDATE THE PERSONAL ID IF IT IS REQUIRED AND HAS BEEN ENTERED.
*      IF IT HAS NOT BEEN VOLUNTEERED PROMPT THE USER FOR IT. 
# 
 
                IF (NOT PTA$COPI[PT]) AND (PID$CHAR[0] NQ NULL$)
                THEN                   # PERSONAL IDENTIFIER REQUIRED  #
                  BEGIN 
                  IF PTA$VPIDF[PT]
                  THEN                 # PERSONAL ID VOLUNTEERED       #
                    BEGIN 
                    IF (PID$CHAR[0] NQ PTA$PID[PT]) 
                    THEN               # PERSONAL ID ENTERED INVALID   #
                      BEGIN 
                      PTA$INVPID[PT] = TRUE;
                      NVFTPUV(PT);     # PROCESS UNSUCCESSFUL VALIDATN #
 
                      RETURN;          # EXIT                          #
                      END 
                    END 
                  ELSE                 # PERSONAL ID NOT VOLUNTEERED   #
                    BEGIN 
                    PTA$PID[PT] = PID$CHAR[0];
                    PTA$PROMPT[PT] = AWTPID$; 
                    NVFTILP(PT);       # ISSUE PERSONAL ID LOGIN PROMPT#
 
                    RETURN;            # EXIT                          #
                    END 
                  END 
                IF PID$CHAR[0] NQ NULL$ 
                THEN                   # SAVE PID FOR ACCOUNT MESSAGE  #
                  PTA$PID[PT] = PID$CHAR[0];
                NVFTPSV(PT);           # PROCESS SUCCESSFUL VALIDATION #
                IF PTA$STATE[PT] EQ PTACST"AWTVAA"
                THEN                   # NEED TO VALIDATE              #
                  BEGIN 
                  NVFTVAA(PT);         # VALIDATE RIGHT TO ACCESS APPL #
                  END 
                END 
              ELSE
 
# 
*     THIS IS A REVALIDATION. FAMILY AND USER NAME ARE GOOD,
*     BUT PASSWORD IS INVALID.
# 
 
                BEGIN 
                PTA$INVLF[PT]=TRUE; 
                PTA$UIDX[PT] = 0;      # CLEAR USER INDEX FIELD        #
                PTA$WSV[PT]=FALSE;
                IF ((NOT PTA$COPI[PT]) AND (PID$CHAR[0] NQ NULL$) AND 
                   (PTA$AAWC[PT] NQ NULL$) AND (NOT PTA$VPIDF[PT])) 
                THEN                   # INVALID PASSWORD,PID REQUIRED #
                  BEGIN 
                  PTA$PROMPT[PT] = AWTPID$; 
                  NVFTILP(PT);         # ISSUE PERSONAL ID LOGIN PROMPT#
                  END 
                ELSE                   # PID NOT REQUIRED              #
                  BEGIN 
                  NVFTPUV(PT);         # PROCESS UNSUCCESSFUL VALIDATIO#
                  RETURN; 
                  END 
                END 
              END 
            ELSE                       # INVALID LOGIN                 #
              BEGIN 
              IF (NOT PTA$WSV[PT])
              THEN
                BEGIN 
 
# 
*   THIS IS A ORIGINAL VALIDATION, SINCE IT IS A INVALID LOGIN, WE NEED 
*   TO ISSUE CPM56 REQUEST TO REVALIDATE FAMILY AND USER NAME AGAIN.
# 
 
                P<CRQBUF>=LOC(MSGBUF[0])+((NMSGBUF$+1)/2);
                CRQ$FCWORD[0]=0;
                CRQ$FWORD[0]=0; 
                CRQ$PWORD[0]=0; 
                CRQ$UWORD[0]=0; 
                CRQ$FC[0]=CPM56B$;
                CRQ$ACN[0]=PTA$VCB[PT]; 
                CRQ$FNAM[0]=PTA$FNAM[PT]; 
                CRQ$VPWF[0]=TRUE;      # PASSWORD NOT TO BE VALIDATED  #
                CRQ$IFCTF[0]=FALSE;    # DO NOT INCREMENT FAMILY COUNT #
                CRQ$RETPID[0] = TRUE;  # RETURN THE PERSONAL IDENTIFIER#
                CRQ$UNUM[0]=PTA$UNUM[PT]; 
                CRQ$QNUM[0]=LOC(P<VDATAQ>); 
                LNGTH=CRQVSIZ$*10;
                NVFUMQE(P<CPMRQ>,CRQBUF[0],APPTTX$,0,LNGTH);
                PTA$STATE[PT]=PTACST"AWTVAL"; 
                PTA$PWEXPF[PT]=TRUE;   # DO NOT REISSUE PW EXP MESSAGE #
                PTA$WSV[PT]=TRUE;      # WAIT FOR SECOND VALIDATION    #
                RETURN; 
                END 
              ELSE
 
# 
*     THIS IS A REVALIDATAION. FAMILY AND USER NAME ARE NOT 
*     VALID. SET UP THE FLAG IN ORDER NOT TO ISSUE FAMILY AND USER
*     NAME IN AN "ABER" ACCOUNTING MESSAGE, SINCE THE INVALID USER
*     NAME COULD PROBABLY BE A PASSWORD.
# 
 
                BEGIN 
                PTA$WSV[PT]=FALSE;
                PTA$IFU[PT]=TRUE;      # BAD FAMILY/USER NAME PACK     #
                NVFTPUV(PT);           # PROCESS UNSUCCESSFUL VALIDATN #
                END 
              END 
            END 
 
          MATCH = TRUE; 
          END 
        END  # END FOR PT LOOP #
 
# 
*     IF NO PTAC ENTRY COULD BE FOUND, DECREMENT FAMILY COUNT AND EXIT. 
# 
      IF NOT MATCH
      THEN                             # NO PTAC ENTRY FOUND           #
        BEGIN 
        $BEGIN
        MESSAGE(DAYMSG,0);             # MSG TO SYSTEM AND USR DAYFILE #
        ABORT;
        $END
 
        P<CRQBUF>     = LOC(MSGBUF[0]) + ((NMSGBUF$ + 1) / 2);
        CRQ$FCWORD[0] = 0;
        CRQ$FWORD[0]  = 0;
        CRQ$FC[0]     = CPM73B$;
        CRQ$ACN[0]    = 0;
        CRQ$FNAM[0]   = MSG$CHAR[0];
 
        LNGTH = CRQDSIZ$ * 10;
        NVFUMQE(P<CPMRQ>,CRQBUF[0],APPTTX$,0,LNGTH);
        END 
 
CONTROL EJECT;
PROC MASKINPUT((PROMPT)); 
# TITLE MASKINPUT - OVERMASK INPUT LINE                                #
 
      BEGIN  # MASKINPUT #
# 
**    MASKINPUT - OVERMASK INPUT LINE 
* 
*     G. A. HUGHES      86/02/17
* 
*     THIS PROCEDURE IS INTERNAL TO PROCEDURE *NVFTVVD* AND IS CALLED 
*     ONLY BY *NVFTVVD*.  IT'S MAIN FUNCTION IS TO OVERMASK THE INPUT 
*     LINE CONTAINING THE PASSWORD. 
* 
*     PROC MASKINPUT
* 
*     ENTRY:  
*       *PROMPT* CONTAINS THE A LABEL POINTER TO LAST PROMPT ISSUED.
* 
*     EXIT: 
*       MASK BUILT AND ISSUED TO THE QUEUE. 
* 
*     NOTES:  
*       1) IF THE PROMPT IS A PASSWORD PROMPT AND THE TERMINAL IS A M33,
*          A 2741, OR A T4014, THEN THE MASK IS BUILT WITHOUT A PROMPT. 
*       2) IN ALL OTHER CASES THE PROMPT WILL BEGIN EACH CHARACTER OF 
*          THE MASK.
*       3) THE FIRST TWO CHARACTERS IN THE SECOND WORD OF THE PROMPT
*          MUST REMAIN BLANKS TO RETAIN THE ORIGINAL SPACING. 
* 
*     METHOD: 
*       DETERMINE HOW MANY CM WORDS EACH MASK LINE WILL NEED.  INSERT 
*       THE PROMPT AND THE MASK CHARACTERS INTO THE BUFFER.  BEFORE 
*       EACH LINE OF THE MASK A FORMAT EFFECTOR IS INSERTED TO SET THE
*       CURSOR BACK TO THE BEGINNING OF THE LINE.  A LINE FEED FORMAT 
*       EFFECTOR IS ISSUED FOLLOWING THE MASK AND CURSOR POSITIONING
*       IS REINSTATED.
# 
 
      DEF NUMBERMASK #4#;    # NUMBER OF SEPARATE MASKS TO GENERATE    #
      DEF BEGIN$LINE #"+"#;  # POSITION TO START OF CURRENT LINE FE    #
      DEF NEW$LINE   #" "#;  # SPACE ONE LINE FORMAT EFFECTOR          #
 
      ITEM IDX           I;  # INDEX FOR SECOND HALF OF *MSGBUF*       #
      ITEM MASK$CHAR     I;  # NUMBER OF CHAR BEYOND WORD BOUNDARY     #
      ITEM MASK$WORD     I;  # NUMBER OF WORDS TO MASK                 #
      ITEM MSK           I;  # MASK NUMBER LOOP COUNTER                #
      ITEM PROMPT        I;  # LAST PROMPT ISSUED                      #
      ITEM WD            I;  # *MSGBUF* LOOP COUNTER                   #
      ITEM WORD$NUMBER   I;  # CURRENT WORD OF MASK BEING BUILT        #
 
# 
*     THE FOLLOWING BUFFER IS USED TO ISSUE  A LINE FEED TO A TERMINAL
*     WHEN THE TERMINAL INPUT DOES NOT CONTAIN A PASSWORD.
# 
      ARRAY NEWLINE[00:00] S(1);
        BEGIN 
        ITEM LINEFEED   C(00,00,01) = [" "];
        END 
 
# 
*     THE FOLLOWING ARRAY DEFINES THE CHARACTERS TO BE USED IN BUILDING 
*     THE OVERMASK. 
# 
      ARRAY DEFMASK[00:03] S(6);
       BEGIN
       ITEM DEF$WORD   C(00,00,60) =             # FULL WORD REFERENCE #
       ["HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH", 
        "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII", 
        "############################################################", 
        "                                                            "];
       END
 
# 
*     THE FOLLOWING BASED ARRAY POINTS TO THE MASK BEING BUILT. 
# 
 
      BASED ARRAY BLDMASK[00:00] S(1);
        BEGIN 
        ITEM BLD$WRD1   C(00,00,10);   # SINGLE WORD REFERENCE         #
        END 
 
# 
*     THE FOLLOWING BASED ARRAY POINTS TO A TWO WORD FIELD FOR THE MASK 
# 
 
      BASED ARRAY BLDMASK2[00:00] S(2); 
        BEGIN 
        ITEM BLD$WRD2   C(00,00,20);   # DOUBLE WORD REFERENCE         #
        END 
 
# 
*     THE FOLLOWING BASED ARRAY POINTS TO A SEVEN WORD FIELD FOR THE
*     MASK. 
# 
 
      BASED ARRAY BLDMASK7[00:00] S(7); 
        BEGIN 
        ITEM BLD$WRD7   C(00,00,70);   # SEVEN WORD REFERENCE          #
        END 
 
      SWITCH MPRMTSWT 
                 MLLAPPL,    # LABEL FOR APPLICATION PROMPT            #
                 MLLPRID,    # LABEL FOR PERSONAL ID PROMPT            #
                 MLLPWRD,    # LABEL FOR PASSWORD PROMPT               #
                 MLLUSER,    # LABEL FOR USER PROMPT                   #
                 MLLFAM;     # LABEL FOR FAMILY PROMPT                 #
 
# 
*     CLEAR OUT GOING SUPERVISORY MESSAGE BUF (SECOND HALF OF *MSGBUF*) 
# 
 
      IDX = (NMSGBUF$ + 1) / 2;        # INDEX TO 2ND HALF OF *MSGBUF* #
      FOR WD = IDX STEP 1 UNTIL NMSGBUF$
      DO
        BEGIN 
        MSG$WORD[WD] = 0; 
        END 
 
      P<BLDMASK> = LOC(MSGBUF[0]) + ((NMSGBUF$ + 1) / 2); 
      MASK$CHAR = 60; 
 
      MASK$WORD = (MASK$CHAR / 10) + 1;  # NUMBER OF WORDS IN INPUT    #
      WORD$NUMBER = 0;
      IF ((PTTC EQ TCM33$) OR (PTTC EQ TCT4014$)) 
         AND (PTA$PROMPT[PT] EQ AWTPWD$)
      THEN                             # PASSWORD NOT ON PROMPT LINE   #
        BEGIN 
        IF (MASK$CHAR - ((MASK$WORD - 1) * 10) GQ 8)
        THEN                           # INSURE ZERO BYTE, INCLUDE FE  #
           MASK$WORD = MASK$WORD + 1; 
 
        FOR MSK = 0 STEP 1 UNTIL (NUMBERMASK - 1) 
        DO
          BEGIN 
          C<0,1>BLD$WRD1[WORD$NUMBER] = BEGIN$LINE; 
          C<1,MASK$CHAR>BLD$WRD1[WORD$NUMBER] = DEF$WORD[MSK];
          WORD$NUMBER = WORD$NUMBER + MASK$WORD;
          END 
        END 
      ELSE                             # PASSWRD ENTERD ON PROMPT LINE #
        BEGIN 
        IF (MASK$CHAR - ((MASK$WORD - 1) * 10) GQ 7)
        THEN                           # INCREMENT FOR ZERO BYTE       #
          MASK$WORD = MASK$WORD + 1;
 
        FOR MSK = 0 STEP 1 UNTIL (NUMBERMASK - 1) 
        DO
          BEGIN 
          P<BLDMASK2> = LOC(BLD$WRD1[WORD$NUMBER]); 
          GOTO MPRMTSWT[PROMPT];
 
MLLFAM: 
          C<0,12>BLD$WRD2[0] = FAM$PRMT;
          GOTO ENDMASK; 
 
MLLUSER:  
          C<0,12>BLD$WRD2[0] = USR$PRMT;
          GOTO ENDMASK; 
 
MLLPWRD:  
          C<0,12>BLD$WRD2[0] = PWD$PRMT;
          GOTO ENDMASK; 
 
MLLPRID:  
MLLAPPL:  
ENDMASK:                               # END OF CASE                   #
          C<0,1>BLD$WRD2[0] = BEGIN$LINE; 
          WORD$NUMBER = WORD$NUMBER + 1;
          C<2,MASK$CHAR>BLD$WRD1[WORD$NUMBER] = DEF$WORD[MSK];
          WORD$NUMBER = WORD$NUMBER + MASK$WORD;
          END 
        END 
 
# 
*     ADD A LINE FEED TO THE GENERATED OVERMASK, QUEUE THE BUFFER,
*     AND TURN CURSOR POSITIONING BACK ON.
# 
      C<0,1>BLD$WRD1[WORD$NUMBER] = NEW$LINE; 
      WORD$NUMBER = WORD$NUMBER + 1; # INCREMENT FOR ACTUAL COUNT    #
      WCB$WC[1] = WORD$NUMBER + 2;
      ABHWORD[1] =0;
      ABHABT[1] = APPTTX$;
      ABHADR[1] = PTA$ACN[PT];
      ABHACT[1] = CT6DISPLAY; 
      ABHTLC[1] = WORD$NUMBER * 10; 
      SSTAQE(P<CTQ>,WCBUF[1],ABH[1],BLDMASK[0]);
      END  # MASKINPUT #
 
      END  # END NVFTVVD #
 
TERM