Lecture Notes for Client-Server Interfaces

25 March 2003 - The Horrible Truth About RPC

The Three Faces of RPC

• The high level.

• The middle level.

• The low level.

• Trading off implicity vs. control.

  • Higher levels are simpler to set-up and use.

  • Lower levels provide more control over details.

  • Controling details provides better performance.

High-Level Access to RPC

• Simple but not necessarily efficient access to RPC facilities.

• Two sublevels of access.

  • RPC library routines are at the highest level.

  • The simplified API is the next highest level.

• Library routines do look just like subroutines.

  • Everything's hidden in the called routine.

  • No control what so ever.

  • At the mercy of the library (librpcsvc for sun).

  • Easy to write your own libraries.

• The simplified API are not subroutine like.

  • Not bound to whatever's in the library.

  • Still no control.

RPC Library Routines

• Most of the Sun RPC services are in the libaray.

  • Status, quotas, users, nfs access.

  • See /usr/include/rpcsvc for details.

• Does a system have a local disk?

  #include <stdio.h>
  #include <stdlib.h>
  #include <rpcsvc/rstat.h>
  
  int 
  main(int argc, char * argv[])
  
    const int dsk = havedisk(argv[1]);
    if (dsk < 0)
      cerr << "havedisk(" << argv[1] 
           << ") failed.\n"
      return EXIT_FAILURE
  
    cout << argv[1] 
         << (dsk ? "has" : "doesn't have")
         << " a disk.\n";
  

And Then. . .

$ make cc-high-rstat
g++ -c cc-high-rstat.cc -o cc-high-rstat.o
g++ -o cc-high-rstat cc-high-rstat.o -lrpcsvc

$ uname -a
SunOS clayton 5.7 Generic_106541-11 sun4u 
sparc SUNW,Ultra-5_10

$ cc-high-rstat cslab05
cslab05 has a disk.

$ cc-high-rstat clayton 
clayton has a disk.

$ cc-high-rstat starbase.se.monmouth.edu
starbase.se.monmouth.edu has a disk.

$ cc-high-rstat cslab00                 
havedisk(cslab00) failed.

$ rsh cslab00 ps -Af | grep -i rpc
  root  156    1  0 /usr/sbin/rpcbind
  root  186    1  0 /usr/lib/netsvc/yp/rpc.ypupdated
  root  171  169  0 rpc.nisd_resolv -F -C 8 
  root  667    1  0 /usr/sbin/rpc.bootparamd
  root  785  213  0 /usr/dt/bin/rpc.ttdbserverd

$ rsh cslab05 ps -Af | grep -i rpc
  root  105    1  0 /usr/sbin/rpcbind
  root  338  142  0 rpc.ttdbserverd
daemon  537  142  0 rpc.cmsd
  root 2835  142  0 rpc.rstatd

The Middle-Level API

• Provide arbitrary rpc services, not what's in the library.

  • Although you can call the library services too.

• Three procedures, one for the client and two for the server.

  • rpc_call() - make an rpc-service call.

  • rpc_reg() - register an rpc-service call.

  • rpc_run() - execute an rpc service.

• Rpc services at this level don't look like subroutine calls.

  • They can be wrapped, however.

The Client Middle-Level API

• Manually call the remote-user count rpc libary service.

  $ cat rusers.c
  #include <utmpx.h>
  #include <rpc/rpc.h>
  #include <rpcsvc/rusers.h>
  
  int main(int argc, char * argv[])
  
    unsigned int nusers
    const enum clnt_stat cs = 
      rpc_call(
        argv[1],          // host
        RUSERS_PROG,      // service
        RUSERS_VERS,      // version
        RUSERS_PROC_NUM,  // call
        xdr_void,         // marshal
        0,	        // input
        xdr_u_int,        // unmarshal
        (char *) &nusers, // output
        "visible")        // protocol
  
    if cs != RPC_SUCCESS
      clnt_perrno(cs)
      exit(EXIT_FAILURE)
  
    cout << nusers << " users on " 
         << argv[1]) << "\n"
  

Using the Client

$ gcc -o rusers rusers.c -lrpcsvc -lnsl

$ ./rusers cslab18
0 users on cslab18.

$ ./rusers cslab00
38 users on cslab00.

$ ./rusers enterprise.se.monmouth.edu
RPC: Program/version mismatch

$ ./rusers rockhopper.monmouth.edu   
RPC: Program not registered

$ ./rusers moncol.monmouth.edu    
RPC: Program not registered

$ ./rusers bluehawk.monmouth.edu
RPC: Program/version mismatch

$ 

The Server Interface

