*DECK FINDPIDS
USETEXT COMCBEG 
USETEXT COMRNET 
USETEXT COMRQUE 
PROC    FINDPIDS(RTNSTATUS,FIRSTCALL);
#     TITLE   FINDPIDS - FIND ALL PIDS ASSOCIATED WITH THE
                         REQUESTED LID  # 
  
      BEGIN  # FINDPIDS  #
  
# 
**    FINDPIDS -  FIND ALL PIDS ASSOCIATED WITH THE REQUESTED LID 
* 
*     THIS PROCEDURE IS APPLICABLE TO NOS ONLY.  IT WILL ACCESS THE 
*     LIDT VIA A GETLIDC MACRO CALL TO FIND ALL PIDS ASSOCIATED WITH
*     THE LID.  IF ONLY THE PID IS SPECIFIED A GETPIDA MACRO CALL 
*     WILL BE MADE TO VERIFY THAT THE PID IS VALID AND ENABLED.  A
*     STATUS OF TRUE WILL BE RETURNED IF AN ENABLED LIDT PID MATCHES
*     THE CURRENT ENTRY (NET$PID) IN THE NETWORK DESCRIPTION TABLE. 
* 
*     PROC FINDPIDS (RTNSTATUS,FIRSTCALL) 
* 
*     ENTRY   QU$ADDRESS - BASED ARRAY CONTAINING CON/ACRQ/R
*             NET$HEADER - BASED ARRAY CONTAINING CURRENT ENTRY 
*                          IN NDT 
*             FIRSTCALL  - TRUE   - ISSUE LIDT MANAGEMENT FUNCTION
*                                   GETLIDC OR GETPIDA
*                          FALSE  - CHECK LIDT RETURN PARAMETER BUFFER
*                                   FOR MATCHING PID
* 
*     EXIT    RTNSTATUS  - TRUE IF ENABLED PID FOUND FOR REQUESTED
*                          LID AND MATCHING NET$PID 
*     PROCESS   IF FIRST CALL 
*               THEN
*                 CLEAR BUFFER. 
*                 ISSUE LID MANAGEMENT REQUEST. 
*                 IF ONLY PID SPECIFIED (LID = 0) 
*                 THEN
*                   GET PID ATTRIBUTES. 
*                 ELSE
*                   GET LID CONFIGURATION.
*               ELSE
*                 SET RTNSTATUS TO FALSE. 
*                 CHECK LID MANAGEMENT RETURN PARAMETERS. 
*                 IF ONLY PID SPECIFIED 
*                 THEN
*                   IF PID ACCESSIBLE 
*                   THEN
*                     SET RTNSTATUS TO TRUE.
*                 ELSE
*                   SEARCH LIST OF ENABLED PIDS RETURNED. 
*                   IF MATCHING PID FOUND 
*                     AND PATH AVAILABLE
*                     AND NOT STORE AND FORWARD 
*                   THEN
*                     SET RTNSTATUS TO TRUE.
* 
# 
      ITEM  FIRSTCALL     B;       # INITIAL CALL  #
      ITEM  RTNSTATUS     B;       # RETURN STATUS  # 
  
# 
****  PROC FINDPIDS XREF LIST BEGIN.
# 
      XREF
        BEGIN 
        PROC GETLIDC;              # GET LID CONFIGURATION  # 
        PROC GETPIDA;              # GET PID ATTRIBUTE  # 
        END 
  
  
    CONTROL  IFEQ OS$NOS; 
      ITEM  BARRAY        B;       # BASED ARRAY FLAG  #
      ITEM  I             I;       # INDEX  # 
      ITEM  PIDCNT        I;       # COUNT OF PIDS IN BUFFER  # 
  
      BASED ARRAY GPARM [0:0] S(2); 
        BEGIN  # GETLIDC/GETPIDA PARAMETER BLOCK  # 
        ITEM GP$WD0     U(00,00,60);
        ITEM GP$WD1     U(01,00,60);
# 
*       GETPIDA DEFINITIONS 
# 
        ITEM GP$PID     C(00,00,03);  # PID  #
