*DECK FCSFSCS 
USETEXT TEXTFCS;
      FUNC FCSFSCS (FTPCMD1, FTPPAR1, ID) B;
*CALL COPYRITE
# TITLE FCSFSCS - PROCESS FTP SINGLE COMMAND SEQUENCE.                 #
  
      BEGIN                            # FCSFSCS                       #
  
# 
**    FCSFSCS - PROCESS FTP SINGLE COMMAND SEQUENCE.
* 
*     C. J. RAMSAY                     87/11/03 
* 
*     THIS PROCEDURE PROCESSES AN FTP SINGLE COMMAND SEQUENCE.
* 
*     FUNC FCSFSCS (FTPCMD1, FTPPAR1, ID) 
* 
*     ENTRY   FTPCMD1    = FTP COMMAND TO SEND. 
*             FTPPAR1    = PARAMETER BLOCK ASSOCIATED WITH COMMAND. 
*             ID         = CONNECTION IDENTIFIER OF HOST. 
* 
*     EXIT    FCSFSCS    = TRUE IF COMMAND SEQUENCE COMPLETED OK. 
*             FCSFSCS    = FALSE IF COMMAND SEQUENCE NOT COMPLETED OK.
*             FTPERROR   = TRUE IF PROTOCOL ERROR DETECTED. 
*             FTPFAIL    = TRUE IF COMMAND FAILURE DETECTED.
* 
*     NOTES   THIS PROCEDURE IS USED TO FTP COMMANDS THAT CONFORM TO
*             THE FOLLOWING MODEL.
*                                                1,3     +-------+
*                                         -------------->! ERROR !
*                                        !               +-------+
*                                        !
*             +-------+    CMD     +-------+      2      +-------+
*             ! BEGIN !----------->!  WAIT !------------>!SUCCESS!
*             +-------+            +-------+             +-------+
*                                        !
*                                        !       4,5     +-------+
*                                         -------------->!FAILURE!
*                                                        +-------+
* 
*     METHOD  SEND FTP COMMAND WITH PARAMETERS TO SPECIFIED HOST. 
*             WAIT FOR RESPONSE FROM SPECIFIED HOST.
* 
# 
  
# 
****  FUNC FCSFSCS - XREF LIST
# 
      XREF
        BEGIN 
        PROC FCSNODB;                  # OUTPUT DATA BLOCK             #
        PROC FCSNWFR;                  # WAIT FOR FTP REPLY            #
        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 
# 
****
# 
      ARRAY FTPCMD1 [00:00] S(1); 
        BEGIN                          # FTP COMMAND                   #
        ITEM CMDC1       U(00,00,60);  # FIRST WORD REFERENCE          #
        ITEM CMDL1       U(00,52,08);  # COMMAND LENGTH IN OCTETS      #
        END 
      ARRAY FTPPAR1 [00:00] S(PARSIZ$); 
        BEGIN                          # PARAMETERS WITH FTP COMMAND   #
        ITEM PARP1       U(00,00,60);  # FIRST WORD REFERENCE          #
        ITEM PARS1       U(S$,00,60);  # PARAMETER LENGTH IN OCTETS    #
        END 
      ITEM ID            I;            # CONNECTION IDENTIFIER         #
  
      ITEM SPACE         U = X"200000000000000";
  
      ARRAY BEGSCS [00:00] S(4);
        BEGIN 
        ITEM  BSC$TEXT   C(00,00,33) =
       [" FTP PROCESSING COMMAND SEQUENCE."]; 
        ITEM  BSC$ZBYTE  U(03,18,42) = [0]; 
        END 
  
      ARRAY ENDSCS [00:00] S(4);
        BEGIN 
        ITEM  ESC$TEXT   C(00,00,31) =
       [" FTP COMMAND SEQUENCE COMPLETE."]; 
        ITEM  ESC$ZBYTE  U(03,06,54) = [0]; 
        END 
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      MESSAGE (BEGSCS[0], 1);          # DISPLAY START MESSAGE         #
      FCSFSCS = TRUE;                  # DEFAULT TO SEQUENCE OKAY      #
# 
*    SEND FTP COMMAND TO SPECIFIED HOST.
# 
      OUTLEN = AIPIHDR$;               # INITIALIZE OUTPUT LENGTH      #
      NETUCAS (FTPCMD1[0], 0, CMDL1[0], 
               OUTBUF, OUTLEN);        # COPY FTP COMMAND              #
      IF PARS1[0] NQ 0
      THEN
        BEGIN                          # PARAMETERS WITH FTP COMMAND   #
        NETUCAC (SPACE, 0,
                 OUTBUF, OUTLEN);      # COPY ASCII SPACE              #
        NETUCAS (FTPPAR1[0], 0, PARS1[0], 
                 OUTBUF, OUTLEN);      # COPY THE PARAMETERS           #
        END 
      FCSNODB (AIPISC, ID);            # SEND TO SPECIFIED HOST        #
      FCSNWFR (ID);                    # WAIT FOR RESPONSE             #
# 
*     PROCESS RESPONSE TO FTP COMMAND FROM SPECIFIED HOST.
# 
      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 
# 
*     PROCESS ANY ERROR CONDITIONS. 
# 
      MESSAGE (ENDSCS[0], 1);          # DISPLAY COMPLETE MESSAGE      #
  
      IF (FTPERROR OR FTPFAIL)
      THEN
        BEGIN                          # SEQUENCE DID NOT COMPLETE OK  #
        FCSUCRE;                       # COPY FTP REPLY TO ERROR BUFFER#
        FCSFSCS = FALSE;               # RETURN FALSE TO CALLER        #
        END 
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FCSFSCS                       #
  
      TERM
