*DECK FFSIP 
USETEXT TEXTFFS 
      PROC FFSIP; 
*CALL COPYRITE
# TITLE FFSIP - FILE SERVER INITIALIZATION PROCESSOR                   #
  
      BEGIN                            # FFSIP                         #
# 
**    FFSIP  FILE SERVER INITIALIZATION PROCESSOR 
* 
*     A. LIM                           88/01/15 
* 
*     THIS PROCEDURE FORMS THE INITIALIZATION OVERLAY FOR THE FILE
*     SERVER FACILITY. ITS PURPOSE IS TO PERFORM ALL THE TASKS THAT 
*     MUST BE DONE BEFORE STARTING NORMAL FILE SERVER OPERATION.
* 
*     PROC FFSIP
* 
*     ENTRY    NONE 
* 
*     EXIT     THERE IS NO EXIT IN THE NORMAL SENSE.
*              IF INITIALIZATION COMPLETES SUCCESSFULLY THEN THIS 
*              PROGRAM TRANSFERS CONTROL TO THE EXECUTIVE PROCESSOR 
*              (*FFSXPES*) WHICH NEVER RETURNS. 
*              IF INITIALIZATION DOES NOT COMPLETE SUCCESSFULLY THEN
*              THE FILE SERVER IS ABORTED.
* 
*     METHOD   INITIALIZE THE POINTER TABLE.
*              VALIDATE THE FILE SERVER CONTROL CARD. 
*              INITIALIZE MANAGED BUFFER TABLE *MBT*. 
*              INITIALIZE MANAGED TABLES SPACE. 
*              INITIALIZE PROGRAM VARIABLES.
*              CONNECT FILE SERVER TO THE NETWORK.
*              READ TCP HOST FILE.
*              TRANSFER CONTROL TO THE FILE SERVER EXECUTIVE PROCESSOR. 
* 
# 
  
# 
****  PROC FFSIP - XREF LIST
# 
      XREF
        BEGIN 
        PROC FFSEEFS;    # END FILE SERVER WITH A DAYFILE MESSAGE      #
        PROC FFSIBCT;    # BUILD COMMAND TABLE                         #
        PROC FFSICCC;    # CRACK CONTROL CARD                          #
        PROC FFSIINI;    # INITIALIZE NETWORK INTERFACE                #
        PROC FFSIIPT;    # INITIALIZE POINTER TABLE                    #
        PROC FFSIIMB;    # INITIALIZE MANAGED BUFFER TABLE *MBT*       #
        PROC FFSIIMT;    # INITIALIZE MANAGED TABLES                   #
        PROC FFSIIPV;    # INITIALIZE PROGRAM VARIABLES                #
        FUNC FFSIRHF B;  # READ TCP HOST FILE                          #
        PROC FFSXPES;    # PROGRAM EXECUTION SEQUENCER                 #
        END 
# 
****
# 
      CONTROL EJECT;
      ITEM PROGNAME C(10)="FTPS";      # PROGRAM NAME FOR FFSICCC      #
      ITEM COMMENT  C(80);             # CONTROL CARD COMMENT          #
      DEF NUMPARAMS # 3 #;   # NUMBER OF INPUT PARAMETERS IN PDT$ARRAY #
      DEF NINPARM  # 1 #;              # NETWORK INVOKATION NUMBER PARM#
      DEF MCPARM   # 2 #;              # MESSAGE COUNT PARAMETER       #
      DEF THFPARM  # 3 #;              # TCP HOST FILE USER NAME       #
  
# 
*     PARM$ARRAY - THIS ARRAY WILL CONTAIN VALID VALUES FOR EACH
*     PARAMETER SPECIFIED IN PDT$ARRAY. THE LOCATION OF VALUES IN 
*     THIS ARRAY CORRESPOND TO THE POSITION OF THE PARAMETERS IN
*     PDT$ARRAY.
* 
*     EACH ENTRY CONSISTS OF TWO WORDS. 
*     THE FIRST WORD IS THE VALUE VALUE OF THE PARAMETER. 
*     THE SECOND WORD CONTAINS TWO VALUES.  THE RIGHTMOST THIRTY BITS 
*     ARE A BOOLEAN INDICATING IF THE VALUE IN WORD ONE WAS USER
*     SPECIFIED (TRUE) OR A DEFAULT VALUE (FALSE).  THE LEFTMOST THIRTY 
*     BITS INDICATE WHETHER *VALUE* IS *KEYWORD* OR *KEYWORD=VALUE*.
# 
  
      ARRAY PARM$ARRAY[1:NUMPARAMS] S(2); 
        BEGIN 
        ITEM PARM$IVALUE U(00,00,60); 
        ITEM PARM$CVALUE C(00,00,07); 
        ITEM PARM$NUMARG U(01,00,30); 
        ITEM PARM$USED   B(01,30,30); 
        END 
  
