*DECK SSIRASR 
USETEXT TEXTATS 
USETEXT TEXTIPL 
USETEXT TEXTRPC 
USETEXT TEXTXDR 
      PROC SSIRASR (TIMER, RETCODE);
*CALL COPYRITE
# TITLE SSIRASR - RECEIVE ATS SERVER REQUEST.                          #
  
      BEGIN                            # SSIRASR                       #
# 
****  SSIRASR - RECEIVE ATS SERVER REQUEST. 
* 
*     THIS PROCEDURE OBTAINS A QUEUED SERVER REQUEST FROM THE SERVER
*     SYSTEM.  THE REQUEST IS AN ACKNOWLEDGMENT OR FINAL RESPONSE FROM
*     A PREVIOUS CLIENT REQUEST.
* 
*     PROC SSIRASR
* 
*     ENTRY    TIMER    = TIME TO WAIT FOR A SERVER REQUEST 
* 
*     EXIT     RETCODE  = COMPLETION STATUS 
* 
*     METHOD   CALL *SSIRPSR* TO PROCESS ANY PORTMAPPER REQUESTS QUEUED.
*              CALL *IPPSTAS* TO SEE IF THERE ARE ANY SERVER REQUESTS 
*              OUTSTANDING.  IF NONE ARE FOUND, LOOP UNTIL ONE IS FOUND 
*              OR THE TIMER EXPIRES.
*              IF ONE IS FOUND, DECODE THE CSI HEADER, MESSAGE HEADER,
*              AND RESPONSE HEADER.  CALL THE ROUTINE BASED ON THE
*              COMMAND TYPE TO FURTHER DECODE THE RECEIVED SERVER 
*              REPLY.  IF NOT ENOUGH DATA WAS RECEIVED FOR A REQUEST
*              ISSUE A GARBAGE ARGUEMENTS REPLY.  IF THE PROCEDURE
*              CALLED IS NOT ATSPROC$, ISSUE A PROCEDURE UNAVAILABLE
*              REPLY, OTHERWISE THE REQUEST IS ASSUMED VALID.  RETURN 
*              AN ERROR CODE INDICATING THE RESULT OF THE CALL. 
* 
# 
  
# 
****  PROC SSIRASR - XREF LIST. 
# 
  
      XREF
        BEGIN 
        PROC IPPSTAS;    # GET IP SOCKET STATUS                        #
        PROC RPCSREP;    # SEND RPC SERVER REPLY                       #
        PROC RPCSREQ;    # GET RPC SERVER REQUEST                      #
        PROC RTIME;      # REAL TIME CLOCK                             #
        PROC SSIDDIS;    # DEBUG DISPLAY                               #
        PROC SSIPSCR;    # PROCESS SERVER COMMAND REPLY                #
        PROC SSIPSQR;    # PROCESS SERVER QUERY REPLY                  #
        PROC SSIRPSR;    # RECEIVE PORTMAPPER SERVER REQUEST           #
        PROC SSISRID;    # SKIP RESPONSE IDENTIFIER BYTES              #
        PROC XDRINT;     # CONVERT INTEGER TO XDR FORMAT.              #
        PROC XDRSTR;     # CONVERT STRING TO XDR FORMAT                #
        END 
  
