*DECK FFSIINI 
USETEXT TEXTFFS 
      PROC FFSIINI; 
*CALL COPYRITE
# TITLE FFSIINI - INITIALIZE NETWORK INTERFACE.                        #
  
      BEGIN                            # FFSIINI                       #
# 
**    FFSIINI  INITIALIZE NETWORK INTERFACE.
* 
*     A. LIM                           88/01/15 
* 
*     THIS PROCEDURE CONNECTS THE FILE SERVER TO THE NETWORK AND
*     INITIALIZES ALL NETWORK INTERFACES. 
* 
*     PROC FFSIINI
* 
*     ENTRY    FSMC     = MAXIMUM MESSAGE COUNT FOR TRACE FILE. 
*              NET$INIT = FALSE (NETON INCOMPLETE). 
* 
*     EXIT     PTR$ADDR[PZDN] = ADDRESS OF *ZZZZZDN* FET. 
*              NET$INIT       = TRUE (NETON COMPLETE).
* 
*     METHOD   CALL NETREL TO INITIALIZE THE *ZZZZZDN* FILE 
*              AND SAVE THE FET ADDRESS TO BE USED FOR REPRIEVE 
*              PROCESSING.
* 
*              ATTEMPT TO *NETON* AND DAYFILE THE RESULT. 
* 
*              IF SUCCESSFUL THEN UNCONDITIONALLY TURN TRACING ON.
*              IF UNSUCCESSFUL, THEN DAYFILE A MESSAGE AND STOP 
*              FTPS EXECUTION.
* 
# 
  
# 
****  PROC FFSIINI - XREF LIST
# 
      XREF
        BEGIN 
        PROC MESSAGE;    # DISPLAY AND DAYFILE A MESSAGE               #
        PROC NETDBG;     # CHANGE DEBUG LOGGING OPTION                 #
        PROC NETFUNC;    # INITIATE SPECIAL AIP FUNCTIONS              #
        PROC NETON;      # CONNECT APPLICATION TO NETWORK              #
        PROC NETREL;     # PROCESS NETWORK DEBUG LOG FILE              #
        PROC NETSETF;    # SET UP DEBUG LOG FILE FLUSHING              #
        PROC RECALL;     # PLACE JOB IN RECALL                         #
        PROC WAIT;       # RELINQUISH CPU                              #
        END 
# 
****
# 
      STATUS NETONST                   # NETON STATUS LIST             #
        SUCCESS,                       # NETON SUCCESSFUL              #
        UNAVAIL,                       # NAM UNAVAILABLE               #
        DUPLICATE,                     # DUPLICATE NETON ATTEMPT       #
        DISABLED;                      # APPLICATION DISABLED          #
  
      ITEM ANAME         C(7);         # APPLICATION NAME              #
      ITEM DNFETADR      I;            # FET ADDRESS OF *ZZZZZDN* FILE #
      ITEM NSTAT         S:NETONST;    # STATUS RETURNED FROM *NETON*  #
      ITEM NDSTAT        I;            # STATUS RETURNED FROM *NETDBG* #
      CONTROL EJECT;
  
#     THIS ARRAY DEFINES THE LFN FOR THE *ZZZZZDN* FILE.               #
  
      ARRAY NRLLFN [00:00] S(1);
        BEGIN 
        ITEM NRL$NAME    C(00,00,07) = [L1FN$]; 
        ITEM NRL$ZBYTE   U(00,42,18) = [0]; 
        END 
  
#     THIS ARRAY DEFINES THE MESSAGE FOR ATTEMPTING NETON.             #
  
      ARRAY TRYMSG [00:00] S(3);
        BEGIN 
        ITEM TRY$TEXT    C(00,00,23) = [" FTPS-ATTEMPTING NETON."]; 
        ITEM TRY$ID      C(00,06,04); 
        ITEM TRY$ZBYTE   U(02,18,42) = [0]; 
        END 
  
