*DECK PATHVAL 
USETEXT COMCBEG 
USETEXT COMRLRA 
USETEXT COMRNET 
USETEXT COMRQUE 
USETEXT COMRRTN 
PROC PATHVAL(REPLYCODE);
# TITLE PATHVAL - VALIDATE PATH FOR REMOTE CONNECT REQUEST. # 
  
      BEGIN  # PATHVAL #
  
# 
**    PATHVAL - VALIDATE PATH FOR REMOTE CONNECT REQUEST. 
* 
*     VERIFY THAT REQUESTING NAD IS IN OUR CONFIGURATION. VERIFY
*     THAT PID, PATH AND NAD ARE ALL ENABLED. 
* 
*     PROC PATHVAL(REPLYCODE).
* 
*     ENTRY   -  QU$ADDRESS IS BASED ARRAY CONTAINING REMOTE CONNECTION 
*                  REQUEST. 
* 
*     EXIT    -  REPLYCODE: 
*                  CONR$OK     - PID, PATH, NAD ALL ENABLED.
*                  CONR$BDID  - NO MATCHING ENABLED PID FOUND.
*                  CONR$BDNAD - NO MATCHING REMOTE NAD
*                                OR PATH OR NAD DISABLED. 
*                NET$HEADER IS BASED ARRAY CONTAINING PID HEADER. 
*                PTH$ENGRY IS BASED ARRAY CONTAINING PATH ENTRY.
*                NAD$ENTRY IS BASED ARRAY CONTAINING NAD ENTRY. 
*                RMT$ENTRY IS BASED ARRAY CONTAINING REMOTE NAD ENTRY.
* 
*     PROCESS -  FOR EACH PID HEADER: 
*                  IF NOS ISSUE GETPIDA TO VERIFY PID ENABLED.
*                  IF PID MATCHES AND IS ENABLED
*                  THEN:  
*                    FOR EACH PATH ENTRY: 
*                      IF NAD ADDRESS MATCHES 
*                        AND DESTINATION MATCHES
*                        AND EST AND PATH ARE ENABLED 
*                        AND TRUNK IS ENABLED 
*                      THEN:  
*                        PATH IS VALID. 
*                SET APPROPRIATE REPLY CODE 
*                RETURN.
* 
* 
# 
  
      ITEM REPLYCODE I;              # REPLY CODE # 
  
# 
*     PROC PATHVAL - XREF LIST BEGIN. 
# 
  
      XREF
        BEGIN 
        PROC GETPIDA;        # GET PID ATTRIBUTE  # 
        ITEM NADTBL  I;              # LOCAL NAD TABLE ADDRESS #
        ITEM NDTADDR  I;             # NETWORK DEFINITION TABLE ADDR #
        END 
  
# 
*     PROC PATHVAL - XREF LIST END. 
# 
  
  
      ITEM INDX      I;              # INDEX FOR PATH TABLE SEARCH #
      ITEM PATHFOUND B;              # PATH FOUND INDICATOR # 
       ITEM PIDENABLD B;      # PID ENABLED FLAG  # 
  
    CONTROL IFEQ OS$NOS;
      ITEM BARRAY   B;               # BASED ARRAY FLAG  #
  
      BASED ARRAY GETPA [0:0] S(1); 
        BEGIN  # GETPIDA PARAMETER  # 
        ITEM  GPA$WD0   U(00,00,60);
        ITEM  GPA$PID   C(00,00,03);
        ITEM  GPA$RC    U(00,42,08);
        ITEM  GPA$CMPLT B(00,59,01);
        END    # GETPIDA PARAMETER  # 
    CONTROL ENDIF;
  
CONTROL EJECT;
  
      PATHFOUND = FALSE;
      REPLYCODE = CONR$BDID;
      P<NET$HEADER> = NDTADDR;
  
      ASLONGAS P<NET$HEADER> NE 0 AND NOT PATHFOUND 
      DO
        BEGIN  # LOOK AT NEXT PID HEADER #
  
      CONTROL IFEQ OS$NOS;
        IF QU$REMPID EQ NET$PID 
        THEN
          BEGIN 
          P<GETPA> = LDT$BPTR;
          GPA$WD0 = 0;
          GPA$PID = QU$REMPID;
          GPA$CMPLT = TRUE; 
          P<LDT$PENTRY> = P<GETPA> + 1; 
          LDT$PWD0 = 0; 
          BARRAY = TRUE;
          GETPIDA(P<GETPA>,BARRAY); 
          PIDENABLD = LDT$ENABLE; 
          END 
      CONTROL ENDIF;
  
      CONTROL IFEQ OS$NOSBE;
        PIDENABLD = NET$ENABLE; 
      CONTROL ENDIF;
  
  
        IF QU$REMPID EQ NET$PID 
          AND PIDENABLD 
        THEN
          BEGIN  # FOUND PID MATCHING REQUESTOR # 
          REPLYCODE = CONR$OK;
          P<PTH$ENTRY> = NET$PATHAD;
  
          SLOWFOR INDX = 1 STEP 1 
            WHILE NOT PATHFOUND AND INDX LE NET$NMPATH
          DO
            BEGIN  # SEARCH PATH TABLE #
            P<NAD$ENTRY> = NADTBL + PTH$NADORD * NAD$LENGTH;
            P<RMT$ENTRY> = PTH$RMTNAD;
  
            IF QU$CONNAD  EQ RMT$NAD
              AND QU$CONDEST EQ RMT$DEST
              AND QU$LOCNAD EQ PTH$NADORD 
              AND NOT NAD$ESTOFF
              AND NOT NAD$PREVOF
              AND PTH$ENABLE
              AND (-PTH$LTE LAN QU$CONLT EQ 0)
            THEN
              BEGIN  # PATH IS OK # 
              PATHFOUND = TRUE; 
              EXIT NETSRCH; 
              END 
  
            P<PTH$ENTRY> = P<PTH$ENTRY> + PTH$LENGTH; 
            END 
  
          END 
  
        P<NET$HEADER> = NET$NXTPID; 
        END NETSRCH:  
  
      IF REPLYCODE EQ CONR$OK AND NOT PATHFOUND 
      THEN
        BEGIN  # PID FOUND BUT CORRECT PATH NOT FOUND # 
        REPLYCODE = CONR$BDNAD; 
        END 
  
      RETURN; 
      END  # PATHVAL #
  
      TERM
