ONC+ Developer's Guide

One-way call using a simple counter service

This section describes how to use a one-way procedure on a simple counter service. In this counter service the ADD() function is the only function available. Each remote call sends an integer and this integer is added to a global counter managed by the server. For this service, you must declare the oneway attribute in the RPC language definition.

In this example, you generate stubs using the -M, -N and -C rpcgen options. These options ensure that the stubs are multithread safe, accept multiple input parameters and that generated headers are ANSI C++ compatible. Use these rpcgen options even if the client and server applications are mono-threaded as the semantic to pass arguments is clearer and adding threads in applications is easier since the stubs do not change.

  1. First, you write the service description in the counter.x.

       /* counter.x: Remote counter protocol */
    program COUNTERPROG {
     	version COUNTERVERS {
     	  oneway ADD(int) = 1;
     	} = 1;
    } = 0x20000001;

    The service has a program number, (COUNTERPROG) 0x200000001, and a version number, (COUNTERVERS) 1.

  2. Next, call rpcgen on the counter.x file.

    rpcgen -M -N -C counter.x

    This call generates the client and server stubs, counter.h, counter_clnt.c and counter_svc.c.

  3. As shown in the server.c file below, write the service handler for the server side and the counterprog_1_freeresult() function used to free memory areas allocated to the handler. The RPC library calls this function when the server sends a reply to the client.

    	  #include <stdio.h>
    #include "counter.h"
    int counter = 0;
    add_1_svc(int number, struct svc_req *rqstp)
     	 bool_t retval = TRUE;
      	 counter = counter + number;
      	 return retval;
    counterprog_1_freeresult(SVCXPRT *transp, xdrproc_t xdr_result, caddr_t
     	 (void) xdr_free(xdr_result, result);
    		  * Insert additional freeing code here, if needed 
      	 return TRUE;

    You build the server by compiling and linking the service handler to the counter_svc.c stub. This stub contains information on the initialization and handling of TI-RPC.

  4. Next, you write the client application, client.c.

    	  #include <stdio.h>
    #include "counter.h"
    main(int argc, char *argv[])
     	 CLIENT *clnt;
     	 enum clnt_stat result;
     	 char *server;
     	 int number;
      	 if(argc !=3) {
     		  fprintf(stderr, "usage: %s server_name number\n", argv[0];
     	 server = argv[1];
     	 number = atoi(argv[2]);
    		  * Create client handle 
     	 clnt = clnt_create(server, COUNTERPROG, COUNTERVERS, "tcp");
      	 if(clnt == (CLIENT *)NULL) {
    		  * Couldn't establish connection 
      	 result = add_1(number, clnt);
     	 if (result !=RPC_SUCCESS) {
     		  clnt_perror(clnt, "call failed");

    The add_1() client function is the counter_clnt.c stub generated for the remote function.

    To build the client, compile and link the client main and the counter_clnt.c.

  5. To launch the server that you built, type ./server

  6. Finally, to invoke the service in another shell, type: ./client servername23.

    23 is the number being added to the global counter.