• The server.

  #include <rpc/rpc.h>
  
  int main()
  
    const int e = 
      rpc_reg(
        ENCRYPT_SVR,    // service
        ENCRYPT_VER,    // version
        ENCRYPT_PROCNO, // call
        encrypt,        // procedure
        xdr_string,     // marshal
        xdr_string,     // unmarshal
        "visible")      // protocol
  
    if (e == -1)
      perror("rpc_reg() failed")
      exit(EXIT_FAILURE)
  
    svc_run()  /* Doesn't return. */
  

An Encrypt-Service Client

• The client.

  #include <utmpx.h>
  #include <rpc/rpc.h>
  #include <rpcsvc/rusers.h>
  
  int main(int argc, char * argv[])
  
    unsigned int nusers
    enum clnt_stat cs =
      rpc_call(
        argv[1],
        ENCRYPT_PROG,
        ENCRYPT_VERS,
        ENCRYPT_PROCNUM,
        xdr_string,
        (char *) &clear,
        xdr_u_int,
        (char *) &cypher,
        "visible")
  
    if cs != RPC_SUCCESS
      clnt_perrno(cs)
      exit(EXIT_FAILURE)
  

The Middle Level

#include <stdio.h>
#include <stdlib.h>
#define PORTMAP
#include <rpc/rpc.h>
#include <rpcsvc/rstat.h>
#include <rpc/xdr.h>

int main(int argc, char * argv[]) {

  if (argc != 2) {
    fprintf(stderr, "Command format is \"%s hostname\".\n", argv[0]);
    return EXIT_FAILURE;
    }

  int dsk;
  enum clnt_stat stat = callrpc(
    argv[1], RSTATPROG, RSTATVERS_VAR, RSTATPROC_HAVEDISK, 
    xdr_void, 0, xdr_u_long, &dsk);
  if (stat) {
    clnt_perrno(stat);
    return EXIT_FAILURE;
    }

  printf("%s %s a disk.\n", argv[1], dsk ? "has" : "doesn't have");

  return EXIT_SUCCESS;
  }

Fun with RPC

$ make cc-mid-rstat
g++    -c cc-mid-rstat.cc -o cc-mid-rstat.o
g++ -o cc-mid-rstat cc-mid-rstat.o -lnsl

$ cc-mid-rstat clayton
clayton has a disk.

$ cc-mid-rstat cslab05
cslab05 has a disk.

$ cc-mid-rstat starbase.se.monmouth.edu
RPC: Program/version mismatch

$ 

The Low Level

int main(int argc, char * argv[]) {

  struct hostent *hp;
  if ((hp = gethostbyname(argv[1])) == NULL) {
    fprintf(stderr, "can't get addr for %s\n",argv[1]);
    return EXIT_FAILURE;
    }

  int sock = RPC_ANYSOCK;
  struct timeval pertry_timeout, total_timeout;
  struct sockaddr_in server_addr;

  pertry_timeout.tv_sec = 3;
  pertry_timeout.tv_usec = 0;
  bcopy(hp->h_addr, (caddr_t)&server_addr.sin_addr, hp->h_length);
  server_addr.sin_family = AF_INET;
  server_addr.sin_port =  0;

  CLIENT *client = clntudp_create(&server_addr, RSTATPROG,
				  RSTATVERS_VAR, pertry_timeout, &sock);
  if (NULL == client) {
    clnt_pcreateerror("clntudp_create");
    return EXIT_FAILURE;
    }

  total_timeout.tv_sec = 20;
  total_timeout.tv_usec = 0;
  unsigned long dsk;
  enum clnt_stat stat = clnt_call(client, RSTATPROC_HAVEDISK,
				  (bool_t (*)(XDR *, void *)) xdr_void, 0,
				  xdr_u_long, (char *) &dsk, 
				  total_timeout);
  if (stat != RPC_SUCCESS) {
    clnt_perror(client, "rpc");
    return EXIT_FAILURE;
    }

  printf("%s %s a disk.\n", argv[1], dsk ? "has" : "doesn't have");

  clnt_destroy(client);
  close(sock);

  return EXIT_SUCCESS;
  }

Just Checking

$ cc-low-rstat cslab05
cslab05 has a disk.

$ cc-low-rstat cslab00
clntudp_create: RPC: Program not registered

$ cc-low-rstat starbase.se.monmouth.edu
rpc: RPC: Program/version mismatch; low version = 1, high version = 3

$ 

Why Three Levels?

• The high level.

  • Where the RPC benefits lie.

• The low level.

  • Complete control - transport, timing.

• The middle level.

  • Where the other two levels meet.

The Server Side

• The server only has one level - low.

This page last modified on 2 March 2002.