*DECK SSISACR 
USETEXT TEXTATS 
USETEXT TEXTIPL 
USETEXT TEXTRPC 
USETEXT TEXTXDR 
      PROC SSISACR (COMMAND, RETCODE);
*CALL COPYRITE
# TITLE SSISACR - SEND ATS CLIENT REQUEST                              #
  
      BEGIN                            # SSISACR                       #
# 
****  SSISACR - SEND ATS CLIENT REQUEST.
* 
*     THIS PROCEDURE SENDS AN ATS CLIENT REQUEST TO THE ACS LIBRARY 
*     MANAGER VIA THE SERVER SYSTEM.
* 
*     PROC SSISACR
* 
*     ENTRY    COMMAND    = COMMAND TO ISSUE TO SERVER SYSTEM 
* 
*     EXIT     RETCODE    = COMPLETION STATUS OF SERVER REQUEST 
* 
*     METHOD   CALL *SSIRPSR* TO PROCESS ANY PORTMAPPER REQUESTS QUEUED.
*              VERIFY *COMMAND* IS A VALID ENTRY FOR THE *CSI$COMMAND*
*              ARRAY.  IF NOT AN INTERNAL ERROR IS RETURNED IN *STAT*.
*              CREATE A CLIENT HANDLE TO THE SERVER SYSTEM.  PORTMAPPER 
*              WILL DETERMINE THE PORT TO USE.  MODIFY THE CSI HEADER,
*              MESSAGE HEADER, AND COMMAND HEADER FOR ANY COMMAND 
*              SPECIFIC ENTRIES.  USE THE XDRINT ROUTINE TO BUILD THE 
*              REQUEST AND RPCCCAL TO SEND IT TO THE SERVER SYSTEM. 
*              WHEN COMPLETE, RETURN ANY ERROR STATUS THAT ENCOUNTERED
*              BY THE RPC OR PORTMAPPER ROUTINES AND DELETE THE RPC 
*              CLIENT HANDLE. 
# 
  
# 
****  PROC SSISACR - XREF LIST. 
# 
  
      XREF
        BEGIN 
        PROC RPCCCAL;    # ISSUE RPC CLIENT CALL                       #
        PROC RPCCDES;    # DELETE RPC CLIENT HANDLE                    #
        PROC RPCCUDP;    # CREATE UDP CLIENT HANDLE                    #
        PROC SSIDDIS;    # DEBUG DISPLAY                               #
        PROC SSIRPSR;    # RECEIVE PORTMAPPER SERVER REQUEST           #
        PROC XDRINT;     # CONVERT INTEGER TO XDR FORMAT               #
        PROC XDRSTR;     # CONVERT STRING TO XDR FORMAT                #
        END 
  
      ITEM COMMAND             I;      # COMMAND TO ISSUE              #
      ITEM RETCODE             I;      # ERROR STATUS                  #
  
      ITEM COMMANDWRDS         I;      # NUMBER OF WORDS IN CMD REQUEST#
      ITEM INLEN               I;      # INPUT REPLY LENGTH            #
      ITEM INPOS               I;      # CURRENT REPLY BUFFER POSITION #
      ITEM LOOP                I;      # LOOP COUNTER                  #
      ITEM OUTLEN              I;      # REQUEST LENGTH                #
      ITEM RPCSTATUS   S:RPCSTAT;      # RPC RETURN STATUS CODE        #
      ITEM VOLSIZE             I;      # RETURN PARAMTER OF VOLID SIZE #
  
      BASED ARRAY CMDBASE [00:00] S(1);;
CONTROL EJECT;
  
