*DECK FCSFLIS 
USETEXT TEXTFCS;
      FUNC FCSFLIS B; 
*CALL COPYRITE
# TITLE FCSFLIS - PROCESS FTP LOGIN SEQUENCE.                          #
  
      BEGIN                            # FCSFLIS                       #
  
# 
**    FCSFLIS - PROCESS FTP LOGIN SEQUENCE. 
* 
*     C. J. RAMSAY                     87/11/03 
* 
*     THIS PROCEDURE PROCESSES AN FTP LOGIN SEQUENCE. 
* 
*     FUNC FCSFLIS
* 
*     ENTRY   PARMS[1]   = USER NAME. 
*             PARMS[2]   = PASSWORD.
*             PARMS[3]   = FAMILY.
*             PARMS[4]   = ACCOUNT. 
*             PARMS[5]   = PROJECT. 
*             FTPINPUT   = FTP INPUT FILE NAME. 
*             MBIX       = MBT ENTRY INDEX FOR INPUT FILE.
* 
*     EXIT    FCSFLIS    = TRUE IF COMMAND SEQUENCE COMPLETED OK. 
*             FCSFLIS    = FALSE IF COMMAND SEQUENCE NOT COMPLETED OK.
*             FTPERROR   = TRUE IF PROTOCOL ERROR DETECTED. 
*             FTPFAIL    = TRUE IF COMMAND FAILURE DETECTED.
* 
*     NOTES   ANY PARAMETERS THAT ARE REQUIRED BUT NOT SPECIFIED
*             ARE READ IN FROM THE CURRENT INPUT FILE.
* 
*     METHOD  SEND *USER* COMMAND WITH PARAMETERS TO REMOTE HOST. 
*             WAIT FOR REPLY FROM REMOTE HOST.
*             IF REQUIRED THEN SEND *PASS* COMMAND WITH PASSWORD AND
*               FAMILY PARAMETERS TO REMOTE HOST. 
*               WAIT FOR REPLY FROM REMOTE HOST.
*             IF REQUIRED THEN SEND *ACCT* COMMAND WITH ACCOUNT AND 
*               PROJECT PARAMETERS TO REMOTE HOST.
*               WAIT FOR REPLY FROM REMOTE HOST.
* 
# 
  
# 
****  FUNC FCSFLIS - XREF LIST
# 
      XREF
        BEGIN 
        PROC FCSNODB;                  # OUTPUT DATA BLOCK             #
        PROC FCSNWFR;                  # WAIT FOR FTP REPLY            #
        PROC FCSOFTO;                  # FLUSH TERMINAL OUTPUT         #
        PROC FCSOWOF;                  # WRITE TO OUTPUT FILE          #
        PROC FCSRRFF;                  # READ FROM FILE                #
        PROC FCSROPM;                  # OVERWRITE PROMPT MESSAGE      #
        PROC FCSRSPM;                  # SEND PROMPT MESSAGE           #
        PROC FCSUCRE;                  # COPY FTP REPLY TO ERROR BUFFER#
        PROC MESSAGE;                  # DISPLAY / DAYFILE A MESSAGE   #
        PROC NETUCAC;                  # COPY AN ASCII CHARACTER       #
        PROC NETUCAS;                  # COPY AN ASCII STRING          #
        END 
# 
****
# 
      ITEM COMPLETE      B;            # USER INPUT COMPLETE FLAG      #
      ITEM DIND          I;            # DESTINATION INDEX             #
      ITEM RESULT        I;            # RESULT FROM *READC* MACRO     #
      ITEM COMMA         U = X"2C0000000000000";
      ITEM SPACE         U = X"200000000000000";
  
      ARRAY RETMSG[00:00] S(5); 
        BEGIN 
        ITEM RLI$TEXT    C(00,00,47) =
       ["--WARNING--  STRING MUST BE 1 TO 60 CHARACTERS."]; 
        ITEM RLI$ZBYTE   U(04,42,18) = [0]; 
        END 
  
      ARRAY BEGLIS [00:00] S(4);
        BEGIN 
        ITEM  BLI$TEXT   C(00,00,31) =
       [" FTP PROCESSING LOGIN SEQUENCE."]; 
        ITEM  BLI$ZBYTE  U(03,06,54) = [0]; 
        END 
  
      ARRAY ENDLIS [00:00] S(3);
        BEGIN 
        ITEM  ELI$TEXT   C(00,00,20) =
       [" FTP LOGIN COMPLETE."];
        ITEM  ELI$ZBYTE  U(02,00,60) = [0]; 
        END 
      CONTROL EJECT;
