The RPC Intermediate Layer

The calls of the RPC intermediate layer are:

Routine

Description

RegistersaprocedurewiththelocalPortmapper

Callsaremoteprocedureonthespecifiedsystem

AcceptsRPCrequestsandcallstheappropriateserviceusingsvc _ getreq ( )

The transport mechanism is the User Datagram Protocol (UDP). The UDP transport mechanism handles only arguments and results that are less than 8K bytes in length. At this level, RPC does not allow timeout specifications, choice of transport, or process control, in case of errors. If you need this kind of control, consider the lowest layer of RPC.

With only these three RPC calls, you can write a powerful RPC-based network application. The sequence of events follows:

• Use the registerrpc() call to register your remote program with the local Portmapper. See Portmapper for more information. The following is an example of an RPC server:

  /* define remote program number and version */
  
  #define RMTPROGNUM (u_long)0x3fffffffL
  #define RMTPROGVER (u_long)0x1
  #define RMTPROCNUM (u_long)0x1
  
  #include <stdio.h>
  #include <rpc\rpc.h>
  

  main()
  {
   int *rmtprog();
  
   /* register remote program with Portmapper */
   registerrpc(RMTPROGNUM, RMTPROGVER, RMTPROCNUM, rmtprog,
   xdr_int, xdr_int);
   /* infinite loop, waits for RPC request from client */
   svc_run();
   printf("Error: svc_run should never reach this point \n");
   exit(1);
  }
  
  int *
  rmtprog(inproc)          /* remote program */
  int *inproc;
  
  {
  int *outproc;
  ...
   /* Process request */
  ...
   return (outproc);
  }
  

  The registerrpc() call registers a C procedure rmtprog, which corresponds to a given RPC procedure number.

  The registerrpc() call has six parameters:

  • The first three parameters are the program, version, and procedure numbers of the remote procedure to be registered.

  • The fourth parameter, rmtprog, is the name of the local procedure that implements the remote procedure.

  • The last two parameters, xdr_int, are the XDR filters for the remote procedure's arguments and results.
  After registering a procedure, the RPC server goes into an infinite loop waiting for a client request to service.

The RPC client uses callrpc() to make a service request to the RPC server. The following is an example of an RPC client using the callrpc() call:

/* define remote program number and version */

#define RMTPROGNUM (u_long)0x3fffffffL
#define RMTPROGVER (u_long)0x1
#define RMTPROCNUM (u_long)0x1

#include <stdio.h>
#include <rpc\rpc.h>

main()
{
  int inproc=100, outproc, rstat;

...

  /* service request to host RPCSERVER_HOST */
  if (rstat = callrpc("RPCSERVER_HOST", RMTPROGNUM,
              RMTPROGVER, RMTPROCNUM, xdr_int, (char *)&inproc,
              xdr_int, (char *)&outproc)!= 0)
     {
      clnt_perrno(rstat);   /* Why  callrpc() failed ? */
      exit(1);
     }
...

  }

The callrpc() call has eight parameters:

• The first is the name of the remote server machine.

• The next three parameters are the program, version, and procedure numbers.

• The fifth and sixth parameters are an XDR filter, and an argument to be encoded and passed to the remote procedure.

• The final two parameters are a filter for decoding the results returned by the remote procedure, and a pointer to the place where the procedure's results are to be stored.
You handle multiple arguments and results by embedding them in structures. The callrpc() call returns 0 if it succeeds, otherwise nonzero. The exact meaning of the returned code is in the <RPC\CLNT.H> header file and is an enum clnt_stat structure cast into an integer.