# 
*     TYPE DECLARATIONS FOR PARM$TYPE FIELD IN PDT$ARRAY
# 
  
      DEF TYPE$NULL    # 0 #;          # NULL PARAMETER FIELD          #
      DEF TYPE$FILE    # 1 #;          # FILE TYPE PARAMETER           #
      DEF TYPE$INTEGER # 2 #;          # INTEGER TYPE PARAMETER        #
      DEF TYPE$NAME    # 3 #;          # NAME TYPE PARAMETER           #
      DEF TYPE$USER    # 4 #;          # USER NAME PARAMETER           #
  
# 
*     PDT$ARRAY - THIS ARRAY DEFINES THE ALLOWABLE PARAMETERS FOR THE 
*     CONTROL CARD. DEFAULTS ARE LISTED ALONG WITH THE MAXIMUM LENGTHS
*     OF EACH PARAMETER, WHETHER THE PARAMETER IS *KEYWORD* OR
*     *KEYWORD=VALUE*, THE TYPE OF THE PARAMETER, WHETHER THE 
*     KEYWORD IS REQUIRED OR OPTIONAL AND THE MINIMUM AND MAXIMUM 
*     VALUES ALLOWED (INTEGER TYPE PARAMETERS ONLY).
* 
*     PARM$NAME    - 1 TO 7 CHARACTERS, ZERO FILLED.
*     PARM$MXLEN   - INTEGER VALUE 1 THRU 7 
*     PARM$NARGS   - 1 => KEYWORD ONLY, 2 => KEYWORD=VALUE, 3 => EITHER.
*     PARM$TYPE    - 1 = FILE NAME
*                    2 = INTEGER
*                    3 = KEYWORD NAME 
*                    4 = USER NAME
*     PARM$REQRD   - BOOLEAN, TRUE => KEYWORD REQUIRED, FALSE =>OPTIONAL
*     PARM$DFAULT  - DEFAULT PARAMETER VALUE BINARY REPRESENTATION
*     PARM$MIN     - MINIMUM ALLOWABLE INTEGER VALUE
*     PARM$MAX     - MAXIMUM ALLOWABLE INTEGER VALUE
* 
* 
*     ARRAY PDT$ARRAY[1:NUMPARAMS] S(3) 
*       BEGIN 
*       ITEM PDT$WORD1  U(00,00,60) 
*       ITEM PARM$NAME  C(00,00,07) 
*       ITEM PARM$MXLEN U(00,42,09) 
*       ITEM PARM$NARGS U(00,51,03) 
*       ITEM PARM$TYPE  U(00,54,03) 
*       ITEM PARM$REQRD B(00,57,03) 
*       ITEM PDT$WORD2  U(01,00,60) 
*       ITEM PARM$DFALT U(01,00,60) 
*       ITEM PDT$WORD3  U(02,00,60) 
*       ITEM PARM$MIN   I(02,00,30) 
*       ITEM PARM$MAX   I(02,30,30) 
*       END 
# 
  
      ARRAY PDT$ARRAY[1:NUMPARAMS] S(3);
        BEGIN 
        ITEM PDT$WORD1       U(00,00,60); 
        ITEM PDT$PNAME       U(00,00,42) = [
                                       O"16111600000000",  # NIN       #
                                       O"15030000000000",  # MC        #
                                       O"24032010251600",  # TCPHUN    #
                                       ]; 
        ITEM PDT$MXLEN       U(00,42,09) = [3,7,7]; 
        ITEM PDT$NARGS       U(00,51,03) = [2,2,2]; 
        ITEM PDT$PTYPE       U(00,54,03) = [
                                       TYPE$INTEGER,       # NIN       #
                                       TYPE$INTEGER,       # MC        #
                                       TYPE$USER,          # TCPHUN    #
                                       ]; 
        ITEM PDT$REQRD       B(00,57,03) = [TRUE,FALSE,TRUE]; 
        ITEM PDT$WORD2       U(01,00,60); 
        ITEM PDT$DFAULT      U(01,00,42) =
                                       [0,500,0]; 
        ITEM PDT$FLAG        B(01,42,18) =
                                       [FALSE,FALSE,FALSE]; 
        ITEM PDT$WORD3       U(02,00,60); 
        ITEM PDT$MIN         I(02,00,30) = [
                                       0,                  # NIN       #
                                       0,                  # MC        #
                                       0,                  # TCPHUN    #
                                       ]; 
        ITEM PDT$MAX         I(02,30,30) = [
                                       999,                # NIN       #
                                       9999999,            # MC        #
                                       0,                  # TCPHUN    #
                                       ]; 
        END 
  
  
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
      FFSIIPT;                         # INITIALIZE POINTER TABLE      #
  
                                       # CRACK CONTROL STATEMENT       #
      IF EPTFLAG EQ FTPC$ 
      THEN
        BEGIN                          # CLIENT MODE                   #
        PROGNAME = "FTPI";
        END 
      FFSICCC(PARM$ARRAY,PDT$ARRAY,NUMPARAMS,PROGNAME,COMMENT); 
  
      FSMC     = PARM$IVALUE[MCPARM];  # SAVE MAX MESSAGE COUNT        #
      FSNIN    = PARM$IVALUE[NINPARM]; # SAVE NIN                      #
      FSTHFUN  = 0;                    # ZERO OUT TCP HOST FILE UN WORD#
      FSTHFUNC = PARM$CVALUE[THFPARM]; # 7 CHARACTERS TCP HOST FILE UN #
  
      FFSIBCT;                         # BUILD COMMAND TABLE           #
  
      FFSIIMB;                         # INITIALIZE *MBT*              #
  
      FFSIIMT;                         # INITIALIZE MANAGED TABLES     #
  
      FFSIIPV;                         # INITIALIZE PROGRAM VARIABLES  #
  
      FFSIINI;                         # INITIALIZE NETWORK INTERFACE  #
  
      PAUSE=TRUE;                      # FLASH MESSAGE ON B-DISPLAY IF #
                                       #..HOST FILE NOT FOUND PENDING  #
                                       #..OPERATOR ACTION              #
      IF NOT FFSIRHF
      THEN
        BEGIN                          # HOST NAME NOT FOUND           #
        NOTYETSPAWN = FALSE;           # DO NOT SPAWN ANOTHER COPY     #
        FFSEEFS(NNOIPA);               # ABORT WITH A DAYFILE MESSAGE  #
        END 
  
      PAUSE=FALSE;                     # DONOT FLASH FOR SUBSEQUNT FAIL#
