.TITLE BATCH SUBMIT EXECUTOR .IDENT /V01.12/ ; COPYRIGHT (C) 1978 ; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. ; ; THIS SOFTWARE IS FURNISHED UNDER A LICENSE FOR USE ONLY ON A ; SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE ; INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE, OR ; ANY OTHER COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE ; MADE AVAILABLE TO ANY OTHER PERSON EXCEPT FOR USE ON SUCH ; SYSTEM AND TO ONE WHO AGREES TO THESE LICENSE TERMS. TITLE ; TO AND OWNERSHIP OF THE SOFTWARE SHALL AT ALL TIMES REMAIN ; IN DEC. ; ; THE INFORMATION IN THIS DOCUMENT IS SUBJECT TO CHANGE WITHOUT ; NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL ; EQUIPMENT CORPORATION. ; ; DEC ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ; ; VERSION V01.00 ; ; ERIC ROSDOL SWS/VIENA ; ; 11-FEB-78 ; ; MODULE CONTENTS: ; ; THIS MODULE CONTAINS ALL ROUTINES NECESSARY TO CONTROL THE ; THE PSEUDO BATCH FUNCTIONALITY OF THE SUBMIT COMMAND WITH ; THE VIRTUAL TERMINAL DRIVER VT1: ; ; MODULE MODIFICATION HISTORY: ; ; JGD01 23-MAY-78 MODIFIED TO CLEAN UP A BIT, EXTEND BUFFER SIZE ; FOR LOG FILE, TRUNCATE LOG FILE ON EXIT, ETC ; CORRECT(OR TRY TO) SEVERE SYNCRONIZATION PROBLEMS ; WITH LOGING ON. ALSO (TOGETHER WITH BYE MODIFICATIONS) FIX ; LOGOFF SYNCRONIZATION PROBLEM. ; ALSO AS INITIALLY WRITTEN, BATCH(NE' SEX...) ; DID NOT CORRECTLY USE THE UIC OF THE ; SENDER TASK WHEN INSTALLED AS SLAVE. ; ; JGD02 SPEED BATCH UP A BIT. HAVE BYE SEND A '>' IF ; A VT: LOGS OFF. BATCH NEED NOT WAIT 10 SEC FOR BYE ; COMMAND TO TIME OUT(THIS IS REALLY A BYE FIX). CHECK FOR ; ...AT. TO BECOME ACTIVE BEFORE STARTING TIMEOUT ON READS ; TO ...AT. THIS SOLVES A WIERD PROBLEM IN WHICH IF ...AT. ; WAS NOT ACTIVATED BY THE @COMMAND AT VT: WITHIN 2 SECONDS ; BATCH WOULD SEND A BYE TO MCR FROM VT:. BYE WOULD THEN ; PROCEED TO ABORT ...AT. BEFORE IT HAD EVEN STARTED EXECUTING ; THE COMMAND FILE. THIS PROBLEM ONLY OCCURED WHEN THE SYSTEM ; WAS LOADED DOWN. ; ; JGD03 A MAJOR REWRITE. AS INITIALLY WRITTEN, BATCH WOULD MALFUNCTION ; WITH ANY NON MCR COMMANDS. THIS WAS BECAUSE BATCH TIMES OUT ; IF IT DID NOT NOTICE THAT MCR WAS PROCESSING AN INDIRECT COMMAND ; (IE U2.AT ON). THIS MENT NICE FEATURES LIKE CREATING COMMAND ; FILES ON THE FLY WERE IMPOSSIBLE. ; TO FIX THIS PROBLEM, AST'S ARE NOT USED TO TIME OUT ; READS TO VT:(THE OUTPUT FROM THE BATCH ...AT.). THIS SPEEDS ; THINGS UP AT TIMES. SINCE THERE ARE NO LONGER ANY(OR ALMOST) ; TIMEOUTS, THE END OF THE INDIRECT COMMAND FILE IS DETECTED BY ; SCANNING THE BUFFER FOR @ , AT WHICH POINT THE COMMAND ; IS SENT TO VT: TO LOG OFF. WITH THESE CHANGES, THE PREVIOUS ; BYE CHANGES COULD BE REMOVED, AND MAYBE SOMEDAY THEY WILL. ; ; JGD04 BATCH AND ALL THE TASKS IT SPAWNED ON VT: CAN HANG UP IF ; BATCH GETS SHUFFLED. DOING QIO IO.KILL AND MARKTIMES DO ; NOT SEEM TO SOLVE THE PROBLEM, NEITHER DOES PUTTING A ; TIMEOUT COUNT IN VTDRV. IT LOOKS AS IF THE SYSTEM PLACES ; A CHECKPOINT REQUEST TO BAT...(IT GETS MARKED WITH CKR) ; AND ALL ITS REGISTERS AND PC GETS SAVED, BUT IT CAN'T ; CHECKPOINT BECAUSE ITS IO COUNT IS ALMOST NEVER ZERO. ; AVOID PROBLEM BY MAKING BATCH NON-CHECKPOINTABLE JUST ; DURING THE TIMES IT IS READING FROM VT: ; ; ; THIS CODE EXPLICITLY EXCLUDES THE ORIGINAL NETWORK CODE ; JGD01 ; MACRO CALL DEFINITIONS ; JGD01 ; .MCALL ALUN$C,QIOW$,MRKT$C,RCVX$C,EXIT$S,FDAT$A,OPEN$W,GET$ .MCALL CMKT$S,GLUN$C,DIR$,QIOW$C,ASTX$S,QIO$,CLOSE$,OPEN$R,PUT$ .MCALL FDBDF$,FDRC$A,FDOP$A,FSRSZ$,FINIT$,PRINT$,DELET$,OPEN$U .MCALL GTSK$C,UCBDF$,WTSE$,ENCP$S,DSCP$S ; JGD01; JGD04 UCBDF$ ; JGD01 ; ; LOCAL MACRO DEFINITIONS ; .MACRO PMSG M MOV #M,MSGDPB+Q.IOPL ;SETUP MESSAGE ADDRESS MOV #M'L,MSGDPB+Q.IOPL+2 ; AND COUNT DIR$ #MSGDPB ; EXECUTE QIO .ENDM .MACRO PUSH X MOV X,-(SP) .ENDM .MACRO POP X MOV (SP)+,X .ENDM .NLIST BEX ; ; EQUATED SYMBOLS ; U2.AT.=20 ; ...AT. ACTIVE ON UNIT ; ; FILE DEFINITION BLOCKS ; LOG: FDBDF$ FDAT$A R.VAR,FD.CR ; ; JGD01 FDRC$A ,LOGBUF,132. ; EXPAND LOGBUF TO 132. TO HANDLE LONG LINES ; JGD01 FDOP$A 1,LOGDS,,FO.WRT ; ; FILE STORAGE REGION ; FSRSZ$ 1 ; ONLY ONE FILE AT A TIME ; ; DATA SET DESCRIPTOR BLOCK FOR THE LOG-FILE ; LOGDS: .WORD DEVL,DEV .WORD 0,0 ; UFD DESCRIPTOR BLOCK =0 => USE DEFAULT ; JGD01 ; UIC DESCRIPTOR IN $$FSR2 ; JGD01 .WORD 0,FILNM ; WILL BE DEFINED AT RUN TIME ; DEVICE FOR LOG FILES. ; IT IS A PECULIARITY OF TASKS INSTALLED AS SLAVE THAT THEY DO NOT KNOW ; JGD01 ; THE SY: OF THE TASK STARTING THEM OFF. WHEN AN ALUN$ ; JGD01 ; IS DONE, ONLY THE GLOBAL ASSIGNMENTS ARE SEARCHED, NOT THOSE LOCAL ; JGD01 ; TO THE INITIATING TERMINAL(WHICH BATCH KNOWS ABOUT). THIS CAUSES A ; JGD01 ; PROBLEM SINCE THE LOG FILE MUST BE WRITTEN OUT TO THE DISK DRIVE ; JGD01 ; CORRESPONDING TO THE SY: OF THE USER SUBMITTING THE FILE. EVEN ; JGD01 ; SWITCHING TO THE SYSTEM STATE AND SCANNING THE LOGICAL ASSINGMENTS ; JGD01 ; TABLE FOR THE TERMINAL WILL NOT HANDLE ALL PATHALOGICAL CASES. ; JGD01 ; (WHAT IF USER LOGS OFF, BATCH KNOWS TI:, BUT WHERE'S SY:?). ONE WAY ; JGD01 ; AROUND THE PROBLEM IS TO CODE THE COMMAND TO BATCH(FROM SUBMIT) IN ; JGD01 ; RAD50 FORMAT WHICH WOULD LEAVE ROOM FOR SENDING THE BATCH SY0:(WHICH ; JGD01 ; BY THE WAY SUBMIT WOULD HAVE TO FIND) ON TO WHICH TO RIGHT THE LOG ; JGD01 ; FILES. ; JGD01 ; AS A TEMPORARY EXPEDIENT, ALL USERS WHO WILL BE USING BATCH, ARE NOW ; JGD01 ; AND WILL REMAIN ON LB1:( GLOBALLY ASSIGNED, IN OUR CASE TO DK3:) ; JGD01 DEV: .ASCII /DK3:/ ; THIS MUST BE HARDWIRED IN ; JGD01 DEVL=.-DEV .EVEN UIC: .ASCII /[000,000]/ ; WILL BE USED IN CREATING THE DEFAULT UIC ; JGD01 ; DISCRIPTOR IN $$FSR2 ; JGD01 UICL=.-UIC .EVEN LOGXT: .ASCII /.LOG;1/ ; ONLY EVER KEEP ONE VERSION OF A LOG FILE ; JGD01 BYEBUF: .ASCII /BYE/ .BYTE 15 BYECT=.-BYEBUF ; ; DIRECTIVE PARAMETER BLOCKS ; VT1WRT: QIO$ IO.WLB,5,5,,,,<0,0,0> VT1RD: QIOW$ IO.RLB,5,5,,VTSTAT,,; ASK FOR UP TO 132 CHARACTERS BACK; JGD01 MSGDPB: QIOW$ IO.WBT,6,6,,,,<0,0,40> ; ; LOCAL DATA ; VTSTAT: .BLKW 2 ; LUNINF: .BLKW 6 ; LUN INFORMATION GLNBUF: .BLKW 6 ; BUFFER FOR GETLUN ; JGD01 CMDBUF: .BLKW 2 ; SENDERS TASK NAME RAD50 SPEC: .BLKW 15. ; SPECIFIER BUFFER AND OVERHEAD TIMOUT: .WORD 0 ; TIMEOUT INDICATOR LOGBUF: .BLKW 140. ; BUFFER FOR LOGFILE RECORD FILNM: .BLKW 30. ; LOGFILE FILENAME SNDNAM: .BLKW 2 ; SENDER'S TASK NAME PRMTSW: .WORD 0 ; PROMPT BYPASS SWITCH TEMP: .WORD 0 ; TEMP STORAGE ; JGD01 COUNT: .WORD 0 ; CHARACTER COUNT ; JGD01 TSKBUF: .BLKW 16. ; BUFFER FOR GTSK$ DIRECTIVE ; JGD01 LOGCNT: .WORD 0 ; NUMBER OF TIMES TRIED LOGGING ON ; JGD01 EOFFLG: .WORD 0 ; FLAG TO INDICATE END OF INDIRECT ; JGD01 ; COMMAND FILE REACHED ; JGD01 ; ; LOCAL MESSAGES ; MSG1: .ASCII <15>/BAT -- YOUR COMMAND FILE IS FINISHED/<15><12><7><7>/>/ MSG1L=.-MSG1 MSG2: .ASCII <15>"BAT -- I/O ERROR ON LOG FILE "<7><7><15><12>/>/ ; JGD01 MSG2L=.-MSG2 MSG3: .ASCII <15>/BAT -- ATTACH FAILURE ON VIRTUAL TERMINAL/<7><7><15><12>/>/ MSG3L=.-MSG3 MSG4: .ASCII <15>/BAT -- USER NOT ABLE TO LOG ONTO VT, TRY AGAIN/<7><15><12>/>/; JGD01 MSG4L=.-MSG4 ; JGD01 MSG5: .ASCII <15>/BAT -- COMMAND FILE EXTENSIONS NOT ALLOWED/<7><15><12>/>/ ; JGD04 MSG5L=.-MSG5 .EVEN HDRTXT: .ASCII /** START OF COMMAND FILE SUBMITTED BY :/ TSKNAM: .BLKB 6. .ASCII / **/ HDRLN=.-HDRTXT .EVEN ;+ ; **-$SBCFL ; ; THIS ROUTINE TRIES TO GET A DATA PACKET OUT OF ITS RECEIVE QUEUE. ; IF THIS QUEUE IS EMPTY, IT SIMPLY EXITS. IF NOT, ; COMMAND LOGON INFORMATION IS PARSED AND THE ; HELLO MCR FUNCTION EXECUTED ON VT1:. AFTER LOGGING IN, THE ; INDIRECT COMMAND FILE IS SUBMITTED TO VT1: FOR EXECUTION. ; NOTE THAT THE VIRTUAL TERMINAL IS NOT USED TO SUBMIT MCR TYPE ; COMMANDS FROM A UNPRIVLEGED TASK. IT IS USED TO GET ; INDIRECT COMMAND FILE INFORMATON LOGGED UNDER A FILE RATHER THAN ON THE ; NORMAL TI TERMINAL (WHICH IN ADDITION IT TIES UP). ; BATCH MUST BE INSTALLED AS A SLAVE TASK. IF IT IS SLAVE IT ASSUMES THE ; JGD01 ; UIC OF THE SENDER TASK(...SUB) AND THE TI: OF THE SENDER TASK. ; JGD01 ; BOTH FEATURES ARE NECESSARY IF BATCH IS TO OPEN A FILE ON THE USER'S ; JGD01 ; UFD AND NOTIFY THE USER (ON HIS VERY OWN TI:) WHEN ALL IS DONE. ; JGD01 ; THIS REQUIRES THAT BATCH BE PRIVLEGED BECAUSE IT MUST BE ABLE TO WRITE ; JGD01 ; INTO ANY UIC REQUESTED BY SUB. ALSO IT MUST BE PRIVLEGED TO CONTINUE ; JGD01 ; EXECUTION IF USER LOGS OFF HIS TERMINAL.(BATCH MUST NEVER BE ABORTED). ; JGD01 ; ; NOTE, IT IS NECESSARY TO INSERT THE TASK'S UIC INTO $FSR2. SINCE BAT...; JGD01 ; IS A SLAVE TASK,'S UIC BECOMES THAT OF THE INITIATING TERMINAL. WHEN IT; JGD01 ; INITIATED, THE ACT OF FIRST STARTING BATCH UP, CORRECTLY INITIALIZES THE; JGD01 ; DEFAULT DIRECTORY STRING IN $$FSR2. HOWEVER, IF BATCH RECEIVES ANOTHER ; JGD01 ; REQUEST BEFORE EXITING, THE DEFAULT UIC IN $$FSR2 MUST BE CHANGED TO ; JGD01 ; THAT OF THE NEW TERMINAL'S UIC. THERE MUST BE A BETTER WAY OF DOING THIS ; JGD01 ; THAN THE FOLLOWING, BUT I HAVEN'T BEEN ABLE TO GET ANY TO WORK CORRECTLY.; JGD01 .ENABLE LSB $SBCFL:: ; REFERENCE LABEL ENCP$S ; ENABLE CHECKPOINTING, IF DISABLED ; JGD04 RCVX$C ,CMDBUF ; GET FIRST PACKET (COMMAND) ; AT THIS POINT THE TASK HAS ASSUMED THE TI: ; JGD01 ; AND UIC OF ...SUB. HOWEVER IT IS NECESSARY TO; JGD01 ; PUT THE INFORMATION ON UIC INTO $$FSR2 TO ; JGD01 ; GOVERN WHAT UIC BATCH TRIES TO OPEN A LOG FILE; JGD01 CLR EOFFLG ; ON TO SHOW THAT NOT AT END OF FILE YET ; JGD03 GTSK$C TSKBUF ; GET PARAMETERS OF THIS TASK(LIKE UIC OF TI:) ; JGD01 MOV #TSKBUF+30.,R0 ; ADDRESS OF UIC WORD ; JGD01 MOV (R0),R3 ; BINARY REPRESENTATION OF UIC ; JGD01 MOV #UIC,R2 ; WHERE UIC STRING WILL GO ; JGD01 MOV #1,R4 ; DO NOT SUPPRESS LEADING ZEROS,PLACE, IN STRING; JGD01 CALL .PPASC ; CONVERT BINARY UIC TO ASCII ; JGD01 MOV #UIC,R2 ; CREATE NEW DEFAULT DIRECTORY STRING IN $$FSR2 ; JGD01 MOV #9.,R1 ; 9 BYTES LONG ; JGD01 CALL .WDFDR ; WRITE IT INTO $$FSR2 ; JGD01 ; NONE OF THE CODE BELOW DOES WHAT IT SHOULD. I THOUGHT THAT WHILE IT WAS ; JGD01 ; NOT POSSIBLE TO KNOW THE CORRECT SY: OF THE USER, ONE COULD USE LB1:, FOR THE ; JGD01 ; LOG FILE OUTPUT. HOWEVER ALUN$ DOES NOT SEEM TO TRACK DOWN THE PHYSICAL UNIT ; JGD01 ; WHEN A TASK IS SLAVE. ; JGD01 ; ALUN$C 1,LB,1 ; ASSIGN SY TO LUN 1 ; JGD01 ; GLUN$C 1,GLNBUF ; GET LUN INFO ON SY: ; JGD01 ; MOVB GLNBUF+2,R1 ; GET UNIT NUMBER IN LOWER BYTE ; JGD01 ; BIC #177400,R1 ; CLEAR AWAY HIGH BYTE ; JGD01 ; MOV #DEV+2,R0 ; ADDRESS OF WHERE UNIT NUMBER IS TO GO ; JGD01 ; MOV #11040,R2 ; RADIX 8(BITS 0-7); UNSIGNED(BIT 8 = 0);NO ZERO; JGD01 ; ; SUPRESS(BIT 9=1);DON'T FILL WITH BLANKS(BIT 10); JGD01 ; ; FIELD WIDTH(BITS 11-15)=2 ; JGD01 ; CALL $CBTA ; CONVERT TO OCTAL NUMBER ; JGD01 ; MOV #GLNBUF,R0 ; ADDR OF GLNBUF ; JGD01 ; MOV #DEV,R1 ; ADDR OF DEVICE STRING ; JGD01 ; MOV (R0)+,(R1)+ ; MOVE IN ASCII DEVICE MNEMONIC ; JGD01 ALUN$C 6,TI,0 ; ASSIGN TI OF SENDER TASK ALUN$C 4,VT,0 ; ASSIGN TO VT AND CHECK IF LOADED BCC 10$ ; IF CC DEVICE OK JMP ATTERR ; PRINT ERROR MESSAGE 10$: ALUN$C 5,VT,1 ; ASSIGN TO COMMAND INPUT QIOW$C IO.ATT,5,5 ; ATTACH VT1 TERMINAL BCC 20$ ; IF CC ATTACH OK JMP ATTERR ; OTHERWISE PRINT ERROR 20$: MOV #CMDBUF,R1 ; GET ADDRESS OF SPEC'S MOV (R1),SNDNAM ; SAVE TASK NAME MOV 2(R1),SNDNAM+2 ; OF SENDER TASK MOV (PC)+,(R1)+ ; STORE THE LOGGON .ASCII /HE/ MOV (PC)+,(R1)+ ; COMMAND FOR VT1 .ASCII /L / 30$: CMPB #' ,(R1)+ ; IS IT A BLANK? BNE 30$ ; IF NE NO REZAP... MOVB #15,-1(R1) ; STUFF IN A MOV R1,R2 ; COPY FOR LATER USE SUB #CMDBUF,R1 ; GET LENGTH OF STRING MOV R1,VT1WRT+Q.IOPL+2 ; SETUP DPB COUNT FILED MOV #CMDBUF,VT1WRT+Q.IOPL ; AND DPB ADDRESS FILED MOV #FILNM,R3 ; SET ADDRESS OF FILENAME BUFFER 40$: MOVB (R2)+,(R3) ; COPY THE IND-FILENAME CMPB #'.,(R3) ; IS THE USER TRYING TO INCLUDE AN EXTENSION ; JGD04 BNE 45$ ; NOT THIS TIME ANYWAY ; JGD04 PMSG MSG5 ; WARN USER OF PROBLEM ; JGD04 JMP $SBCFL ; AND LOOK TO SEE IF ANOTHER FILE TO PROCESS ; JGD04 45$: TSTB (R3)+ ; HAVE WE GOTTEN TO THE END(NULL BYTE) ; JGD04 BNE 40$ ; IF NE, NOT FINISHED MOV #LOGXT,R4 ; SET ADDRESS OF EXTENSION DEC R3 ; OVERWRITE THE NULL BYTE .REPT 6 ; DO IT OVER 6 TIMES, IT'S EASIER ; JGD01 MOVB (R4)+,(R3)+ ; APPEND EXTENSION AND VERSION ; JGD01 .ENDR ; JGD01 MOVB #15,-1(R2) ; TERMINATE LINE WITHE SUB #FILNM,R3 ; FILE NAME LENGTH MOV R3,LOGDS+10 ; SETUP INDSDB OPEN$W #LOG ; OPEN OUTPUT FILE BCC 50$ ; IF CC NO FILE ERROR JMP FILERR ; OPEN ERROR 50$: PUSH R0 ; SAVE IT, BECAUSE NEXT PUSH R1 ; ROUTINE NEEDS IF MOV #TSKNAM,R0 ; GET ADDRESS TO STORE MOV SNDNAM,R1 ; GET FIRST RAD50 HALF OF TASK NAME CALL $C5TA ; CONVERT TO ASCII STRING MOV SNDNAM+2,R1 ; GET SECOND RAD50 HALF OF TASK NAME CALL $C5TA ; CONVERT TO ASCII STRING POP R1 ; GET OLD REGISTERS POP R0 ; BACK FROM STACK PUT$ R0,#HDRTXT,#HDRLN ; WRITE LOG HEADER BCC 60$ ; IF CC PUT OK JMP FILERR ; OTHERWISE FILE ERROR 60$: ;PUT$ R0,#CMDBUF,R1 ; LOG THE HELLO INPUT ; JGD01 BCC 70$ ; IF CC OK JMP FILERR ; OTHERWISE FILE ERROR 70$: CALL SBMCMD ; ISSUE HELLO COMMAND ; QIOW$C IO.KIL,5,5 ; IN CASE LEFT OVER HELLO MESSAGES ; JGD03*** CALL CKLOG ; SEE IF TERMINAL LOGGED ON ALRIGHT ; JGD01 BCC 75$ ; LOGGED ON OK, PROCEED ; JGD01 CLOSE$ R0 ; CLOSE THE LOG FILE ; JGD01 PMSG MSG4 ; WARN USER THAT HE COULDN'T LOG ONTO VT: ; JGD01 CLR TIMOUT ; RESET TIMEOUT SWITCH ; JGD01 QIOW$C IO.KIL,5,5 ; TIDY UP ANY LEFT OVER I/O ; JGD03 JMP $SBCFL ; GET A NEW COMMAND LINE ; JGD01 75$: SUB #2,R3 ; NOW FILENAME WITHOUT EXT., WITH AND @ MOV R3,VT1WRT+Q.IOPL+2 ; SETUP NEW COMMAND LENGTH DEC R1 ; POINT TO START OF COMMAND ADD R1,VT1WRT+Q.IOPL ; POINT DPB TO START OF COMMAND FIELD MOVB #'@,@VT1WRT+Q.IOPL ; STUFF IN AN AT SIGN DIR$ #VT1WRT ; EXECUTE COMMAND DIR$ #VT1RD ; ISSUE FIRST READ FOR OUTPUT FROM ...AT., ; JGD02 ; DON'T ISSUE ANY MARK TIMES. ; JGD02 BR 90$ ; GO LOG THE OUTPUT ; JGD02 ; THIS SECTION SHOULD BE REWRITTEN TO MAKE IT FLOW LINEARLY ; JGD03 ; 80$: ; REFERENCE LABLE ; JGD03 TST EOFFLG ; HAVE WE RECIEVED AN @ FROM ...AT.? ; JGD03 BEQ 85$ ; IF EQ, NO, CONTINUE TO ISSUE READS TO VT: ; JGD03 BR 100$ ; IF NE GO ISSUE BYE COMMAND ; JGD03 85$: ; REF LABLE ; JGD04 DSCP$S ; DISABLE CHECKPOINTING WHILE TALKING TO VT: ; JGD04 ; I THOUGHT WE COULD LIVE WITHOUT THIS, BUT BATCH AND ; JGD04 ; ALL VT: TASKS GET LOCKED UP IF BATCH GETS CHECKPOINTED; JGD04 DIR$ #VT1RD ; READ MCR MESSAGES ENCP$S ; MAKE TASK CHECKPOINTABLE AGAIN ; JGD04 TST TIMOUT ; FLAG SET BY TIMOUT ? BEQ 90$ ; IF EQ NO QIOW$C IO.KIL,5,5 ; KILL PENDING I/O ANYWAY GLUN$C 4,LUNINF ; READ LUN INFO FROM VT0 CLR TIMOUT ; RESET TIMOUT FLAG BIT #U2.AT.,LUNINF+6 ; IS ...AT. ACTIVE(WITH MCR COMMAND) ; U1.AT.=2 IF MCR IS PROCESSING AN MCR COMMAND BUT ; JGD02 ; U2.AT. NOT SET IF .AT. PROCESSING INTERNAL COMMAND ; JGD02 BNE 80$ ; IF NE YES, WAIT AGAIN BR 100$ ; OTHERWISE LOG OFF 90$: ; REF LABLE CLEAN OUT GARBAGE IN LOG FILE ; JGD01 CMP VTSTAT+2,#4 ; IF COUNT OF 4 ->A '>' ONLY ; JGD01 BEQ 80$ ; IF SO DON'T OUTPUT RECORD ; JGD01 MOV #LOGBUF,TEMP ; GET START OF BUFFER ; JGD01 PUSH R5 ; SAVE R5 ; JGD01 MOV VTSTAT+2,R5 ; GET CHARACTER COUNT ; JGD01 ADD TEMP,R5 ; POINT TO END OF BUFFER ; JGD01 CMPB (R5),#'> ; IS IT A '>' ; JGD01 BNE 92$ ; NO ,SKIP AROUND ; JGD01 CLRB (R5) ; YES, MAKE IT A NUL ; JGD01 92$: CMPB (R5),#12 ; IS IT A LF ; JGD01 BNE 94$ ; NO, SKIP ; JGD01 CLRB -2(R5) ; YES MAKE IT A NUL ; JGD01 94$: POP R5 ; RESTORE R5 ; JGD01 CMPB #'+,@TEMP ; MAYBE WE HAVE A '+' ; JGD01 BNE 96$ ; IF NE, NO ; JGD01 INC TEMP ; YES, SKIP OVER ; JGD01 DEC VTSTAT+2 ; AND DECREASE CHARACTER COUNT ; JGD01 96$: ; REF LABLE ; JGD01 PUSH R5 ; SAVE R5 ; JGD01 CMPB #'>,(R5) ; MAYBE SECOND CHARACTER IS A '>' ; JGD01 BNE 98$ ; IF NE, NO SKIP AROUND ; JGD01 CLRB (R5) ; YES SO MAKE IT A NUL ; JGD01 98$: ; REF LABLE ; JGD01 CALL CHKEOF ; CHECK TO SEE IF END OF INDIRECT COMMAND FILE ; JGD02 POP R5 ; RESTORE R5 ; JGD01 PUT$ R0,TEMP,VTSTAT+2; LOG THE MCR OUTPUT ; JGD01 BCC 80$ ; IF CC NO FILE ERROR ; JGD01 JMP FILERR ; OTHERWISE PRINT ERROR ; JGD01 100$: MOV #BYEBUF,VT1WRT+Q.IOPL ; SETUP ADDRESS OF BYE BUFFER MOV #BYECT,VT1WRT+Q.IOPL+2 ; AND BYTE COUNT MRKT$C ,10,2,MKAST1 ; TIMEOUT ON BYE FOR SOME STRANGE REASONS CALL SBMCM1 ; ISSUE BYE COMMAND ALTERNATE ENTRY RESUM: CMKT$S ; CANCEL THE MARK TIME CLR PRMTSW ; CLEAR PROMPT REVERSE SWITCH ; PRINT$ R0 ; SPOOL THE LOG FILE CLOSE$ R0 ; CLOSE THE FILE, THE USER CAN PIP IT TO TI: BCS FLERR ; IF CS, CLOSE ERROR ; IF IT IS DESIRED TO SPEED UP THE CREATION OF LISTING FILESONE MAY SET THE ; JGD01 ; EXTENSION BLOCK COUNT>1 IN FDAT$A. THE LOG FILE IS TRUNCATED AT THIS POINT TO ; JGD01 ; SAVE DISK SPACE. COMMENTING OUT THE CODE WILL SPEED UP PROCESSING SOMEWHAT FOR ; JGD01 ; SYSTEMS WITH LOTS OF DISK SPACE. ; JGD01 OPEN$U R0 ; OPEN FILE FOR UPDATE(NEED EXTEND ACCESS FOR TRUNCATE) ; JGD01 BCS FLERR ; IF CS, OPEN ERROR ; JGD01 CALL .TRNCL ; CLOSE THE FILE AND TRUNCATE IT ; JGD01 BCS FLERR ; IF CS, TRUNCATE ERROR ; JGD01 PMSG MSG1 ; PRINT READY MESSAGE CLR TIMOUT ; RESET POSSIBLE TIMEOUT SWITCH QIOW$C IO.KIL,5,5 ; KILL ANY PENDING IO ; JGD03 JMP $SBCFL ; DEQUE NEXT REQUEST OR EXIT FLERR: JMP FILERR ; GO REPORT FILE ERROR ; JGD03 .DSABLE LSB ;+ ; **-CHKEOF ; ; CHECK TO SEE IF ...AT. HAS OUTPUT AN @ ; OR IF IT HAS ISSUED A FATEL ERROR MESSAGE AT. -- FILE NOT FOUND ; IF SO SET EOFFLG ;- CHKEOF: ; REFERENCE LABLE PUSH R0 ; SAVE R0 FOR LATER ; JGD03 PUSH R1 ; SAVE R1 ; JGD03 MOV #LOGBUF,R0 ; ADDRESS OF BUFFER TO CHECK ; JGD03 MOV #7,R1 ; ONLY CHECK FIRST 7 CHARACTERS ; JGD03 10$: CMPB #'A,(R0) ; LOOK FOR ERROR MESSAGE ; JGD03 BEQ 200$ ; YES , GO LOOK FOR MORE ; JGD03 CMPB #'@,(R0)+ ; HAVE WE GOT AN '@' ? ; JGD03 BEQ 20$ ; YES, CHECK SOME MORE ; JGD03 SOB R1,10$ ; LOOP UNTIL R1=0 ; JGD03 BR 100$ ; IF NEVER FIND AN '@' GIVE UP ; JGD03 20$: CMPB (R0)+,#40 ; IS IT A SPACE ; JGD03 BNE 100$ ; NO, NO GOOD ; JGD03 CMPB (R0)+,#'< ; IS IT A '<'? ; JGD03 BNE 100$ ; NO, NO GOOD ; JGD03 CMPB (R0)+,#'E ; IS IT AN 'E'? ; JGD03 BNE 100$ ; NO NO GOOD ; JGD03 CMPB #'O,(R0)+ ; IS IT AN 'O' ; JGD03 BNE 100$ ; NO, NO GOOD ; JGD03 CMPB #'F,(R0)+ ; IS IT AN 'F' ; JGD03 BNE 100$ ; NO, NO GOOD ; JGD03 CMPB #'>,(R0) ; IS IT AN '>' ; JGD03 BNE 100$ ; NO , NO GOOD, BUT CLOSE ; JGD03 INC EOFFLG ; SET EOFFLG ; JGD03 100$: POP R1 ;RESTORE R1 ; JGD03 POP R0 ;RESTORE R0 ; JGD03 RETURN ; ; JGD03 200$: TSTB (R0)+ ; INCREMENT POINTER ; JGD03 CMPB (R0)+,#'T ; IS IT A 'T'? ; JGD03 BNE 100$ ; NO, RETURN ; JGD03 CMPB (R0)+,#'. ; IS IT AN ERROR MESSAGE ; JGD03 BNE 100$ ; NO, SO RETURN ; JGD03 CMPB (R0)+,#40 ; IS IT A BLANK ; JGD03 BNE 100$ ; NO, JUST RETURN ; JGD03 CMPB (R0)+,#'- ; IS IT A '-' ; JGD03 BNE 100$ ; NO JUST RETURN ; JGD03 CMPB (R0)+,#'- ; IS IS A SECOND '-' ; JGD03 BNE 100$ ; NO, JUST RETURN ; JGD03 INC EOFFLG ; ELSE INCREMENT EOFFLG, AND RETURN ; JGD03 BR 100$ ; AND RETURN ; JGD03 ;+ ; **-SBMCMD ; ; THIS ROUTINE FIRST ISSUES THE PREPARED COMMANDLINE ; TO VT1: (EITHER HELLO OR BYE) AND READS THE ; MCR OUTPUTS AND PUTS IT IN THE LOG FILE ; AS LOGN AS THE MCR PROMPT ">" APPEARS IN THE ; LOG BUFFER. ; ; IF INPUT IS ON ALTERNATE ENTRY, THEN THE FIRST OCCURENCE OF ; THE MCR PROMT IS IGNORED. ; ; INPUTS: ; ; R0=ADDRESS OF LOG FDB ; DPB'S=PREPARED TO ISSUE COMMAND ; LOGFILE ALREADY OPEN ; ; OUTPUTS: ; ; R0=UNCHANGED ; REQUESTED PROCEDURE DONE (HEL, BYE) ; DIRECT JUMP TO FILERR IF FILE ERROR ; ;- .ENABLE LSB SBMCM1: INC PRMTSW ; MARK IGNORE ON FIRST PROMT**TEST SBMCMD: DIR$ #VT1WRT ; ISSUE COMMAND SET UP 10$: DIR$ #VT1RD ; READ MCR OUTPUT TST PRMTSW ; IGNORE PROMT IN FIRST LINE? BNE 20$ ; IF NE YES, IGNORE ">" CMPB LOGBUF+3,#'> ; IS IT MCR PROMT? BEQ 30$ ; IF EQ YES, EXIT ROUTINE 20$: PUT$ R0,#LOGBUF,VTSTAT+2 ; LOG THE MCROUTPUT BCS 40$ ; IF CS FILE ERROR MOV VTSTAT+2,R5 ; GET NUMBER OF CHARACTERS READ ADD #LOGBUF,R5 ; POINT BEHIND LAST BYTE CMPB -1(R5),#'> ; IS IT MCR PROMPT? BNE 10$ ; IF NE, NO, SO CONTINUE INC PRMTSW ; INCREMENT THE PROMPT SWITCH ; JGD02 CMP #2,PRMTSW ; IS THIS THE SECOND PROMPT FROM BYE ; JGD02 BEQ 30$ ; YES, RETURN ; JGD02 CMP VTSTAT+2,#4 ; JUST > ONLY? BEQ 10$ ; IF EQ YES, IGNORE PROMT 30$: ; REFERENCE LABLE ; JGD03 TST EOFFLG ; IS THIS A BYE COMMAND READ ; JGD03 BEQ 35$ ; IF EQ 0, NO, JUST RETURN ; JGD03 DIR$ #VT1RD ; YES, READ ONCE AGAIN ; JGD03 35$: RETURN ; SO GO RETURN TO CALLER 40$: TST (SP)+ ; FILE I/O ERROR, REMOVE ARG FROM STACK JMP FILERR ; AND LEAVE ROUTINE DIRECTLY .DSABL LSB ;+ ; **-MKAST1 ; ; THIS AST SERVICE ROUTINE IS NECESSARY TO COVER THE PROBLEMS, WHEN ; ISSUING A BYE COMMAND. IF THE SUBMIT REQUEST SPECIFIED AN ; ACCOUNT WHICH DOESN'T EXIST, THE CODE FOR THE BYE COMMAND ; (SBMCM1) CANNOT DETECT THE "MCR -- NOT LOGGED IN" ERROR ; MESSAGE. THIS ( AND SOME OTHER PROBLEMS) ARE MAINLY CAUSED ; BY THE FACT, THAT MCR ISSUES THE PROMT (>) IN VERY DIFFERENT WAYS. ; THIS IS A BIT INCOSISTENT AND SHOULD BE ADDRESSED TO FUTURE ; RELEASES. ; ;- MKAST1: TST (SP)+ ; REMOVE EVENTFLAG FROM STACK MOV #RESUM,2(SP) ; MODIFY RETURN ADDDRESS QIOW$C IO.KIL,5,5 ; KILL THE READ PENDING ON VT1 ASTX$S ; AND LEAVE AST ROUTINE ;>>>> THIS ROUTINE IS NOT CURRENTLY USED, IT IS LEFT AS AN EXAMPLE OF HOW TO ; JGD03 ; USE AN AST SERVICE ROUTINE TO BREAK INTO A QIOW FOR WHICH THE WAIT IS NEVER ; JGD03 ; SATISFIED. THE AST RETURNS TO THE QIO WHICH IS COMPLETED BECAUSE THE EVENT ; JGD03 ; SPECIFIED IN THE MARKTIME IS SET. ; JGD03 ;+ ; **-MRKAST ; ; AST SERVICE ROUTINE FOR MARK TIME ASTS ; SIMPLY SETS THE TIMEOUT INDICATOR ; EVENTFLAG IMPLICITLY SET AS WELL. ; ;- ;>>>> MRKAST: TST (SP)+ ; REMOVE EVENT FLAG FROM STACK INC TIMOUT ; SET TIMEOUT INDICATOR ASTX$S ; EXIT AST ROUTINE ;+ ; **-FILERR ; **-ATTERR ; ; SOME SORT OF INTELLIGENT ERROR HANDLING SHOULD ; BE DONE THERE, HOWEVER: ; ENTRY AT FILERR >> PRINT ERROR AND START OVER ; ENTRY AT ATTERR >> PRINT ERROR AND EXIT ( NO VT AVAILABLE) ; ;- FILERR: MOV F.ERR(R0),LOGBUF ; PRESERV FILE SYSTEM ERROR CLOSE$ R0 ; CLOSE THE LOG FILE MOV #MSG2+31.,R0 ; ADDR OF WHERE ERROR CODE GOES ; JGD01 MOV LOGBUF,R1 ; ERROR CODE ; JGD01 BIS #177400,R1 ; TURN ON HIGH ORDER BITS(TO CONVERT CORRECTLY) ; JGD01 CLR R2 ; SUPRESS LEADING ZEROS ; JGD01 CALL $CBDSG ; CONVERT BINARY ERROR CODE TO SIGNED DECIMAL ; JGD01 PMSG MSG2 ; PRINT THE ERROR MESSAGE ; JGD01 PMSG DEV ; PRINT OUT DEVICE ; JGD01 PMSG UIC ; AND UIC ; JGD01 JMP $SBCFL ; START OVER AGAIN ATTERR: ; REFERENCE LABEL PMSG MSG3 ; PRINT ERROR MESSAGE EXIT$S ; AND LEAVE PROGRAM ;+ ; JGD01 ; CHECK LOG BIT TO SEE IF VT LOGGED ON ALRIGHT ; JGD01 ; CC - SET IF FAILED ; JGD01 ; CC - CLEAR IF SUCCESS ; JGD01 ;- ; JGD01 .DSABLE LSB .ENABLE LSB CKLOG: ; REF LABLE ; JGD03 CLR LOGCNT ; RESET THE LOGON TRIES ; JGD03 10$: MRKT$C 5,1,2 ; MARK TIME FOR 1 SECOND ; JGD01 GLUN$C 4,LUNINF ; READ LUN INFO FOR VT0: ; JGD01 BIT #U2.LOG,LUNINF+6 ; IS VT: LOGGED ON YET ; JGD01 BEQ 100$ ; IF EQ, YES, SO EXIT WITH CARRY CLEAR ; JGD01 INC LOGCNT ; INCREMENT THE NUMBER OF TIMES TRIED TO LOGON ; JGD01 CMP #4,LOGCNT ; ARE WE AT 3 YET ; JGD01 BEQ 75$ ; YES, GO SET CARRY AND EXIT ; JGD01 BR 10$ ; AND TRY AGAIN ; JGD01 75$: SEC ; SET CARRY ; JGD01 100$: RETURN ; ALL DONE ; JGD01 .END $SBCFL