# 
**
# 
  
      ITEM TIMER               I;      # WAIT TIME FOR A SERVER REQUEST#
      ITEM RETCODE             I;      # ERROR STATUS                  #
  
  
      ITEM READ                B;      # IPPSTAS, DATA AVAILABLE       #
      ITEM INBUFLEN            I;      # INPUT BUFFER LENGTH           #
      ITEM INBUFPOS            I;      # INPUT BUFFER BYTE POSITION    #
      ITEM LOOP                I;      # LOOP COUNTER                  #
      ITEM OUTBUFLEN           I;      # OUTPUT BUFFER LENGTH          #
      ITEM REPLYSIZE           I;      # NUMBER OF WORDS IN REPLY MSG  #
      ITEM RESPONSE S:ACCEPTSTAT;      # RPC RESPONSE CODE             #
      ITEM RPCPROCNUM          I;      # RECEIVED RPC PROCEDURE NUMBER #
      ITEM RPCSTATUS   S:RPCSTAT;      # RPC STATUS                    #
      ITEM SOCKSTATUS S:SOCKSTAT;      # SOCKET CALL STATUS            #
      ITEM STATE  S:CONNECTSTATE;      # IPPSTAS, SOCKET STATE         #
      ITEM UPLNGTH             I;      # USERNAME/PASSWORD LENGTH      #
      ITEM WRITE               B;      # IPPSTAS, DATA CAN BE WRITTEN  #
  
      ARRAY RCP$TIME [00:00] S(2);
        BEGIN 
        ITEM RCP$SECONDS  U(00,00,24); # SECOND TIMER                  #
        ITEM RCP$MILLI    U(00,24,36); # MILLISECOND TIMER             #
        ITEM RCP$EXPIRE   U(01,00,24); # SECOND EXPIRE TIME            #
        END 
CONTROL EJECT;
  
# 
****  START MAIN PROCEDURE
# 
  
  
      RTIME (RCP$TIME);                # CURRENT TIME                  #
      RCP$EXPIRE [0] = RCP$SECONDS [0] + TIMER; 
      READ = FALSE; 
  
      FOR LOOP = 0
      WHILE NOT READ
      DO
        BEGIN                          # LOOP UNTIL TIMER EXPIRES      #
        SSIRPSR (RETCODE);             # PROCESS PORTMAPPER            #
  
        IF (RETCODE EQ NOERROR$)
        THEN
          BEGIN                        # SERVER DATA AVAILABLE         #
          IPPSTAS (SRVR$SOCKET, STATE, READ, WRITE, SOCKSTATUS);
          IF SOCKSTATUS NQ S"OK"
          THEN
            RETCODE = SSOCKFAIL$; 
          END                          # SERVER DATA AVAILABLE         #
  
        IF RETCODE NQ NOERROR$
        THEN
          RETURN; 
  
        IF NOT READ 
        THEN
          BEGIN                        # CHECK IF EXPIRED              #
          RTIME (RCP$TIME); 
  
          IF (RCP$SECONDS [0] GQ RCP$EXPIRE [0])
          THEN
            BEGIN                      # TIMER EXPIRED                 #
            RETCODE = REMUNAVA$;
            RETURN; 
            END                        # TIMER EXPIRED                 #
          END                          # CHECK IF EXPIRED              #
        END                            # LOOP UNTIL TIMER EXPIRES      #
  
      RPCSREQ (SRVR$HANDLE, RPCPROCNUM, INDATABUF [0], INBUFPOS,
               INBUFLEN, RPCSTATUS);
  
      IF RPCSTATUS EQ S"OK" 
      THEN
        BEGIN                          # MESSAGE FOUND                 #
        INBUFLEN = INBUFLEN - INBUFPOS -
                   ((HDRSIZE$ + MSGSIZE$ + RSPSIZE$) * 4);
  
        IF INBUFLEN GQ 0
        THEN
          BEGIN                        # DECODE DATA                   #
          XDRINT (INDATABUF [0], INBUFPOS, CSI$HDR [REPLY$], HDRSIZE$,
                  XDROPER"READ"); 
          XDRINT (INDATABUF [0], INBUFPOS, MSG$HDR [REPLY$], MSGSIZE$,
                  XDROPER"READ"); 
  
          IF MSG$EXTHDR [REPLY$]
          THEN
           BEGIN                    # PROCESS UNUSED USER/PASSWORD  # 
           XDRSTR (INDATABUF [0], INBUFPOS, EXT$ACCESS [REPLY$],
                   UPLNGTH, XDROPER"READ"); 
           XDRSTR (INDATABUF [0], INBUFPOS, EXT$ACCESS [REPLY$],
                   UPLNGTH, XDROPER"READ"); 
           END                      # PROCESS UNUSED USER/PASSWORD  # 
          ELSE
           BEGIN                    # NOT AN EXTENDED MESSAGE       # 
            INBUFPOS = INBUFPOS - 3;
           END                      # NOT AN EXTENDED MESSAGE       # 
  
          XDRINT (INDATABUF [0], INBUFPOS, RSP$HDR [REPLY$], RSPSIZE$,
                  XDROPER"READ"); 
  
