*DECK FFSIRHF 
USETEXT TEXTFFS 
      FUNC FFSIRHF B; 
*CALL COPYRITE
# TITLE FFSIRHF - READ HOST FILE.                                      #
  
      BEGIN                            # FFSIRHF                       #
  
# 
**    FFSIRHF - READ HOST FILE. 
* 
*     A. LIM                           88/02/07 
* 
*     THIS PROCEDURE READS THE HOST FILE, AND LOOKS FOR THE IP ADDRESS
*     OF THE USER HOST NAME.
* 
*     PROC FFSIRHF
* 
*     ENTRY   PARMS[1]   = HOST NAME IN 8/8 ASCII.
*             MBT        = FET AND CIO BUFFER FOR HOST FILE.
*             MBHX       = INDEX INTO MBT.
*             PAUSE      = TRUE => FLASH DAYFILE MESSAGE ON B-DISPLAY 
*                                  PENDING OPERATOR ACTION UPON 
*                                  TCPHOST FILE NOT FOUND.
*                        = FALSE => DONOT FLASH DAYFILE MESSAGE ON
*                                   B-DISPLAY UPON TCPHOST FILE NOT 
*                                   FOUND.
* 
*     EXIT    ONE OF THE FOLLOWING: 
* 
*               FFSIRHF = TRUE => HOST NAME FOUND.
*                 - PARMS[2] = HOST NAME OF THE MATCHING HOST.
*                 - PARMS[3] = IP ADDRESS OF THE MATCHING HOST NAME 
*                              IN ASCII.
*                 - PARMS[4] = IP ADDRESS OF THE MATCHING HOST NAME 
*                              IN DISPLAY CODE. 
*                 - PARMS[5] = IP ADDRESS OF THE MATCHING HOST NAME 
*                              IN BINARY INTERNET FORMAT. 
* 
*               FFSIRHF = FALSE => HOST FILE OR HOST NAME NOT FOUND.
* 
*     METHOD  FFSIRHF = FALSE.
* 
*             IF HOST FILE DOES NOT EXIST:  
*               IF PAUSE IS TRUE: 
*                 SET PAUSE FLAG IN RA+0. 
*                 SEND DAYFILE MESSAGE TO B DISPLAY.
*               ELSE: 
*                 EXIT. 
* 
*             SEARCH HOST NAME FILE FOR MATCHING HOST NAME
*             IF MATCH: 
*               PARMS[3] = IP ADDRESS OF THE MATCHING HOST NAME 
*                          IN ASCII.
*               PARMS[4] = IP ADDRESS OF THE MATCHING HOST NAME 
*                          IN DISPLAY CODE. 
*               PARMS[5] = IP ADDRESS OF THE MATCHING HOST NAME 
*                          IN BINARY INTERNET FORMAT. 
*               FFSIRHF = TRUE. 
* 
*             EXIT. 
# 
  
# 
****  PROC FFSIRHF - XREF LIST
# 
      XREF
        BEGIN 
        FUNC FATTACH I;                # ATTACH A PERMANENT FILE       #
        PROC FFSUCIA;                  # CONVERT IPA ADDRESS           #
        PROC FFSURFF;                  # READ FROM FILE                #
        FUNC FGET I;                   # GET A PERMANENT FILE          #
        PROC MESSAGE;                  # MESSAGE MACRO                 #
        PROC NETUCAC;                  # COPY AN ASCII CHARACTER       #
        PROC NETUCAD;                  # CONVERT ASCII TO DISPLAY CODE #
        PROC NETUCLR;                  # CLEAR AN AREA OF MEMORY       #
        PROC RECALL;                   # RELINQUISH CPU                #
        PROC RETERN;                   # RETURN A LOCAL FILE           #
        END 