# 
*       GETLIDC DEFINITIONS 
# 
        ITEM GP$WC      I(00,00,12);  # WORD COUNT OF RETURN BUFFER#
        ITEM GP$RC      I(00,42,08);  # RETURN CODE  #
        ITEM GP$CMP     B(00,59,01);  # COMPLETE BIT  # 
        ITEM GP$LID     C(01,00,03);  # LID  #
        ITEM GP$NUMPIDS I(01,48,12);  # NUMBER OF PIDS FOR THIS LID  #
        END    # GETLIDC/GETPIDA PARAMETER BLOCK  # 
  
      BASED ARRAY GRTN$ENTRY [0:0] S(1);
        BEGIN  #GETLIDC RETURN PARAMETER DESCRIPTION  # 
        ITEM GR$PID     C(00,00,03);  # PID  #
        ITEM GR$SAF     B(00,18,01);  # STORE AND FORWARD  #
        ITEM GR$LB      B(00,19,01);  # LOOPBACK  # 
        ITEM GR$SSF     I(00,48,04);
        ITEM GR$RHF     I(00,52,04);
        ITEM GR$NHP     I(00,56,04);
        END    # GETLIDC RETURN PARAMETER DESCRIPTION  #
      CONTROL EJECT;
CONTROL  EJECT;                    # INITIALIZATION  #
      IF FIRSTCALL
      THEN
        BEGIN                      #ISSUE LID MANAGEMENT CALL  #
        P<LDT$PENTRY> = LDT$BPTR[0];
        SLOWFOR I = 1 STEP 1 UNTIL LDT$BUFL[0]
        DO
          BEGIN                    # CLEAR BUFFER  #
          LDT$PWD0 = 0; 
          P<LDT$PENTRY> = P<LDT$PENTRY>+1;
          END 
  
        P<GPARM> = LDT$BPTR[0]; 
        IF QU$LIDI EQ 0 
        THEN
          BEGIN                    # GETPIDA  # 
          GP$WD0 = 0; 
          GP$PID = QU$PID;
          GP$CMP = TRUE;
          BARRAY = TRUE;
          GETPIDA(P<GPARM>,BARRAY); 
          P<GRTN$ENTRY> = P<GPARM>+1; 
          END 
  
        ELSE
          BEGIN                    # GETLIDC  # 
          GP$WD0 = 0; 
          GP$WC = LDT$BUFL[0];
          GP$CMP = TRUE;
          GP$WD1 = 0; 
          GP$LID = QU$LID;
          BARRAY = TRUE;
          GETLIDC(P<GPARM>,BARRAY); 
          P<GRTN$ENTRY> = P<GPARM>+2; 
          IF  GP$NUMPIDS GT GP$WC 
          THEN
            BEGIN 
            PIDCNT = GP$WC;        # LIMIT COUNT TO BUFFER SIZE  #
            END 
  
          ELSE
            BEGIN 
            PIDCNT = GP$NUMPIDS;   # ACTUAL COUNT OF PIDS RETURNED  # 
            END 
  
          END                      # GETLIDC  # 
  
        END                        # LID MANAGEMENT REQUEST  #
  
      ELSE                         # NOT INITIALIZATION CALL  # 
  
        BEGIN                      # CHECK RETURN PARAMETERS  # 
        RTNSTATUS = FALSE;
        IF QU$LIDI EQ 0 
        THEN
          BEGIN                    # GETPIDA - CHECK FOR PID ENABLED  # 
          P<LDT$PENTRY> = P<GPARM> + 1; 
          IF LDT$PID EQ NET$PID 
            AND LDT$ENABLE
            AND LDT$RHF EQ NW$PTHSUP
          THEN
            BEGIN 
            RTNSTATUS = TRUE; 
            END 
  
          END 
  
        ELSE
          BEGIN                    # GETLIDC - SEARCH PID LIST  # 
          P<GRTN$ENTRY> = P<GPARM> + 2; 
          SLOWFOR I = 1 STEP 1 UNTIL PIDCNT 
          DO
            BEGIN 
            IF GR$PID EQ NET$PID
              AND GR$RHF EQ NW$PTHSUP 
            THEN
              BEGIN 
              IF QU$PIDI NE 0 
                OR NOT GR$SAF 
              THEN
                BEGIN 
                RTNSTATUS = TRUE; 
                EXIT PIDSRCH; 
                END 
  
              END 
  
            P<GRTN$ENTRY> = P<GRTN$ENTRY>+1;
          END 
  
        END  PIDSRCH: 
  
      END 
    CONTROL  ENDIF; 
  
      RETURN; 
      END  # FINDPIDS  #
      TERM
