*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 = 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 = 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 = 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,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=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); LNGTH=CRQVSIZ$*10; NVFUMQE(P,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 = 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,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 = 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 = 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,WCBUF[1],ABH[1],BLDMASK[0]); END # MASKINPUT # END # END NVFTVVD # TERM