#     THIS ARRAY DEFINES THE MESSAGE FOR FTPS BEING DISABLED.          #
  
      ARRAY DISMSG [00:00] S(2);
        BEGIN 
        ITEM DIS$TEXT    C(00,00,15) = [" FTPS-DISABLED."]; 
        ITEM DIS$ID      C(00,06,04); 
        ITEM DIS$ZBYTE   U(01,30,30) = [0]; 
        END 
  
#     THIS ARRAY DEFINES THE MESSAGE FOR A SUCCESSFUL NETON.           #
  
      ARRAY OKMSG [00:00] S(3); 
        BEGIN 
        ITEM OK$TEXT     C(00,00,23) = [" FTPS-NETON SUCCESSFUL."]; 
        ITEM OK$ID       C(00,06,04); 
        ITEM OK$ZBYTE    U(02,18,42) = [0]; 
        END 
      CONTROL EJECT;
  
#     START MAIN PROCEDURE                                             #
  
      IF FSMC NQ 0
      THEN
        BEGIN                          # MAXIMUM MESSAGE COUNT NOT 0   #
        NETREL (NRLLFN, FALSE, FALSE); # INTITIALIZE *ZZZZZDN* FILE    #
        END;
  
      NETSETF (FALSE, DNFETADR);       # GET *ZZZZZDN* FET ADDRESS     #
      PTR$ADDR[PZDN] = DNFETADR;       # SAVE FOR REPRIEVE PROCESSING  #
  
      MAX$WORD[0]   = 0;               # CLEAR MAXACN WORD             #
      MAX$NUMRCN[0] = NUMRCN$;         # NO OF ORGINIATING CONNECTIONS #
      IF EPTFLAG EQ FTPC$ 
      THEN
        BEGIN                          # CLIENT MODE                   #
        MAX$MAXACN[0] = MAXACNC$;      # MAX C/N = CS+SAP+CTRL+DATA    #
        ANAME         = "FTPI   ";     # NETON AS FTPI                 #
        TRY$ID[0] = FTPI$;             # MESSAGE HEADER = FTPI         #
        DIS$ID[0] = FTPI$;
        OK$ID[0]  = FTPI$;
        END 
      ELSE
        BEGIN                          # SERVER MODE                   #
        MAX$MAXACN[0] = MAXACNS$;      # MAX C/N = SAP+CTRL+DATA       #
        ANAME         = "FTPS   ";     # NETON AS FTPS                 #
        END 
  
      MESSAGE (TRYMSG[0],0);           # DAYFILE ATTEMPTING NETON      #
  
      FOR NSTAT = S"DUPLICATE"
        WHILE    (NSTAT EQ S"DUPLICATE")
              OR (NSTAT EQ S"UNAVAIL")
      DO                               # LOOP IF MAX COPIES REACHED,   #
        BEGIN                          # OR NAM IS NOT AVAILABLE       #
        NETON (ANAME, NSUP, NSTAT,
               MINACN$, MAXACN);       # ATTEMPT TO CONNECT TO NETWORK #
  
        IF    (NSTAT EQ S"DUPLICATE") 
           OR (NSTAT EQ S"UNAVAIL") 
        THEN
          BEGIN 
          WAIT (2000);                 # RELINQUISH THE CPU            #
          END 
        END;
  
      IF NSTAT EQ S"DISABLED" 
      THEN
        BEGIN                          # FILE SERVER DISABLED          #
        MESSAGE (DISMSG[0],0);         # DAYFILE THE MESSAGE           #
        STOP;                          # END OF STORY                  #
        END;
  
      MESSAGE (OKMSG[0],0);            # DAYFILE NETON SUCCESSFUL      #
      NETDBG (FALSE, FALSE, NDSTAT);   # TURN AIP TRACING ON           #
      NET$INIT = TRUE;                 # SAVE NETON FOR REPRIEVE PROC  #
  
      NETFUNC(1,1);                    # FTPS WANTS TO BE SWAPPED OUT..#
                                       #..WHEN IT ISSUES A NETWAIT.    #
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFSIINI                       #
  
      TERM
