Lecture Notes for Client-Server Interfaces

28 February 2002 - 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[]) {
  
    int dsk;
    if ((dsk = havedisk(argv[1])) < 0) {
      fprintf(stderr, "havedisk(%s) failed.\n", argv[1]);
      return EXIT_FAILURE;
      }
  
    printf("%s %s a disk.\n", argv[1], 
           dsk ? "has" : "doesn't have");
    }
  

And Then. . .

cl 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

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

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

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

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

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

cl rsh cslab00 ps -Af | grep -i rpc
  root  156    1  0   Jan 29 ?   1:32 /usr/sbin/rpcbind
  root  186    1  0   Jan 29 ?   0:00 /usr/lib/netsvc/yp/rpc.ypupdated
  root  171  169  0   Jan 29 ?   5:57 rpc.nisd_resolv -F -C 8 
  root  667    1  0   Jan 29 ?   0:00 /usr/sbin/rpc.bootparamd
  root  785  213  0   Jan 29 ?   0:00 /usr/dt/bin/rpc.ttdbserverd

cl rsh cslab05 ps -Af | grep -i rpc
  root  105    1  0   Feb 12 ?   0:00 /usr/sbin/rpcbind
  root  338  142  0   Feb 12 ?   0:00 rpc.ttdbserverd
daemon  537  142  0   Feb 13 ?   0:00 rpc.cmsd
  root 2835  142  0 16:14:20 ?   0:00 rpc.rstatd

The High-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 High-Level API

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

  cl cat rusers.c
  #include <utmpx.h>
  #include <rpc/rpc.h>
  #include <rpcsvc/rusers.h>
  
  int main(int argc, char * argv[]) {
  
    unsigned int nusers;
    enum clnt_stat cs;
  
    cs = rpc_call(argv[1],
                  RUSERS_PROG,
                  RUSERS_VERS,
                  RUSERS_PROC_NUM,
                  xdr_void,
                  0,
                  xdr_u_int,
                  (char *) &nusers,
                  "visible");
    if (cs != RPC_SUCCESS) {
      clnt_perrno(cs);
      exit(EXIT_FAILURE);
      }
  
    printf("%d users on %s.\n", nusers, argv[1]);
    }
  

• Not like a subroutine call at all.

Using the Client

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

cl ./rusers cslab18
0 users on cslab18.

cl ./rusers cslab00
38 users on cslab00.

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

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

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

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

cl 

The Server High-Level Interface

• The server.

  #include <rpc/rpc.h>
  
  int main() {
    int e = rpc_reg(ENCRYPT_SVR,
                    ENCRYPT_VER,
                    ENCRYPT_PROCNO,
                    encrypt,
                    xdr_string,
                    xdr_string,
                    "visible");
    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;
  
    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
     
     
     
    
  
  cl 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
  
  cl cc-mid-rstat clayton
  clayton has a disk.
  
  cl cc-mid-rstat cslab05
  cslab05 has a disk.
  
  cl cc-mid-rstat starbase.se.monmouth.edu
  RPC: Program/version mismatch
  
  cl 
  
  
  
  
  
     
  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
     
     
     
    
  
  cl cc-low-rstat cslab05
  cslab05 has a disk.
  
  cl cc-low-rstat cslab00
  clntudp_create: RPC: Program not registered
  
  cl cc-low-rstat starbase.se.monmouth.edu
  rpc: RPC: Program/version mismatch; low version = 1, high version = 3
  
  cl 
  
  
  
  
  
     
  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.