# 
****
# 
  
      ITEM DIND          I;            # DESTINATION INDEX             #
      ITEM DINDEX        I;            # DESTINATION INDEX             #
      ITEM FOUND         B;            # MATCHING HOST NAME FOUND FLAG #
      ITEM I             I;            # LOOP INDUCTION VARIABLE       #
      ITEM J             I;            # LOOP INDUCTION VARIABLE       #
      ITEM K             I;            # LOOP INDUCTION VARIABLE       #
      ITEM RESULT        I;            # RESULT FROM *READC* MACRO     #
      ITEM SIND          I;            # SOURCE INDEX                  #
      ITEM SINDEX        I;            # SOURCE INDEX                  #
  
      ARRAY THISCHAR [00:00] S(1);     # CURRENT CHARACTER             #
        BEGIN 
        ITEM THISCHR     U(00,00,08); 
        END 
  
      BASED ARRAY CHOST [01:01] S(1);  # CURRENT HOST NAME READ        #
        BEGIN 
        ITEM CWORD       U(00,00,60); 
        END 
  
      BASED ARRAY LHOST [01:01] S(1);  # LOCAL HOST NAME               #
        BEGIN 
        ITEM LWORD       U(00,00,60); 
        END 
  
      BASED ARRAY JCAREA [00:00] S(1);  # JOB COMMUNICATION AREA       #
        BEGIN 
        ITEM WORD0       U(00,00,60);   # WHOLE WORD REFERENCE         #
        ITEM PAUSEFLAG   B(00,47,01);   # PAUSE FLAG                   #
        END 
  
      ARRAY FNFMSG [00:00] S(4);
        BEGIN 
        ITEM FNF$MSG     C(00,00,30) =
          ["$HOST FILE NOT FOUND,GO/DROP."];
        ITEM ZBYTE       U(03,00,60) = [0]; 
        END 
  
  
      CONTROL EJECT;
      PROC FFS2GNC; 
      BEGIN                            # FFS2GNC                       #
# 
*     INTERNAL PROCEDURE - FFS2GNC
* 
*     THIS EMBEDDED PROCEDURE GETS THE NEXT CHARACTER.
* 
# 
      DIND = 0; 
      NETUCAC (OUTBUF, SIND,
               THISCHAR, DIND);        # GET NEXT CHARACTER            #
      SIND = SIND + 1;                 # INCREMENT CHARACTER INDEX     #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2GNC                       #
      CONTROL EJECT;
      PROC FFS2ANT (PARBLK);
      BEGIN                            # FFS2ANT                       #
# 
*     INTERNAL PROCEDURE - FFS2ANT
* 
*     THIS EMBEDDED PROCEDURE ASSEMBLES THE NEXT TOKEN INTO THE 
*     SUPPLIED PARAMETER BLOCK. 
* 
# 
      ARRAY PARBLK [00:00] S(PARSIZ$);
        BEGIN 
        ITEM PARP        U(00,00,60); 
        ITEM PARS        U(S$,00,60); 
        END 
# 
*     CLEAR PARAMETER BLOCK AND SKIP ALL BLANK CHARACTERS.
# 
      NETUCLR (LOC(PARBLK), PARSIZ$);  # CLEAR PARAMETER BLOCK         #
      FOR SIND = SIND 
        WHILE (SIND LQ OUTLEN) AND
              (THISCHR EQ ASCISPACE)
      DO
        BEGIN                          # SKIP ALL BLANK CHARACTERS     #
        FFS2GNC;                       # GET NEXT CHARACTER            #
        END 
# 
*     TOKEN COMPRISES ALL CHARACTERS UP TO END, SPACE OR COMMENT. 
# 
      FOR SIND = SIND 
        WHILE (SIND LQ OUTLEN) AND
              (THISCHR NQ ASCISPACE) AND
              (THISCHR NQ ASCINSIGN)
      DO
        BEGIN                          # TILL END, SPACE OR COMMENT    #
        IF PARS LS 60 
        THEN
          BEGIN                        # STORE MAX OF 60 CHARACTERS    #
          IF THISCHR GQ ASCILA AND
             THISCHR LQ ASCILZ
          THEN
            BEGIN                      # LOWER CASE CHARACTER          #
            THISCHR = THISCHR - X"20"; # CONVERT TO UPPER CASE         #
            END 
          DIND = PARS;
          NETUCAC (THISCHAR, 0, 
                   PARBLK, DIND);      # STORE UPPER CASE TOKEN CHAR   #
          PARS = PARS + 1;             # UPDATE TOKEN LENGTH           #
          END 
        FFS2GNC;                       # GET NEXT CHARACTER            #
        END 
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2SCC                       #
      CONTROL EJECT;
      FUNC FFS2FIP B; 
      BEGIN                            # FFS2FIP                       #
# 
**    THIS EMBEDDED FUNCTION SEARCHES THE HOST NAME FILE FOR AN ENTRY 
*     MATCHING THE SPECIFIED HOST NAME. IF FOUND A TRUE RESULT IS 
*     RETURNED AND THE CORRESPONDING IP ADDRESS IS RETURNED IN PARMS[3].
* 
# 
      FOUND = FALSE;                   # DEFAULT TO NOT FOUND          #
      MBT$STAT[MBHX] = 1;              # CLEAR STATUS + SET COMPLETION #
      FFSURFF (RESULT);                # READ FIRST LINE OF FILE       #
      FOR I = 1 
        WHILE (RESULT EQ 0) AND 
              (NOT FOUND) 
      DO
        BEGIN                          # LOOP TILL MATCH OR END        #
        SIND = 0;                      # INITIALIZE SOURCE INDEX       #
        FFS2GNC;                       # GET FIRST CHARACTER           #
        FFS2ANT (PARMS[3]);            # ASSEMBLE IP ADDRESS           #
        FOR J = 1 
          WHILE (SIND LQ OUTLEN) AND
                (THISCHR NQ ASCINSIGN) AND
                (NOT FOUND) 
        DO
          BEGIN                        # TILL MORE HOST NAMES TO CHECK #
          FFS2ANT (PARMS[2]);          # ASSEMBLE HOST NAME            #