# 
****  DEPENDING ON THE RESPONSE TYPE, SKIP THE APPROPRIATE NUMBER OF
*     BYTES IN *INDATABUF* TO REACH THE COMMAND RESPONSE DATA.
# 
  
          SSISRID (RSP$TYPE [REPLY$], INBUFLEN, INBUFPOS);
  
          IF (RPCPROCNUM EQ ATSPROC$) AND 
             (INBUFLEN GQ 0)
          THEN
            BEGIN                      # ATS PROCEDURE                 #
            IF MSG$MESOPT [REPLY$] EQ ACKOPT$ 
            THEN
              BEGIN                    # MESSAGE AN ACKNOWLEDGEMENT    #
              IF DFLAG
              THEN
                 SSIDDIS (MSG$COMMAND [REPLY$], DEBUGACK$); 
  
              IF RSP$STATUS [REPLY$] NQ STATVALID$
              THEN
                RETCODE = INVALIDREQ$;
              END                      # MESSAGE AN ACKNOWLEDGEMENT    #
  
# 
****  ELSE MESSAGE IS A FINAL RESPONSE
# 
  
            ELSE
              BEGIN                    # MESSAGE A FINAL RESPONSE      #
              IF (MSG$COMMAND [REPLY$] EQ CSIQUERY$)
              THEN
                BEGIN                  # QUERY REPLY                   #
                SSIPSQR (INBUFPOS, INBUFLEN, RETCODE);
                END                    # QUERY REPLY                   #
              ELSE IF (MSG$COMMAND [REPLY$] EQ CSIMOUNT$) OR
                      (MSG$COMMAND [REPLY$] EQ CSIDISMOUNT$)
              THEN
                BEGIN                  # MOUNT OR DISMOUNT             #
                SSIPSCR (INBUFPOS, INBUFLEN, RETCODE);
                END                    # MOUNT OR DISMOUNT             #
              ELSE                     # COMMAND UNKNOWN               #
                RETCODE = UNKNOWNCMD$;
  
              IF DFLAG
              THEN
                SSIDDIS (MSG$COMMAND[REPLY$], DEBUGFINAL$); 
  
              END                      # MESSAGE A FINAL RESPONSE      #
            END                        # ATS PROCEDURE                 #
          END                          # DECODE DATA                   #
  
# 
****  ISSUE AN ACKNOWLEDGMENT TO THE SERVER SYSTEM. 
# 
  
        IF RPCPROCNUM NQ ATSPROC$ 
        THEN
          BEGIN 
          RESPONSE = S"PROCUNAVAIL";
          RETCODE = BADCALL$; 
          END 
        ELSE IF INBUFLEN LS 0 
        THEN
          BEGIN 
          RESPONSE = S"GARBAGEARGS";
          RETCODE = BADCALL$; 
          END 
        ELSE
          RESPONSE = S"SUCCESS";
  
        OUTBUFLEN = 0;
        RPCSREP (SRVR$HANDLE, RESPONSE, OUTDATABUF, OUTBUFLEN,
                 RPCSTATUS);
        IF RPCSTATUS EQ S"SOCKFAIL" 
        THEN
          RETCODE = SSOCKFAIL$; 
  
        END                            # MESSAGE FOUND                 #
      ELSE IF RPCSTATUS EQ S"SOCKFAIL"
      THEN
        RETCODE = SSOCKFAIL$; 
  
      IF RETCODE EQ NOERROR$
      THEN
        RETCODE = RPC$ERR [RPCSTATUS];
  
      END                              # SSIRASR                       #
  
      TERM