# 
*     INTERNAL PROCEDURE - FCS2RLI
* 
*     THIS INTERNAL PROCEDURE PROMPTS THE USER FOR LOGIN INFORMATION, 
*     READS THE INPUT, AND RETURNS IT IN THE SPECIFIED PARAMETER BLOCK. 
# 
      PROC FCS2RLI (PROMPT, LPARM); 
      BEGIN                            # FCS2RLI                       #
  
      ITEM PROMPT        I;            # PROMPT MESSAGE TO WRITE       #
  
      ARRAY LPARM [00:00] S(PARSIZ$);  # LOCAL PARAMETER BLOCK         #
        BEGIN 
        ITEM LPARP       U(00,00,60);  # FIRST WORD REFERENCE          #
        ITEM LPARS       U(S$,00,60);  # PARAMETER LENGTH IN OCTETS    #
        END 
# 
*     PROMPT, READ AND VALIDATE USER INPUT UNTIL VALIDATION SUCCESSFUL
*     OR EOR/EOF/EOI IS REACHED ON AN INPUT FILE NOT ASSIGNED TO THE
*     TERMINAL. 
# 
      COMPLETE = FALSE;                # USER INPUT NOT COMPLETE       #
      FOR INPLEN = 0
        WHILE NOT COMPLETE DO 
        BEGIN                          # LOOP TILL USER INPUT COMPLETE #
        COMPLETE = TRUE;               # ASSUME USER INPUT COMPLETE    #
        FCSRSPM (PROMPT, MBIX);        # SEND PROMPT MESSAGE           #
        IF FTPINPUT NQ "0"
        THEN
          BEGIN                        # INPUT FILE EXISTS             #
          FCSRRFF (MBIX, RESULT);      # READ FROM INPUT FILE          #
          FCSROPM (PROMPT, MBIX);      # OVERWRITE PASSWORD VALUE      #
          IF (INPLEN GR PARMAX$) OR 
             ((INPLEN EQ 0) AND (RESULT EQ 0 OR MBT$DT[MBIX] EQ "TT"))
          THEN
            BEGIN                      # NULL INPUT OR TOO MANY CHARS  #
            FCSOWOF (RETMSG[0], 
                     INTERNAL$);       # WRITE MESSAGE TO OUTPUT FILE  #
            FCSOFTO;                   # FLUSH TERMINAL OUTPUT         #
            COMPLETE = FALSE;          # PROMPT USER AGAIN             #
            END 
          END 
        END 
# 
*     COPY USER INPUT TO SPECIFIED PARAMETER BLOCK. 
# 
      DIND = 0;                        # INITIALIZE PARAMETER LENGTH   #
      NETUCAS (INPBUF, 0, INPLEN, 
               LPARM, DIND);           # COPY TO PARAMETER BLOCK       #
      LPARS = INPLEN;                  # LENGTH OF INPUT PARAMETER     #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCS2RLI                       #
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      MESSAGE (BEGLIS[0], 1);          # DISPLAY START MESSAGE         #
      FCSFLIS = TRUE;                  # DEFAULT TO SEQUENCE OKAY      #
# 
*     IF USER NAME IS NOT SPECIFIED THEN READ USER NAME FROM INPUT FILE.
*     SEND *USER* COMMAND WITH PARAMETERS TO REMOTE HOST AND WAIT FOR A 
*     REPLY.
# 
      IF PARAMSZ[1] EQ 0
      THEN
        BEGIN                          # USER NAME NOT SPECIFIED       #
        FCS2RLI (PRUSER, PARMS[1]);    # READ USER NAME FROM INPUT FILE#
        END 
  
      OUTLEN = AIPIHDR$;               # INITIALIZE OUTPUT LENGTH      #
      NETUCAS (FTPCUSER, 0, 4,
               OUTBUF, OUTLEN);        # COPY *USER* COMMAND           #
      NETUCAC (SPACE, 0,
               OUTBUF, OUTLEN);        # COPY ASCII SPACE              #
      NETUCAS (PARMS[1], 0, PARAMSZ[1], 
               OUTBUF, OUTLEN);        # COPY USER NAME                #
      FCSNODB (AIPISC, REMOTEID);      # SEND TO REMOTE HOST           #
      FCSNWFR (REMOTEID);              # WAIT FOR FTP REPLY            #
      IF (FTPRPYC1 EQ 1)
      THEN
        BEGIN                          # PROTOCOL ERROR DETECTED       #
        FTPERROR = TRUE;               # SET FTP ERROR FLAG            #
        END 
      IF (FTPRPYC1 EQ 4) OR 
         (FTPRPYC1 EQ 5)
      THEN
        BEGIN                          # COMMAND FAILURE DETECTED      #
        FTPFAIL = TRUE;                # SET FTP FAILURE FLAG          #
        END 