# 
*     CHECK FOR A MATCHING HOST NAME. 
# 
          IF PARAMSZ[2] GR 0
          THEN
            BEGIN                      # HOST NAME ASSEMBLED           #
            P<LHOST> = LOC(PARMS[1]);  # POINTER TO USER HOST NAME     #
            P<CHOST> = LOC(PARMS[2]);  # POINTER TO CURRENT HOST NAME  #
            FOUND = TRUE;              # ASSUME MATCHING HOST NAME     #
            FOR K = 1 STEP 1
              WHILE K LQ PARSIZ$ AND FOUND
            DO
              BEGIN                    # LOOP WHILE HOST NAME MATCH    #
              FOUND = LWORD[K] EQ CWORD[K]; 
              END 
            END 
          END 
# 
*     IF MATCH NOT FOUND THEN READ NEXT LINE OF HOST NAME FILE. 
# 
        IF NOT FOUND
        THEN
          BEGIN                        # HOST NAME MATCH NOT FOUND     #
          FFSURFF (RESULT);            # READ NEXT LINE OF FILE        #
          END 
        END 
  
      RETERN (MBT[MBHX]);              # RETURN HOST NAME FILE         #
      FFS2FIP = FOUND;                 # RETURN RESULT TO CALLER       #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFS2FIP                       #
      CONTROL EJECT;
# 
*     START MAIN PROCEDURE
# 
  
      FFSIRHF = FALSE;            # DEFAULT TO HOST FILE/NAME NOT FOUND#
      P<JCAREA> = 0;              # POINT AT RA+0 OF JOB COMM AREA     #
# 
*     ATTEMPT TO ACCESS HOST NAME FILE. 
# 
 LAB$GETF:  
  
      IF FGET(MBT[MBHX]) NQ 0 
      THEN
        BEGIN                          # COULD NOT GET HOST NAME FILE  #
        IF FATTACH(MBT[MBHX]) NQ 0
        THEN
          BEGIN                        # COULD NOT ATTACH HOST FILE    #
          IF PAUSE
          THEN
            BEGIN 
            PAUSEFLAG = TRUE;          # SET THE PAUSE FLAG            #
            MESSAGE(FNFMSG, 2);        # FLASH MESSAGE AT B-DISPLAY    #
LAB$PAUSE:  
            IF PAUSEFLAG
            THEN
              BEGIN                    # STILL PAUSING                 #
              RECALL(0);               # RECALL                        #
              GOTO LAB$PAUSE;          # CHECK PAUSE BIT AGAIN         #
              END 
            ELSE
              BEGIN                    # STOPPED PAUSING               #
              GOTO LAB$GETF;           # TRY TO ACCESS THE FILE AGAIN  #
              END 
            END 
          ELSE
            BEGIN 
            RETURN;                    # GET OUT OF HERE QUICKLY       #
            END 
          END                          # COULD NOT ATTACH HOST FILE    #
  
        END                            # COULD NOT GET HOST NAME FILE  #
# 
*     FIND IP ADDRESS FOR SPECIFIED HOST NAME.
# 
      IF NOT FFS2FIP
      THEN
        BEGIN                          # HOST NAME SPECIFIED UNKNOWN   #
        RETURN;                        # GET OUT OF HERE QUICKLY       #
        END 
  
# 
*     CONVERT IP ADDRESS FROM ASCII TO DISPLAY CODE, AND STORE INTO 
*     PARMS[4]. 
*     CONVERT DISPLAY CODE FORM OF IP ADDRESS INTO INTERNET FORMAT AND
*     STORE INTO PARMS[5].
*     SET RETURN STATUS TO HOST NAME FOUND. 
# 
      SINDEX = 0; 
      DINDEX = 0; 
      NETUCAD(PARMS[3], SINDEX, PARAMSZ[3], 
              PARMS[4], DINDEX);
  
      FFSUCIA(PARMS[4], PARMS[5]);     # CONVERT IP ADDRESSES ROUTINE  #
  
      FFSIRHF = TRUE;                  # HOST NAME FOUND               #
  
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # FFSIRHF                       #
  
      TERM
