*DECK PMPPROC 
USETEXT TEXTIPL 
USETEXT TEXTRPC 
USETEXT TEXTXDR 
      PROC PMPPROC (PROCNUM, INBUFFER, INBUFPOS, INBUFLEN, RESPONSE,
*CALL COPYRITE
        OUTBUFFER, OUTBUFLEN);
# TITLE PMPPROC - PROCESS PORTMAPPER REMOTE PROCEDURE REQUEST          #
  
      BEGIN                            # PMPPROC                       #
# 
****  PMPPROC  PROCESS PORTMAPPER REMOTE PROCEDURE REQUEST
* 
*     THIS PROCEDURE PROCESSES A PORTMAPPER REQUEST RECEIVED FROM A 
*     REMOTE SYSTEM ON THE PORTMAPPER PORT. 
* 
*     PROC PMPPROC
* 
*     ENTRY    PROCNUM    = PROCEDURE NUMBER CALLED 
*              INBUFFER   = INPUT BUFFER
*              INBUFPOS   = INPUT BUFFER POSITION 
*              INBUFLEN   = INPUT BUFFER LENGTH 
*              RESPONSE   = PORTMAPPER RESPONSE CODE
* 
*     EXIT     RESPONSE   = PORTMAPPER RESPONSE CODE
*              OUTBUFFER  = OUTPUT BUFFER 
*              OUTBUFLEN  = OUTPUT BUFFER LENGTH
* 
*     METHOD   A "GETPORT" RPC REQUEST IS DECODED AND USED TO SEARCH
*              THE PORTMAPPER DATABASE. IF THE ENTRY IS FOUND, IT IS
*              FORMATTED IN XDR AND RETURNED TO THE CALLER. 
* 
*              A "PMAPLIST" RPC REQUEST RESULTS IN THE ENTIRE 
*              PORTMAPPER DATABASE BEING ENCODED WITH XDR AND RETURNED
*              TO THE CALLER. 
* 
*              ANY OTHER REQUEST TYPE RETURNS A "PROC UNAVAILABLE"
*              RESPONSE.
# 
# 
*     PROC PMPPROC - XREF LIST
# 
      XREF
        BEGIN 
        PROC XDRINT;     # CONVERT INTEGERS TO XDR FORMAT              #
        END 
# 
**
# 
      ITEM PROCNUM            U;       # PROCEDURE NUMBER CALLED       #
      ARRAY INBUFFER [0:0] S(1);;      # INPUT BUFFER                  #
      ITEM INBUFPOS           U;       # INPUT BUFFER POSITION         #
      ITEM INBUFLEN           U;       # INPUT BUFFER LENGTH           #
      ITEM RESPONSE S:ACCEPTSTAT;      # RESPONSE CODE                 #
      ARRAY OUTBUFFER [0:0] S(1);;     # OUTPUT BUFFER                 #
      ITEM OUTBUFLEN          U;       # OUTPUT BUFFER LENGTH          #
# 
**
# 
      ITEM INDEX              U;       # LOOP INDEX                    #
      ARRAY NEXT    [00:01] S(1);      # PRESETS FOR RPC NEXT BOOLEAN  #
        ITEM NEXTITM   B(0,0,60) = [FALSE, TRUE]; 
      ARRAY PMAPREQ [00:00] S(4);      # PORTMAPPER STRUCT MAPPING     #
        BEGIN 
        ITEM PROG      U(0,0,60);      # PROGRAM NUMBER                #
        ITEM VERS      U(1,0,60);      # VERSION NUMBER                #
        ITEM PROT      U(2,0,60);      # PROTOCOL NUMBER               #
        ITEM PORT      U(3,0,60);      # PORT NUMBER                   #
        END 
      BASED ARRAY PORTVAL [0:0] S(1);; # PORT NUMBER                   #
      CONTROL EJECT;
# 
****  START MAIN PROCEDURE
* 
****  DETERMINE CALL TYPE 
# 
      OUTBUFLEN = 0;
      IF PROCNUM EQ PMAPPROC"GETPORT" 
      THEN
        BEGIN 
# 
****    PROCESS GETPORT REQUEST 
# 
        XDRINT (INBUFFER, INBUFPOS, PMAPREQ, 4, XDROPER"READ"); 
        FOR INDEX = 0 STEP 1 UNTIL MAXREG$ DO 
          BEGIN 
          IF (PROG [0] EQ PM$PROGNUM [INDEX]) AND 
             (VERS [0] EQ PM$VERSION [INDEX]) AND 
             (PROT [0] EQ PM$PROTOCOL [INDEX])
          THEN                         # MATCHING ENTRY FOUND          #
            BEGIN 
            P<PORTVAL> = LOC(PM$PORT [INDEX]);
            XDRINT (OUTBUFFER, OUTBUFLEN, PORTVAL, 1, XDROPER"WRITE");
            RESPONSE = S"SUCCESS";
            RETURN; 
            END 
          END 
# 
****    ENTRY NOT FOUND 
# 
        RESPONSE = S"PROGUNAVAIL";
        RETURN; 
        END 
  
      IF PROCNUM EQ PMAPPROC"DUMP"
      THEN
        BEGIN 
# 
****    PROCESS DUMP REQUEST
# 
        FOR INDEX = 0 STEP 1 UNTIL MAXREG$ DO 
          BEGIN 
          IF (PM$PROGNUM [INDEX] NQ 0)
          THEN                         # ACTIVE ENTRY FOUND            #
            BEGIN 
            XDRINT (OUTBUFFER, OUTBUFLEN, NEXT [1], 1, XDROPER"WRITE"); 
            XDRINT (OUTBUFFER, OUTBUFLEN, PM$PORTMAP [INDEX], 4,
              XDROPER"WRITE");
            END 
          END 
          XDRINT (OUTBUFFER, OUTBUFLEN, NEXT [0], 1, XDROPER"WRITE"); 
  
        RESPONSE = S"SUCCESS";
        RETURN; 
        END 
# 
****  UNSUPPORTED PROC
# 
      RESPONSE = S"PROCUNAVAIL";
      RETURN;                          # RETURN TO CALLER              #
  
      END                              # PMPPROC                       #
  
      TERM