# 
*     IF REPLY CODE INDICATES THAT PASSWORD IS REQUIRED THEN PROCESS: 
*     IF PASSWORD IS NOT SPECIFIED THEN READ PASSWORD FROM INPUT FILE.
*     SEND *PASS* COMMAND WITH PARAMETERS TO REMOTE HOST AND WAIT FOR A 
*     REPLY.
# 
      IF FTPREPLY EQ 331
      THEN
        BEGIN                          # PASSWORD REQUIRED             #
        IF PARAMSZ[2] EQ 0
        THEN
          BEGIN                        # PASSWORD NOT SPECIFIED        #
          FCS2RLI (PRPASS, PARMS[2]);  # READ PASSWORD FROM INPUT FILE #
          END 
  
        OUTLEN = AIPIHDR$;             # INITIALIZE OUTPUT LENGTH      #
        NETUCAS (FTPCPASS, 0, 4,
                 OUTBUF, OUTLEN);      # COPY *PASS* COMMAND           #
        NETUCAC (SPACE, 0,
                 OUTBUF, OUTLEN);      # COPY ASCII SPACE              #
        NETUCAS (PARMS[2], 0, PARAMSZ[2], 
                 OUTBUF, OUTLEN);      # COPY PASSWORD                 #
        IF PARAMSZ[3] NQ 0
        THEN
          BEGIN                        # FAMILY PARAMETER SPECIFIED    #
          NETUCAC (COMMA, 0,
                   OUTBUF, OUTLEN);    # COPY ASCII COMMA              #
          NETUCAS (PARMS[3], 0, PARAMSZ[3], 
                   OUTBUF, OUTLEN);    # COPY FAMILY                   #
          END 
        FCSNODB (AIPISC, REMOTEID);    # SEND TO REMOTE HOST           #
        FCSNWFR (REMOTEID);            # WAIT FOR FTP REPLY            #
        IF (FTPRPYC1 EQ 1)
        THEN
          BEGIN                        # PROTOCOL ERROR DETECTED       #
          FTPERROR = TRUE;             # SET FTP ERROR FLAG            #
          END 
        IF (FTPRPYC1 EQ 4) OR 
           (FTPRPYC1 EQ 5)
        THEN
          BEGIN                        # COMMAND FAILURE DETECTED      #
          FTPFAIL = TRUE;              # SET FTP FAILURE FLAG          #
          END 
        END 
# 
*     IF REPLY CODE INDICATES THAT ACCOUNT IS REQUIRED THEN PROCESS:  
*     IF ACCOUNT IS NOT SPECIFIED THEN READ ACCOUNT FROM INPUT FILE.
*     SEND *ACCT* COMMAND WITH PARAMETERS TO REMOTE HOST AND WAIT FOR A 
*     REPLY.
# 
      IF FTPREPLY EQ 332
      THEN
        BEGIN                          # ACCOUNT REQUIRED              #
        IF PARAMSZ[4] EQ 0
        THEN
          BEGIN                        # ACCOUNT NOT SPECIFIED         #
          FCS2RLI (PRACCT, PARMS[4]);  # READ ACCOUNT FROM INPUT FILE  #
          END 
  
        OUTLEN = AIPIHDR$;             # INITIALIZE OUTPUT LENGTH      #
        NETUCAS (FTPCACCT, 0, 4,
                 OUTBUF, OUTLEN);      # COPY *ACCT* COMMAND           #
        NETUCAC (SPACE, 0,
                 OUTBUF, OUTLEN);      # COPY ASCII SPACE              #
        NETUCAS (PARMS[4], 0, PARAMSZ[4], 
                 OUTBUF, OUTLEN);      # COPY ACCOUNT                  #
        IF PARAMSZ[5] NQ 0
        THEN
          BEGIN                        # PROJECT PARAMETER SPECIFIED   #
          NETUCAC (COMMA, 0,
                   OUTBUF, OUTLEN);    # COPY ASCII COMMA              #
          NETUCAS (PARMS[5], 0, PARAMSZ[5], 
                   OUTBUF, OUTLEN);    # COPY PROJECT                  #
          END 
        FCSNODB (AIPISC, REMOTEID);    # SEND TO REMOTE HOST           #
        FCSNWFR (REMOTEID);            # WAIT FOR FTP REPLY            #
        IF (FTPRPYC1 EQ 1) OR 
           (FTPRPYC1 EQ 3)
        THEN
          BEGIN                        # PROTOCOL ERROR DETECTED       #
          FTPERROR = TRUE;             # SET FTP ERROR FLAG            #
          END 
        IF (FTPRPYC1 EQ 4) OR 
           (FTPRPYC1 EQ 5)
        THEN
          BEGIN                        # COMMAND FAILURE DETECTED      #
          FTPFAIL = TRUE;              # SET FTP FAILURE FLAG          #
          END 
        END 
# 
*     PROCESS ANY ERROR CONDITIONS. 
# 
      MESSAGE (ENDLIS[0], 1);          # DISPLAY COMPLETE MESSAGE      #
  
      IF (FTPERROR OR FTPFAIL)
      THEN
        BEGIN                          # SEQUENCE DID NOT COMPLETE OK  #
        FCSUCRE;                       # COPY FTP REPLY TO ERROR BUFFER#
        FCSFLIS = FALSE;               # RETURN FALSE TO CALLER        #
        END 
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCSFLIS                       #
  
      TERM