# 
****  START MAIN PROCEDURE
# 
  
      SSIRPSR (RETCODE);               # CHECK PORTMAPPER              #
      IF (RETCODE NQ NOERROR$)
      THEN
        RETURN; 
  
      IF COMMAND GR LASTCOMMAND$
      THEN
        BEGIN                          # INVALID CALL                  #
        RETCODE = INTERNERR$; 
        RETURN; 
        END 
  
  
      P<IP$ADDR$REC> = LOC (WRKSTADDR [0]); 
      IP$UDPORT [0] = 0;
      RPCSTATUS = S"RPCTIMEOUT";
      FOR LOOP = 1 STEP 1 
      WHILE (RPCSTATUS EQ S"RPCTIMEOUT") AND
            (LOOP LQ RETRYCOUNT$) 
      DO                               # REISSUE CALL IF NO ACK        #
        RPCCUDP (CLNT$HANDLE, WRKSTADDR [0], CSI$PROGRAM, CSI$UDPVER, 
                (ACKWAIT$), CLNT$SOCKET, RPCSTATUS);
  
      IF RPCSTATUS EQ S"OK" 
      THEN
        BEGIN                          # BUILD AND ISSUE REQUEST       #
        MSG$COMMAND [REQUEST$] = CSI$COMMAND [COMMAND]; 
        MSG$MESOPT [REQUEST$] = 0;
        MSG$PACKID [REQUEST$] = REQ$ID [REQUEST$];
        CSI$XIDSEQ [REQUEST$] = CSI$XIDSEQ [REQUEST$] + 1;
        CSI$XIDPID [REQUEST$] = MAGNETID$;
        IF COMMAND EQ SERVERQUERY$
        THEN
          BEGIN 
          CSI$XIDPID [REQUEST$] = SSIID$; 
          MSG$PACKID [REQUEST$] = 1;
          END 
  
        IF COMMAND EQ FORCEDIS$ 
        THEN
          MSG$MESOPT [REQUEST$] = FORCEOPT$;
  
        MSG$EXTHDR [REQUEST$] = TRUE; # EXTENDED OPTION                #
        OUTLEN = 0; 
        XDRINT (OUTDATABUF [0], OUTLEN, CSI$HDR [REQUEST$], HDRSIZE$, 
                XDROPER"WRITE");
        XDRINT (OUTDATABUF [0], OUTLEN, MSG$HDR [REQUEST$], MSGSIZE$, 
                XDROPER"WRITE");
        XDRSTR (OUTDATABUF [0], OUTLEN, EXT$ACCESS [REQUEST$],
                VOLSIZE, XDROPER"WRITE"); 
        XDRSTR (OUTDATABUF [0], OUTLEN, EXT$ACCESS [REQUEST$],
                VOLSIZE, XDROPER"WRITE"); 
  
        IF COMMAND EQ SERVERQUERY$
        THEN
          BEGIN                        # SERVER QUERY ENTRIES          #
          CMD$TYPE [REQUEST$] = SERVER$;
          CMD$COUNT [REQUEST$] = 0; 
          COMMANDWRDS = QCMDSIZE$;
          P<CMDBASE> = LOC (CMD$TYPE [REQUEST$]); 
          END                          # SERVER QUERY ENTRIES          #
        ELSE
          BEGIN                        # MOUNT/DISMOUNT                #
          VOL$ID [REQUEST$] = REQ$VSN [REQUEST$]; 
          XDRSTR (OUTDATABUF [0], OUTLEN, VOL$HDR [REQUEST$], 
                  VOLSIZE, XDROPER"WRITE"); 
          CMD$CNTMNT [REQUEST$] = 1;
          CMD$ATS [REQUEST$] = REQ$ATS [REQUEST$];
          CMD$LSM [REQUEST$] = REQ$LSM [REQUEST$];
          CMD$PANEL [REQUEST$] = REQ$PANEL [REQUEST$];
          CMD$DRIVE [REQUEST$] = REQ$DRIVE [REQUEST$];
          IF COMMAND EQ MOUNT$
          THEN
            BEGIN                      # MOUNT                         #
            COMMANDWRDS = MCMDSIZE$;
            P<CMDBASE> = LOC (CMD$CNTMNT [REQUEST$]); 
            END                        # MOUNT                         #
          ELSE
            BEGIN                      # DISMOUNT                      #
            COMMANDWRDS = DCMDSIZE$;
            P<CMDBASE> = LOC (CMD$DRIVEID [REQUEST$]);
            END                        # DISMOUNT                      #
          END                          # MOUNT/DISMOUNT                #
  
        IF DFLAG
        THEN
          SSIDDIS (MSG$COMMAND [REQUEST$], DEBUGREQ$);
  
        XDRINT (OUTDATABUF [0], OUTLEN, CMDBASE [0],
                COMMANDWRDS, XDROPER"WRITE"); 
  
        RPCSTATUS = S"RPCTIMEOUT";
        FOR LOOP = 1 STEP 1 
        WHILE (RPCSTATUS EQ S"RPCTIMEOUT") AND
              (LOOP LQ RETRYCOUNT$) 
        DO                             # REISSUE CALL IF NO ACK        #
          RPCCCAL (CLNT$HANDLE, CSI$ACSLMPRC, OUTDATABUF [0], OUTLEN, 
                   INDATABUF [0], INPOS, INLEN, RPCSTATUS); 
  
        IF (RPCSTATUS EQ S"OK") AND 
           (COMMAND NQ SERVERQUERY$)
        THEN                           # CLEAR SUBSYSTEM INTERFACE WORD#
          REQ$WORD0 [REQUEST$] = 0; 
  
        RPCCDES (CLNT$HANDLE);
  
        IF RPCSTATUS EQ S"SOCKFAIL" 
        THEN                           # CLIENT SOCKET FAILED          #
          RETCODE = CSOCKFAIL$; 
  
        END                            # BUILD AND ISSUE REQUEST       #
  
      IF RETCODE EQ NOERROR$
      THEN
        RETCODE = RPC$ERR [RPCSTATUS];
  
      END                              # SSISACR                       #
  
      TERM