# 
*     SAVE SOURCE IP ADDRESS (IN DISPLAY_CODE) IN 
*     *SIPA* DEFINED IN *TEXTFFS*.
# 
  
      SIPA$DC[0] = PARAMP[IPADC$];
  
# 
*     PLUG INTERNET SOURCE ADDRESS INTO ACN ENTRIES FOR CONTROL & DATA
*     SET ULP TIMEOUT VALUES. 
# 
      P<T$SADR$REC>               = LOC(PARMS[5]);
        P<I$SADR$REC>               = LOC(T$SADR$IPA);
          ACN$SIPFIU[CTYPE"CTCTRL"] = I$SADR$FIU; 
          ACN$SIPFIU[CTYPE"CTDATA"] = I$SADR$FIU; 
          ACN$SIPNET[CTYPE"CTCTRL"] = I$SADR$NET; 
          ACN$SIPNET[CTYPE"CTDATA"] = I$SADR$NET; 
          ACN$SIPHST[CTYPE"CTCTRL"] = I$SADR$HST; 
          ACN$SIPHST[CTYPE"CTDATA"] = I$SADR$HST; 
        ACN$STCPIU[CTYPE"CTCTRL"] = FALSE;
        ACN$STCPIU[CTYPE"CTDATA"] = FALSE;
        ACN$STCPRT[CTYPE"CTCTRL"] = 0;
        ACN$STCPRT[CTYPE"CTDATA"] = 0;
        ACN$PUSH[CTYPE"CTCTRL"]   = TRUE;  # SET PUSH FLAG ON CTRL C/N #
  
      IF EPTFLAG EQ FTPS$ 
      THEN
        BEGIN                          # SERVER - SET CTRL SOURCE PORT #
        ACN$STCPIU[CTYPE"CTCTRL"] = TRUE; 
        ACN$STCPRT[CTYPE"CTCTRL"] = TP$PT$FTPC; # WELL-KNOWN FTP CTRL  #
        END 
      ELSE
        BEGIN                          # CLIENT - SET CTRL DESTN. PORT #
        ACN$DTCPIU[CTYPE"CTCTRL"] = TRUE; 
        ACN$DTCPRT[CTYPE"CTCTRL"] = TP$PT$FTPC; # WELL-KNOWN FTP CTRL  #
        END 
      ACN$TULPTO[CTYPE"CTCTRL"]   = 300;      # 5 MINUTES              #
      ACN$TULPTO[CTYPE"CTDATA"]   = 300;      # 5 MINUTES              #
  
  
      FFSXPES;                         # PROGRAM EXECUTION SEQUENCER   #
  
  
      END                              # FFSIP                         #
  
      TERM
