#include <rpc/rpc.h>
#include <rpcsvc/rusers.h>
#include <stdio.h>
 
/*
 * rnusers() サービスを
 * 呼び出すプログラム
 */
 
main(argc, argv)
	int argc;
 char **argv;
{
	int num;
 
 if (argc != 2) {
		fprintf(stderr, "usage: %s hostname¥n",
 					argv[0]);
		exit(1);
	}
 if ((num = rnusers(argv[1])) < 0) {
		fprintf(stderr, "error: rnusers¥n");
		exit(1);
	}
	fprintf(stderr, "%d users on %s¥n", num,
						argv[1] );
	exit(0);
} 

cc program.c -lrpcsvc -lnsl

int	0 or error code
rpc_call (  
       char				*host		/* サーバーホストの名前 */
       rpcprog_t		prognum 	/* サーバープログラム番号 */
       rpcvers_t		versnum		/* サーバーバージョン番号 */
       rpcproc_t		procnum		/* サーバー手続き番号 */
       xdrproc_t		inproc		/* 引数を符号化する XDR フィルタ */
       char 			*in			/* 引数へのポインタ */
       xdr_proc_t		outproc		/* 結果を復号化するフィルタ */
       char				*out		/* 結果を格納するアドレス */
       char				*nettype	/* トランスポートの選択 */
);

#include <stdio.h>
#include <utmpx.h>
#include <rpc/rpc.h>
#include <rpcsvc/rusers.h>
 
/*
 *RUSERSPROG RPC プログラムを呼び出すプログラム
 */
 
main(argc, argv)
	int argc;
	char **argv;
{
 unsigned int nusers;
	enum clnt_stat cs;
 
	if (argc != 2) {
		   fprintf(stderr, "usage: rusers hostname¥n");
 	   exit(1);
	}
	if( cs = rpc_call(argv[1], RUSERSPROG,
			 	RUSERSVERS,	RUSERSPROC_NUM, xdr_void,
 				(char *)0, xdr_u_int, (char *)&nusers,
                    "visible")  !=  RPC_SUCCESS )  {
		          clnt_perrno(cs);
 	          exit(1);
	           }
	fprintf(stderr, "%d users on %s¥n", nusers,
						argv[1] );
 exit(0);
}

rpc_reg (
      rpcprog_t		prognum			/* サーバープログラム番号 */
      rpcvers_t		versnum			/* サーバーバージョン番号 */
      rpcproc_t		procnum			/* サーバー手続き番号 */
      char				*procname 	/* 遠隔関数の名前 */
      xdrproc_t		inproc			/* 引数を符号化するフィルタ */
      xdrproc_t		outproc			/* 結果を復号化するフィルタ */
      char			 *nettype			/* トランスポートの選択 */
);

#include <stdio.h>
 #include <rpc/rpc.h>
 #include <rpcsvc/rusers.h>
 void *rusers();
 
 main()
 {
 	if(rpc_reg(RUSERSPROG, RUSERSVERS,
						RUSERSPROC_NUM, rusers,
 					xdr_void, xdr_u_int,
						"visible") == -1) {
 		fprintf(stderr, "Couldn't Register¥n");
 		exit(1);
 	}
 	svc_run();     /* この関数は値を戻さない */
 	fprintf(stderr, "Error: svc_run
						returned!¥n");
 	exit(1);
 }

xdr_int()

xdr_netobj()

xdr_u_long()

xdr_enum()

xdr_long()

xdr_float()

xdr_u_int()

xdr_bool()

xdr_short()

xdr_double()

xdr_u_short()

xdr_wrapstring()

xdr_char()

xdr_quadruple()

xdr_u_char()

xdr_void()

xdr_hyper()

xdr_u_hyper()

xdr_char()

xdr_int8_t()

xdr_u_char()

xdr_u_int8_t()

xdr_short()

xdr_int16_t()

xdr_u_short()

xdr_u_int16_t()

xdr_int()

xdr_int32_t()

xdr_u_int()

xdr_u_int32_t()

xdr_hyper()

xdr_int64_t()

xdr_u_hyper()

xdr_u_int64_t()

struct simple {
 	int a;
 	short b;
 } simple;

#include <rpc/rpc.h>
#include "simple.h"
 
bool_t
xdr_simple(xdrsp, simplep)
	XDR *xdrsp;
	struct simple *simplep;
{
 if (!xdr_int(xdrsp, &simplep->a))
		return (FALSE);
 if (!xdr_short(xdrsp, &simplep->b))
		return (FALSE);
 return (TRUE);
}

xdr_array()

xdr_bytes()

xdr_reference()

xdr_vector()

xdr_union()

xdr_pointer()

xdr_string()

xdr_opaque()

struct varintarr {
 	int *data;
 	int arrlnth;
 } arr;

bool_t
xdr_varintarr(xdrsp, arrp)
 XDR *xdrsp;
	struct varintarr *arrp;
{
 return(xdr_array(xdrsp, (caddr_t)&arrp->data,
		(u_int *)&arrp->arrlnth, MAXLEN,
		sizeof(int), xdr_int));
} 

int intarr[SIZE];
 
bool_t
xdr_intarr(xdrsp, intarr)
	XDR *xdrsp;
	int intarr[];
{
 return (xdr_vector(xdrsp, intarr, SIZE,
				sizeof(int),
xdr_int));
} 

struct finalexample {
	char *string;
 struct simple *simplep;
} finalexample;
 
bool_t
xdr_finalexample(xdrsp, finalp)
	XDR *xdrsp;
	struct finalexample *finalp;
{
 if (!xdr_string(xdrsp, &finalp->string,
			MAXSTRLEN))
 	return (FALSE);
	if (!xdr_reference( xdrsp, &finalp->simplep,
 		sizeof(struct simple), xdr_simple))
		return (FALSE);
 return (TRUE);
 
}

clnt_call()

clnt_destroy()

clnt_control()

clnt_perrno()

clnt_pcreateerror()

clnt_perror()

svc_destroy()

/* time_prot.h */
#include <rpc/rpc.h>
#include <rpc/types.h>
 
struct timev {
 int second;
	int minute;
	int hour;
};
typedef struct timev timev;
bool_t xdr_timev();
 
#define TIME_PROG 0x40000001
#define TIME_VERS 1
#define TIME_GET  1

#include <stdio.h>
#include "time_prot.h"
 
#define TOTAL (30)
/*
 * 時刻を返すサービスを呼び出すプログラム
 * 使用方法: calltime ホスト名
 */
main(argc, argv)
 int argc;
	char *argv[];
{
	struct timeval time_out;
	CLIENT *client;
	enum clnt_stat stat;
	struct timev timev;
	char *nettype;
 
	if (argc != 2 && argc != 3) {
		fprintf(stderr,"usage:%s host[nettype]¥n"
					,argv[0]);
		exit(1);
 }
	if (argc == 2)
		nettype = "netpath";		/* デフォルト */	
	else
		nettype = argv[2];
 client = clnt_create(argv[1], TIME_PROG,
									TIME_VERS, nettype);
	if (client == (CLIENT *) NULL) {
 	clnt_pcreateerror("Couldn't create client");
 	exit(1);
	}
	time_out.tv_sec = TOTAL;
 time_out.tv_usec = 0;
	stat = clnt_call( client, TIME_GET, 
 				xdr_void, (caddr_t)NULL,
					xdr_timev, (caddr_t)&timev,
 				time_out);
	if (stat != RPC_SUCCESS) {
 	clnt_perror(client, "Call failed");
		exit(1);
 }
	fprintf(stderr,"%s: %02d:%02d:%02d GMT¥n",
 			nettype timev.hour, timev.minute,
				timev.second);
 (void) clnt_destroy(client);
	exit(0);
}

struct timeval timeout;
timeout.tv_sec = 30;		/* 30 秒 */
timeout.tv_usec = 0;
 
client = clnt_create_timed(argv[1],
				TIME_PROG, TIME_VERS, nettype,
 			&timeout);
 

#include <stdio.h>
#include <rpc/rpc.h>
#include "time_prot.h"
 
static void time_prog();
 
main(argc,argv)
 int argc;
	char *argv[];
{
	int transpnum;
	char *nettype;
 
	if (argc > 2) {
 
	 fprintf(stderr, "usage: %s [nettype]¥n",
 					argv[0]);
		exit(1);
	}
 if (argc == 2)
		nettype = argv[1];
	else
 	nettype = "netpath";			/* デフォルト */
	transpnum =
svc_create(time_prog,TIME_PROG,TIME_VERS,nettype);
 if (transpnum == 0) {
		fprintf(stderr,"%s: cannot create %s service.¥n",
					argv[0], nettype);
 	exit(1);
	}
	svc_run();
}
 
/*
 * サーバーのディスパッチ関数
 */
static void
time_prog(rqstp, transp)
	struct svc_req *rqstp;
	SVCXPRT *transp;
{
 struct timev rslt;
	time_t thetime;
 
	switch(rqstp->rq_proc) {
		case NULLPROC:
			svc_sendreply(transp, xdr_void, NULL);
			return;
		case TIME_GET:
 		break;
		default:
			svcerr_noproc(transp);
 		return;
		}
	thetime = time((time_t *) 0);
 rslt.second = thetime % 60;
	thetime /= 60;
 rslt.minute = thetime % 60;
	thetime /= 60;
 rslt.hour = thetime % 24;
	if (!svc_sendreply( transp, xdr_timev, &rslt)) {
		svcerr_systemerr(transp);
	 }
}

svc_getargs( SVCXPRT_handle, XDR_filter, argument_pointer);
svc_freeargs( SVCXPRT_handle, XDR_filter argument_pointer );

#include <stdio.h>
#include <rpc/rpc.h>
#include <netconfig.h>		/* 構造体 netconfig を使用するため */
#include "time_prot.h"
 
#define TOTAL (30)
 
main(argc,argv)
	int argc;
	char *argv[];
{
	CLIENT *client;
	struct netconfig *nconf;
	char *netid;
 /* 以前のサンプルプログラムの宣言と同じ */
 
	if (argc != 3) {
 	fprintf(stderr, "usage: %s host netid¥n",
					argv[0]);
 	exit(1);
	}
	netid = argv[2];
 if ((nconf = getnetconfigent( netid)) ==
 
	    (struct netconfig *) NULL) {
		fprintf(stderr, "Bad netid type: %s¥n",
					netid);
		exit(1);
 }
	client = clnt_tp_create(argv[1], TIME_PROG,
 									TIME_VERS, nconf);
	if (client == (CLIENT *) NULL) {
		clnt_pcreateerror("Could not create client");
 	exit(1);
	}
	freenetconfigent(nconf);
 
	/* これ以降は以前のサンプルプログラムと同じ */
}

struct timeval timeout;
timeout.tv_sec = 30; /* 30 秒 */
timeout.tv_usec = 0;
 
client = clnt_tp_create_timed(argv[1], 
			TIME_PROG, TIME_VERS, nconf,
			&timeout);
 

/*
 * このプログラムは、サービスを呼び出したクライアントにグリニッチ標準時を
 * 返します。呼び出し方法: server netid
 */
#include <stdio.h>
#include <rpc/rpc.h>
#include <netconfig.h>    /* 構造体 netconfig を使用するため */
#include "time_prot.h"
 
static void time_prog();
 
main(argc, argv)
 int argc;
	char *argv[];
{
	SVCXPRT *transp;
	struct netconfig *nconf;
 
	if (argc != 2) {
		fprintf(stderr, "usage: %s netid¥n",
 				argv[0]);
		exit(1);
	}
 if ((nconf = getnetconfigent( argv[1])) ==
					(struct netconfig *) NULL) {
		fprintf(stderr, "Could not find info on %s¥n",
 				argv[1]);
		exit(1);
	}
 transp = svc_tp_create(time_prog, TIME_PROG,
										TIME_VERS, nconf);
	if (transp == (SVCXPRT *) NULL) {
 	fprintf(stderr, "%s: cannot create 
						%s service¥n", argv[0], argv[1]);
		exit(1)
	}
	freenetconfigent(nconf);
 svc_run();
}
 
	static
 void time_prog(rqstp, transp)
		struct svc_req *rqstp;
 	SVCXPRT *transp;
{
/* トップレベルの RPC を使用したコードと同じ */
 

#include <stdio.h>
#include <rpc/rpc.h>
#include <netconfig.h>
#include <netinet/in.h>
/*
 * 旧バージョンの RPC では、TCP/IP と UDP/IP だけがサポートされていました。 
 * 現バージョンの clntudp_create() は TLI/STREAMS に基づいています。
 */
CLIENT *
clntudp_create(raddr, prog, vers, wait, sockp)
 struct sockaddr_in *raddr;		/* 遠隔アドレス */
	rpcprog_t prog;	 				/* プログラム番号 */
	prcvers_t vers;						/* バージョン番号 */
 struct timeval wait;				/* 待ち時間 */
	int *sockp;								/* ファイル記述子 (fd) のポインタ */
{
	CLIENT *cl;								/* クライアントハンドル */
 int madefd = FALSE;					/* fd はオープンされているか */
	int fd = *sockp; 					/* TLI の fd */
	struct t_bind *tbind;				/* 結合アドレス */
 struct netconfig *nconf;			/* netconfig 構造体 */
	void *handlep;
 
	if ((handlep = setnetconfig() ) == (void *) NULL) {
		/* ネットワーク設定開始でのエラー */
		rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
 	return((CLIENT *) NULL);
	}
	/*
  * 非接続型で、プロトコルファミリが INET、名前が UDP の 
	 * トランスポートが見つかるまで探す。
  */
	while (nconf = getnetconfig( handlep)) {
 	if ((nconf->nc_semantics == NC_TPI_CLTS) &&
		     (strcmp( nconf->nc_protofmly, NC_INET ) == 0) &&
 	     (strcmp( nconf->nc_proto, NC_UDP ) == 0))
		 break;
 }
	if (nconf == (struct netconfig *) NULL)
 	rpc_createerr.cf_stat = RPC_UNKNOWNPROTO;
		goto err;
 }
	if (fd == RPC_ANYFD) {
		fd = t_open(nconf->nc_device, O_RDWR, &tinfo);
		if (fd == -1) {
			rpc_createerr.cf_stat = RPC_SYSTEMERROR;
			goto err;
		}
 }
	if (raddr->sin_port == 0) { /* 未知の遠隔アドレス */
 	u_short sport;
		/*
		 * ユーザー作成のルーチン rpcb_getport() は rpcb_getaddr を呼び出して、
		 * netbuf アドレスをホストのバイト順序に従ってポート番号に変換する
 	 */
		sport = rpcb_getport(raddr, prog, vers, nconf);
 	if (sport == 0) {
			rpc_createerr.cf_stat = RPC_PROGUNAVAIL;
 		goto err;
		}
		raddr->sin_port = htons(sport);
 }
	/* sockaddr_in を netbuf に変換 */
	tbind = (struct t_bind *) t_alloc(fd, T_BIND, T_ADDR);
	if (tbind == (struct t_bind *) NULL)
		rpc_createerr.cf_stat = RPC_SYSTEMERROR;
 	goto err;
	}
	if (t_bind->addr.maxlen < sizeof( struct sockaddr_in))
		goto err;
	(void) memcpy( tbind->addr.buf, (char *)raddr,
	               sizeof(struct sockaddr_in));
	tbind->addr.len = sizeof(struct sockaddr_in);
 /* fd を結合 */
	if (t_bind( fd, NULL, NULL) == -1) {
 	rpc_createerr.ct_stat = RPC_TLIERROR;
		goto err;
 }
	cl = clnt_tli_create(fd, nconf, &(tbind->addr), prog, vers,
	                      tinfo.tsdu, tinfo.tsdu);
 /* netconfig ファイルを閉じる */
	(void) endnetconfig( handlep);
 (void) t_free((char *) tbind, T_BIND);
	if (cl) {
 	*sockp = fd;
		if (madefd == TRUE) {
			/* fd はハンドルの破棄と同時に閉じる */
			(void)clnt_control(cl,CLSET_FD_CLOSE, (char *)NULL);
		}
		/* リトライ時間の設定 */
 	(void) clnt_control( l, CLSET_RETRY_TIMEOUT,
		                     (char *) &wait);
		return(cl);
 }
err:
	if (madefd == TRUE)
 	(void) t_close(fd);
	(void) endnetconfig(handlep);
 return((CLIENT *) NULL);
}

#include <stdio.h>
#include <rpc/rpc.h>
#include <netconfig.h>
#include <netinet/in.h>
 
SVCXPRT *
svcudp_create(fd)
	register int fd;
{
 struct netconfig *nconf;
	SVCXPRT *svc;
	int madefd = FALSE;
	int port;
	void *handlep;
 struct  t_info tinfo;
 
	/* どのトランスポートも使用不可の場合 */
 if ((handlep = setnetconfig() ) == (void *) NULL) {
		nc_perror("server");
 	return((SVCXPRT *) NULL);
	}
	/*
  * 非接続型で、プロトコルファミリが INET、名前が UDP の
	 * トランスポートが見つかるまで探す。
  */
	while (nconf = getnetconfig( handlep)) {
 	if ((nconf->nc_semantics == NC_TPI_CLTS) &&
		    (strcmp( nconf->nc_protofmly, NC_INET) == 0 )&&
		    (strcmp( nconf->nc_proto, NC_UDP) == 0 ))
			break;
 }
	if (nconf == (struct netconfig *) NULL) {
 	endnetconfig(handlep);
		return((SVCXPRT *) NULL);
 }
	if (fd == RPC_ANYFD) {
		fd = t_open(nconf->nc_device, O_RDWR, &tinfo);
		if (fd == -1) {
			(void) endnetconfig();
			return((SVCXPRT *) NULL);
 	}
		madefd = TRUE;
	} else
 	t_getinfo(fd, &tinfo);
	svc = svc_tli_create(fd, nconf, (struct t_bind *) NULL,
	                      tinfo.tsdu, tinfo.tsdu);
	(void) endnetconfig(handlep);
 if (svc == (SVCXPRT *) NULL) {
		if (madefd)
 		(void) t_close(fd);
		return((SVCXPRT *)NULL);
 }
	return (svc);
}

/*
 * 使用する変数 :
 * cl: CLIENT *
 * tinfo: struct t_info (t_open() または t_getinfo() からの戻り値)
 * svcaddr: struct netbuf *
 */
	switch(tinfo.servtype) {
		case T_COTS:
		case T_COTS_ORD:
 		cl = clnt_vc_create(fd, svcaddr,
			 prog, vers, sendsz, recvsz);
			break;
		case T_CLTS:
 		cl = clnt_dg_create(fd, svcaddr,
			 prog, vers, sendsz, recvsz);
			break;
		default:
 		goto err;
	}

/*
 * 使用する変数
 * xprt: SVCXPRT *
 */
switch(tinfo.servtype) {
 case T_COTS_ORD:
	case T_COTS:
		xprt = svc_vc_create(fd, sendsz, recvsz);
 
		break;
	case T_CLTS:
		xprt = svc_dg_create(fd, sendsz, recvsz);
 
	 break;
	default:
		goto err;
} 

svc_dg_enablecache(xprt, cache_size)
    SVCXPRT *xprt;
    unsigned int cache_size;

typedef struct {
	AUTH *cl_auth;								/* 認証情報 */
	struct clnt_ops {
		enum clnt_stat (*cl_call)();		/* 遠隔手続き呼び出し */
		void			(*cl_abort)();			/* 呼び出しの中止 */
		void			(*cl_geterr)();		/* 特定エラーコードの取得 */
 	bool_t			(*cl_freeres)();	/* 戻り値の解放*/
		void			(*cl_destroy)(); 	/* この構造体の破棄 */
		bool_t			(*cl_control)();	/* RPC の ioctl() */
	} *cl_ops;
	caddrt_t			cl_private;				/* プライベートに使用 */
	char			*cl_netid;					/* ネットワークトークン */
 char			*cl_tp;						/* デバイス名 */
} CLIENT;

typedef struct {
	struct			opaque_auth  ah_cred;
 struct			opaque_auth  ah_verf;
	union			des_block    ah_key;
 struct auth_ops {
		void		(*ah_nextverf)();
 	int		(*ah_marshal)();			/* nextverf とシリアライズ */
		int		(*ah_validate)(); 		/* 妥当性検査の確認 */
		int		(*ah_refresh)();			/* 資格のリフレッシュ */
 	void		(*ah_destroy)();			/* この構造体の破棄 */
	} *ah_ops;
 caddr_t ah_private;
} AUTH;

typedef struct {
	int			xp_fd;
#define xp_sock					xp_fd
	u_short xp_port;		/* 結合されたポート番号、旧形式 */
 struct xp_ops {
	    bool_t				(*xp_recv)();		/* 要求の受信 */
    enum xprt_stat (*xp_stat)();			/* トランスポートステータスの取得 */
	    bool_t				(*xp_getargs)();	/* 引数の取り出し */
	    bool_t				(*xp_reply)(); 	/* 応答の送信 */
	    bool_t				(*xp_freeargs)();		/* 引数に割り当てたメモリーの解放* */
	    void				(*xp_destroy)();		/* この構造体の破棄 */
 } *xp_ops;
	int		xp_addrlen;			/* 遠隔アドレスの長さ、旧形式 */
 char		*xp_tp;				/* トランスポートプロバイダのデバイス名 */
	char		*xp_netid; 		/* ネットワークトークン */
	struct netbuf  xp_ltaddr;		/* ローカルトランスポートアドレス */
	struct netbuf  xp_rtaddr;		/* 遠隔トランスポートアドレス */
 char				xp_raddr[16];	/* 遠隔アドレス、旧形式 */
	struct opaque_auth xp_verf;	/* raw 応答の確認 */
	caddr_t				xp_p1;		/* プライベート: svc ops で使用 */
	caddr_t				xp_p2;		/* プライベート: svc ops で使用 */
 caddr_t				xp_p3;		/* プライベート: svc lib で使用 */
} SVCXPRT;

xp_fd

ハンドルに結合したファイル記述子。複数のサーバーハンドルで 1 つのファイル記述子を共有できる 

xp_netid

トランスポートのネットワーク ID (たとえば、udp)。ハンドルはこのトランスポート上に作成される。xp_tp は、このトランスポートに結合したデバイス名

xp_ltaddr

サーバー自身の結合アドレス 

xp_rtaddr

RPC の呼び出し側アドレス (したがって、呼び出しのたびに変る) 

xp_netid xp_tp xp_ltaddr

svc_tli_create() のようなエキスパートレベルのルーチンで初期化される

xp_fd

xp_ops()

xp_p1()

xp_p2

xp_verf()

xp_tp()

xp_ltaddr

xp_rtaddr()

xp_netid()

/*
 * 数値を 1 増加させる簡単なプログラム
 */
 
#include <stdio.h>
#include <rpc/rpc.h>
#include <rpc/raw.h>
#define prognum 0x40000001
#define versnum 1
#define INCR 1
 
struct timeval TIMEOUT = {0, 0};
static void server();
 
main (argc, argv)
	int argc;
	char **argv;
{
 CLIENT *cl;
	SVCXPRT *svc;
	int num = 0, ans;
 int flag;
 
	if (argc == 2)
		num = atoi(argv[1]);
 	svc = svc_raw_create();
	if (svc == (SVCXPRT *) NULL) {
 	fprintf(stderr, "Could not create server handle¥n");
		exit(1);
 }
	flag = svc_reg( svc, prognum, versnum, server,
         (struct netconfig *) NULL );
    if (flag == 0) {
     fprintf(stderr, "Error: svc_reg failed.¥n");
	    exit(1);
 }
	cl = clnt_raw_create( prognum, versnum );
 if (cl == (CLIENT *) NULL) {
		clnt_pcreateerror("Error: clnt_raw_create");
 	exit(1);
	}
	if (clnt_call(cl, INCR, xdr_int, (caddr_t) &num, xdr_int,
	      (caddr_t) &ans, TIMEOUT)
   != RPC_SUCCESS) {
		clnt_perror(cl, "Error: client_call with raw");
		exit(1);
	}
	printf("Client: number returned %d¥n", ans);
	exit(0);
}
 
static void
server(rqstp, transp)
	struct svc_req *rqstp;
 SVCXPRT *transp;
{
	int num;
 
   fprintf(stderr, "Entering server procedure.¥n");
 
	switch(rqstp->rq_proc) {
		case NULLPROC:
			if (svc_sendreply( transp, xdr_void,
				(caddr_t) NULL) == FALSE) {
	 		fprintf(stderr, "error in null proc¥n");
				exit(1);
 		}
			return;
		case INCR:
 		break;
		default:
			svcerr_noproc(transp);
 		return;
	}
	if (!svc_getargs( transp, xdr_int, &num)) {
		svcerr_decode(transp);
		return;
 }
    fprintf(stderr, "Server procedure: about to increment.¥n");
 num++;
	if (svc_sendreply(transp, xdr_int, &num) == FALSE) {
		fprintf(stderr, "error in sending answer¥n");
 	exit (1);
	}
    fprintf(stderr, "Leaving server procedure.¥n");
} 

int __rpc_select_to_poll(int fdmax, fd_set *fdset,
 														struct pollfd *pollset)

int __rpc_dtbsize()

void
svc_run()
{
 int nfds;
	int dtbsize = __rpc_dtbsize();
	int i;
	struct pollfd svc_pollset[fd_setsize];
 
	for (;;) {
		/*
		 * 要求待ちするサーバー fd があるかどうかをチェック
 	 */
		nfds = __rpc_select_to_poll(dtbsize, &svc_fdset,
 	                            svc_pollset);
		if (nfds == 0)
 		break;	/* 要求待ちの fd がないので終了 */
 
		switch (i = poll(svc_pollset, nfds, -1)) {
		case -1:
	 	/*
			 * エラーが起こった場合は、poll() ではなく、シグナルハンドラなど
 		 *  外部イベントによるものと考えて、無視して継続する
			 */
		case 0:
			continue;
		default:
	 	svc_getreq_poll(svc_pollset, i);
		}
	}
}
 

/*
 * bcast.c: RPC ブロードキャストの使用例
 */
 
#include <stdio.h>
#include <rpc/rpc.h>
 
main(argc, argv)
 int argc;
	char *argv[];
{
	enum clnt_stat rpc_stat;
	rpcprog_t prognum;
	rpcvers_t vers;
	struct rpcent *re;
 
	if(argc != 3) {
		fprintf(stderr, "usage : %s RPC_PROG VERSION¥n", argv[0]);
		exit(1);
	}
	if (isdigit( *argv[1]))
		prognum = atoi(argv[1]);
	else {
		re = getrpcbyname(argv[1]);
		if (! re) {
			fprintf(stderr, "Unknown RPC service %s¥n", argv[1]);
 		exit(1);
		}
		prognum = re->r_number;
 }
	vers = atoi(argv[2]);
	rpc_stat = rpc_broadcast(prognum, vers, NULLPROC, xdr_void,
	           (char *)NULL, xdr_void, (char *)NULL, bcast_proc,
NULL);
	if ((rpc_stat != RPC_SUCCESS) && (rpc_stat != RPC_TIMEDOUT)) {
	 fprintf(stderr, "broadcast failed: %s¥n",
		         clnt_sperrno(rpc_stat));
 	exit(1);
	}
	exit(0);
}
 
 

bool_t
bcast_proc(res, t_addr, nconf)
 void *res;									/* 応答なし */
	struct t_bind *t_addr;					/* 応答したアドレス */
	struct netconfig *nconf;
{
 register struct hostent *hp;
	char *naddr;
 
	naddr = taddr2naddr(nconf, &taddr->addr);
	if (naddr == (char *) NULL) {
		fprintf(stderr,"Responded: unknown¥n");
 } else {
		fprintf(stderr,"Responded: %s¥n", naddr);
 	free(naddr);
	}
	return(FALSE);
} 

#include <stdio.h>
#include <rpc/rpc.h>
#include "windows.h"
 
main(argc, argv)
 int argc;
	char **argv;
{
	struct timeval total_timeout;
	register CLIENT *client;
 enum clnt_stat clnt_stat;
	char buf[1000], *s = buf;
 
	if ((client = clnt_create( argv[1], WINDOWPROG, WINDOWVERS,
	 						"circuit_v")) == (CLIENT *) NULL) {
		clnt_pcreateerror("clnt_create");
 	exit(1);
	}
 
	total_timeout.tv_sec = 20;
	total_timeout.tv_usec = 0;
	while (scanf( "%s", s ) != EOF) {
		if (clnt_call(client, RENDERSTRING, xdr_wrapstring, &s,
		   xdr_void, (caddr_t) NULL, total_timeout) != RPC_SUCCESS) {
			clnt_perror(client, "rpc");
			exit(1);
 	}
	}
 
	clnt_destroy( client );
 exit(0);
}

#include <stdio.h>
#include <rpc/rpc.h>
#include "windows.h"
 
main(argc, argv)
 int argc;
	char **argv;
{
	struct timeval total_timeout;
	register CLIENT *client;
 enum clnt_stat clnt_stat;
	char buf[1000], *s = buf;
 
	if ((client = clnt_create( argv[1], WINDOWPROG, WINDOWVERS,
	 							"circuit_v")) == (CLIENT *) NULL) {
		clnt_pcreateerror("clnt_create");
 	exit(1);
	}
	timerclear(&total_timeout);
 while (scanf("%s", s) != EOF)
		clnt_call(client, RENDERSTRING_BATCHED, xdr_wrapstring,
		           &s, xdr_void, (caddr_t) NULL, total_timeout);
	/* ここでパイプラインをフラッシュ*/
	total_timeout.tv_sec = 20;
	clnt_stat = clnt_call(client, NULLPROC, xdr_void,
          (caddr_t) NULL, xdr_void, (caddr_t) NULL,
total_timeout);
 if (clnt_stat != RPC_SUCCESS) {
		clnt_perror(client, "rpc");
 	exit(1);
	}
	clnt_destroy(client);
 exit(0);
}

#include <stdio.h>
#include <rpc/rpc.h>
#include "windows.h"
 
void
windowdispatch(rqstp, transp)
	struct svc_req *rqstp;
	SVCXPRT *transp;
{
 char    *s = NULL;
 
	switch(rqstp->rq_proc) {
 	case NULLPROC:
			if (!svc_sendreply( transp, xdr_void, NULL))
 			fprintf(stderr, "can't reply to RPC call¥n");
			return;
 	case RENDERSTRING:
			if (!svc_getargs( transp, xdr_wrapstring, &s)) {
				fprintf(stderr, "can't decode arguments¥n");
 			/* 呼び出し側にエラーを通知 */
				svcerr_decode(transp);
 			break;
			}
			/* 文字列 s を処理するコード */
 		if (!svc_sendreply( transp, xdr_void, (caddr_t) NULL))
	 		fprintf( stderr, "can't reply to RPC call¥n");
			break;
 	case RENDERSTRING_BATCHED:
			if (!svc_getargs(transp, xdr_wrapstring, &s)) {
				fprintf(stderr, "can't decode arguments¥n");
 			/* プロトコルエラーのため何も返さない */
				break;
			}
 		/* 文字列 s を処理するコード。ただし応答はしない。 */
			break;
 	default:
			svcerr_noproc(transp);
			return;
 }
	/* 引数の復号化で割り当てた文字列を解放 */
	svc_freeargs(transp, xdr_wrapstring, &s);
}

AUTH_NONE

デフォルト。認証は実行されない 

AUTH_SYS

UNIX オペレーティングシステムのプロセスアクセス権を基にした認証タイプ 

AUTH_SHORT

サーバーによっては効率向上のため AUTH_SYS の代わりに AUTH_SHORT を使用できる。AUTH_SYS 認証を使用するクライアントプログラムは、サーバーからの AUTH_SHORT 応答ベリファイアを受信できる。詳細は、付録 B 「RPC プロトコルおよび言語の仕様」 を参照

AUTH_DES

DES 暗号化技法を基にした認証タイプ 

AUTH_KERB

DES フレームワークを基にした Version 5 Kerberos 認証形式

clnt = clnt_create(host, prognum, versnum, nettype);

clnt->cl_auth = authnone_create();
 
 

/*
 * 認証データ
 */
struct opaque_auth {
   enum_t    oa_flavor;		/* 資格スタイル */
   caddr_t   oa_base;			/* より詳細な認証データのアドレス */
   u_int     oa_length; 	/* 最大 MAX_AUTH_BYTES まで */
};

clnt->cl_auth = authsys_create_default();

/*
 * AUTH_SYS タイプの資格
 */
struct authsys_parms {
	u_long aup_time;					/* 資格作成時刻 */
 char *aup_machname;				/* クライアント側のホスト名 */
	uid_t aup_uid;	 				/* クライアント側の実効 uid */
	gid_t aup_gid;						/* クライアント側の現在のグループ ID */
	u_int aup_len;						/* aup_gids の配列の長さ */
 gid_t *aup_gids;					/* ユーザーが所属するグループの配列 */
};

nuser(rqstp, transp)
	struct svc_req *rqstp;
 SVCXPRT *transp;
{
	struct authsys_parms *sys_cred;
 uid_t uid;
	unsigned int nusers;
 
	/* NULLPROC の場合は認証データなし */
	if (rqstp->rq_proc == NULLPROC) {
 	if (!svc_sendreply( transp, xdr_void, (caddr_t) NULL))
		 fprintf(stderr, "can't reply to RPC call¥n");
		return;
 }
 
	/* ここで uid を取得 */
	switch(rqstp->rq_cred.oa_flavor) {
		case AUTH_SYS:
			sys_cred = (struct authsys_parms *) rqstp->rq_clntcred;
			uid = sys_cred->aup_uid;
 		break;
		default:
			svcerr_weakauth(transp);
 		return;
	}
	switch(rqstp->rq_proc) {
 	case RUSERSPROC_1:
			/* 呼び出し側が、この手続きの呼び出し資格を持っているかどうか確認 */
 		if (uid == 16) {
				svcerr_systemerr(transp);
 
	 		return;
			}
			/*
			 * ユーザー数を求めて変数 nusers に設定するコード
			 */
			if (!svc_sendreply( transp, xdr_u_int, &nusers))
				fprintf(stderr, "can't reply to RPC call¥n");
			return;
		default:
 		svcerr_noproc(transp);
			return;
	}
} 

cl->cl_auth = authdes_seccreate(servername, 60, server,
 					       (char *)NULL);
 

char servername[MAXNETNAMELEN];
host2netname(servername, server, (char *)NULL);

char servername[MAXNETNAMELEN];
user2netname(servername, serveruid(), (char *)NULL);

#include <rpc/rpc.h>
	...
 ...
nuser(rqstp, transp)
	struct svc_req *rqstp;
 SVCXPRT *transp;
{
	struct authdes_cred *des_cred;
 uid_t uid;
	gid_t gid;
	int gidlen;
 gid_t gidlist[10];
 
	/* NULLPROC の場合は認証データなし */
 if (rqstp->rq_proc == NULLPROC) {
		/* 元のプログラムと同じ */
 }
	/* ここで uid を取得 */
	switch(rqstp->rq_cred.oa_flavor) {
		case AUTH_DES:
			des_cred = (struct authdes_cred *) rqstp->rq_clntcred;
			if (! netname2user( des_cred->adc_fullname.name, &uid,
			                    &gid, &gidlen, gidlist)) {
				fprintf(stderr, "unknown user: %s¥n",
 			         des_cred->adc_fullname.name);
				svcerr_systemerr(transp);
 			return;
			}
			break;
		default:
 		svcerr_weakauth(transp);
			return;
	}
 /* 以降は元のプログラムと同じ */

xdr_type(object)

xdr_long(timestamp.seconds)
xdr_long(timestamp.useconds)
xdr_long(window)
xdr_long(window - 1)

CB0
CB1.low
CB1.high

xdr_long(AUTH_KERB)
xdr_long(length)
xdr_enum(AKN_FULLNAME)
xdr_bytes(ticket)
xdr_opaque(CB1.high) 

xdr_long(AUTH_KERB)
xdr_long(length)
xdr_opaque(CB0)
xdr_opaque(CB1.low) 

xdr_long(timestamp.seconds)
xdr_long(timestamp.useconds) 

xdr_long(AUTH_KERB)
xdr_long(length)
xdr_enum(AKN_NICKNAME)
xdr_opaque(akc_nickname)
 

xdr_long(AUTH_KERB)
xdr_long(length)
xdr_opaque(ECB0)
xdr_opaque(0) 

 
CLIENT *clnt;						/* クライアントハンドル */
char server_host[] = "foo";
char service_name[] = "nfs@machine.eng.company.com";
char mech[] = "kerberosv5";
 
clnt = clnt_create(server_host, SERVER_PROG, SERV_VERS, "netpath");
clnt->clnt_auth = rpc_gss_seccreate(clnt, service_name, mech, ¥
															rpc_gss_svc_integrity, NULL, NULL, NULL);
 
. . .

 
rpc_gss_set_defaults(clnt->clnt_auth, rpc_gss_svc_privacy, qop);
 
. . .

typedef struct {
    uid_t   uid;          /* ユーザー ID */
    gid_t   gid;          /* グループ ID */
    short   gidlen;       
    git_t   *gidlist;     /* グループのリスト */
} rpc_gss_ucred_t;

 
typedef struct {
		u_int 					version;															/* RPCSEC_GSS プログラムバージョン */
		char									*mechanism;
		char 								*qop;
		rpc_gss_principal_t		*client_principal;		/* クライアント主体名 */
		char									*svc_principal;			 								/* サーバー主体名 */
		rpc_gss_service_t			service; 											/* プライバシ、完全性 enum */
} rpc_gss_rawcred_t;
 

static void server_prog(struct svc_req *rqstp, SVCXPRT *xprt)
{
		rpc_gss_ucred_t *ucred;
		rpc_gss_rawcred_t *rcred;
 
		if (rqst->rq_proq == NULLPROC) {
			svc_sendreply(xprt, xdr_void, NULL);
			return;
		}
		/*
		 * 他の全ての要求を認証する */
		 */
 
		switch (rqstp->rq_cred.oa_flavor) {
		case RPCSEC_GSS:
			/*
			 * 資格情報を取得する
			 */
			rpc_gss_getcred(rqstp, &rcred, &ucred, NULL);
			/*
			* 設定ファイルを参照してセキュリティパラメータを
			* 使用することでユーザーにアクセスが許可されている
			* ことを確認する
			*/
			if (!authenticate_user(ucred->uid, rcred->mechanism,
				rcred->qop, rcred->service)) {
				svcerr_weakauth(xprt);
				return;
			}
			break; 	/* ユーザーに許可する */
		default:
			svcerr_weakauth(xprt);
			return;
		} /* スイッチの終り */
 
		switch (rqstp->rq_proq) {
		case SERV_PROC1:
			. . .
		}
 
		/* 通常の要求処理 ; 応答を送る ... */
 
		return;
 
}

 
typedef struct {
 	bool_t 						locked;
		rpc_gss_rawcred_t		*raw_cred;
} rpc_gss_lock_t;

kerberos_v5   1.2.840.113554.1.2.2    gl/mech_krb5.so gl_kmech_krb5

transp = svc_tli_create(0, nconf, (struct t_bind *)NULL, 0, 0)

svc_reg(transp, PROGNUM, VERSNUM, dispatch,(struct netconfig *)NULL)

transp = svc_fd_create(0, recvsize, sendsize);

rpc_prog/vers endpoint_type rpc/proto flags user pathname args 

rpc_prog/vers

RPC プログラム名に / とバージョン番号 (またはバージョン番号の範囲) を付けたもの 

endpoint_type

dgram (非接続型ソケット)、stream (接続型ソケット)、tli (TLI 端点) のどれか

proto

サポートされているトランスポートすべてを意味する *、nettype、netid のどれか。または、nettype と netid をコンマで区切ったリスト 

flags

wait または nowait のどちらか

user

有効な passwd データベースに存在しているユーザー

pathname

サーバーデーモンへのフルパス名 

args

デーモンの呼び出し時に渡される引数 

rquotad/1 tli rpc/udp wait root /usr/lib/nfs/rquotad rquotad
 

pmadm -a -p pm_tag -s  svctag -i id -v vers  ¥
 
	-m `nlsadmin -c command -D -R prog:vers`

# pmadm -a -p tcp -s rusers -i root -v 4 ¥
 
-m `nlsadmin -c /usr/sbin/rpc.ruserd -D -R 100002:1`

# sacadm -k -p pmtag
# sacadm -s -p pmtag

if (!svc_reg(transp, RUSERSPROG, RUSERSVERS_ORIG, 
 					nuser, nconf))
{
	fprintf(stderr, "can't register RUSER service¥n");
	exit(1);
}
if (!svc_reg(transp, RUSERSPROG, RUSERSVERS_SHORT, nuser,
			 		nconf)) {
	fprintf(stderr, "can't register RUSER service¥n");
 exit(1);
}

void
nuser(rqstp, transp)
	struct svc_req *rqstp;
	SVCXPRT *transp;
{
 unsigned int nusers;
	unsigned short nusers2;
 switch(rqstp->rq_proc) {
		case NULLPROC:
	 	if (!svc_sendreply( transp, xdr_void, 0))
				fprintf(stderr, "can't reply to RPC call¥n");
			return;
		case RUSERSPROC_NUM:
			/*
			 * ユーザー数を求めて変数 nusers に設定するコード
			 */
		switch(rqstp->rq_vers) {
 		case RUSERSVERS_ORIG:
				if (! svc_sendreply( transp, xdr_u_int, &nusers))
					fprintf(stderr, "can't reply to RPC call¥n");
 			break;
			case RUSERSVERS_SHORT:
				nusers2 = nusers;
				if (! svc_sendreply( transp, xdr_u_short, &nusers2))
 				fprintf(stderr, "can't reply to RPC call¥n");
				break;
 	}
		default:
			svcerr_noproc(transp);
 		return;
	}
	return;
}

main()
{
	enum clnt_stat status;
 u_short num_s;
	u_int num_l;
	struct rpc_err rpcerr;
	int maxvers, minvers;
	CLIENT *clnt;
 
	clnt = clnt_create("remote", RUSERSPROG, RUSERSVERS_SHORT,
			             "datagram_v");
	if (clnt == (CLIENT *) NULL) {
 	clnt_pcreateerror("unable to create client handle");
		exit(1);
 }
	to.tv_sec = 10;							/* タイムアウト値を設定 */
	to.tv_usec = 0;
 
	status = clnt_call(clnt, RUSERSPROC_NUM, xdr_void,
	                  (caddr_t) NULL, xdr_u_short, 
                  (caddr_t)&num_s, to);
	if (status == RPC_SUCCESS) {			/* 最新バージョン番号が見つかった場合 */
		printf("num = %d¥n", num_s);
 	exit(0);
	}
	if (status != RPC_PROGVERSMISMATCH) {		/* その他のエラー */
		clnt_perror(clnt, "rusers");
 	exit(1);
	}
	/* 指定したバージョンがサポートされていない場合 */
 clnt_geterr(clnt, &rpcerr);
	maxvers = rpcerr.re_vers.high; 	/* サポートされている最新バージョン */
	minvers = rpcerr.re_vers.low;		/* サポートされている最も古いバージョン */
	if (RUSERSVERS_SHORT < minvers || RUSERSVERS_SHORT > maxvers)
{
			                       /* サポート範囲内にない場合 */
		clnt_perror(clnt, "version mismatch");
		exit(1);
	}
	(void) clnt_control(clnt, CLSET_VERSION, RUSERSVERS_ORIG);
	status = clnt_call(clnt, RUSERSPROC_NUM, xdr_void,
			 (caddr_t) NULL, xdr_u_int, (caddr_t)&num_l, to);
	if (status == RPC_SUCCESS)
 		               /* 識別できるバージョン番号が見つかった場合 */
		printf("num = %d¥n", num_l);
	else {
		clnt_perror(clnt, "rusers");
 	exit(1);
	}
}
 

SVCXPRT *
register_transient_prog(dispatch, program, version, netid)
	void (*dispatch)(); /* サービスディスパッチルーチン */
	rpcproc_t  *program;    /* 一時的な RPC 番号が返される */
 rpcvers_t version;     /* プログラムバージョン */
	char *netid;        /* トランスポート id */
{
	SVCXPRT  *transp;
 struct netconfig *nconf;
	rpcprog_t prognum;
 if ((nconf = getnetconfigent(netid)) == (struct netconfig
*)NULL)
 	return ((SVCXPRT *)NULL);
	if ((transp = svc_tli_create(RPC_ANYFD, nconf,
				(struct t_bind *)NULL, 0, 0)) == (SVCXPRT *)NULL) {
		freenetconfigent(nconf);
		return ((SVCXPRT *)NULL);
	}
	prognum = 0x40000000;
 while (prognum < 0x60000000 && svc_reg(transp, prognum,
version,
 								dispatch, nconf) == 0) {
		prognum++;
 }
	freenetconfigent(nconf);
	if (prognum >= 0x60000000) {
		svc_destroy(transp);
		return ((SVCXPRT *)NULL);
	}
	*program = prognum;
 return (transp);
}

$ cc rstat.c -lnsl -lthread

/* @(#)rstat.c 2.3 93/11/30 4.0 RPCSRC */
/*
 * w コマンドと同様の形式で、遠隔ホストのステータスを表示する簡単な
 * プログラム
 */
 
#include <thread.h>		/* スレッドインタフェースの定義 */
#include <synch.h>	/* 相互排他的ロックの定義 */
#include <stdio.h>
#include <sys/param.h>
#include <rpc/rpc.h>
#include <rpcsvc/rstat.h>
#include <errno.h>
 
mutex_t tty;					/* printf のための tty の制御 */
cond_t cv_finish;
int count = 0;
 
main(argc, argv)
int argc;
char **argv;
{
 int i;
	thread_t tid;
	void *do_rstat();
 
	if (argc < 2) {
		fprintf(stderr, "usage: %s ¥"host¥" [...]¥n", argv[0]);
		exit(1);
	}
 
	mutex_lock(&tty);
 
	for (i = 1; i < argc; i++) {
		if (thr_create(NULL, 0, do_rstat, argv[i], 0, &tid) < 0) {
			fprintf(stderr, "thr_create failed: %d¥n", i);
			exit(1);
		} else
 		fprintf(stderr, "tid: %d¥n", tid);
	}
 
	while (count < argc-1) {
		printf("argc = %d, count = %d¥n", argc-1, count);
		cond_wait(&cv_finish, &tty);
 
	}
 
	exit(0);
}
 
bool_t rstatproc_stats();
 
void *
do_rstat(host)
char *host;
{
 CLIENT *rstat_clnt;
 statstime host_stat;
	bool_t rval;
	struct tm *tmp_time;
	struct tm host_time;
 struct tm host_uptime;
	char days_buf[16];
 char hours_buf[16];
 
	mutex_lock(&tty);
 printf("%s: starting¥n", host);
	mutex_unlock(&tty);
 
	/* rstat クライアントハンドル */
	rstat_clnt = clnt_create(host, RSTATPROG, RSTATVERS_TIME,
							"udp");
 if (rstat_clnt == NULL) {
		mutex_lock(&tty);				/* ty の制御権を取得 */
		clnt_pcreateerror(host);
		count++;
 	cond_signal(&cv_finish);
		mutex_unlock(&tty);	/* tty の制御権を解放 */
 
		thr_exit(0);
 
	}
 
	rval = rstatproc_stats(NULL, &host_stat, rstat_clnt);
	if (!rval) {
		mutex_lock(&tty);	/* tty の制御権を取得 */
 	clnt_perror(rstat_clnt, host);
		count++;
 	cond_signal(&cv_finish);
		mutex_unlock(&tty);	/* tty の制御権を解放 */
 
		thr_exit(0);
 
	}
 
	tmp_time = localtime_r(&host_stat.curtime.tv_sec,
                       &host_time);
 
	host_stat.curtime.tv_sec = host_stat.boottime.tv_sec;
 
	tmp_time = gmtime_r(&host_stat.curtime.tv_sec,
                    &host_uptime);
 
	if (host_uptime.tm_yday != 0)
		sprintf(days_buf, "%d day%s, ", host_uptime.tm_yday,
 	         (host_uptime.tm_yday > 1) ? "s" : "");
 else
		days_buf[0] = '¥0';
 
	if (host_uptime.tm_hour != 0)
		sprintf(hours_buf, "%2d:%02d,",
 		host_uptime.tm_hour, host_uptime.tm_min);
 
	else if (host_uptime.tm_min != 0)
		sprintf(hours_buf, "%2d mins,", host_uptime.tm_min);
	else
 
	 hours_buf[0] = '¥0';
 
	mutex_lock(&tty); /* tty の制御権を取得 */
	printf("%s: ", host);
 printf(" %2d:%02d%cm up %s%s load average: %.2f %.2f %.2f¥n",
 	(host_time.tm_hour > 12)  ? host_time.tm_hour - 12
 
	 : host_time.tm_hour,
		host_time.tm_min,
		(host_time.tm_hour >= 12) ? 'p'
		: 'a',
		days_buf,
 	hours_buf,
		(double)host_stat.avenrun[0]/FSCALE,
 	(double)host_stat.avenrun[1]/FSCALE,
		(double)host_stat.avenrun[2]/FSCALE);
 count++;
	cond_signal(&cv_finish);
	mutex_unlock(&tty); /* tty の制御権を解放 */
	clnt_destroy(rstat_clnt);
 
	sleep(10);
 thr_exit(0);
}
 
/* クライアント側の MT rstat プログラムの実行 */
/* clnt_control() を使用してデフォルトのタイムアウトを変更可能 */
static struct timeval TIMEOUT = { 25, 0 };
 
bool_t
rstatproc_stats(argp, clnt_resp, clnt)
	void *argp;
	statstime *clnt_resp;
 CLIENT *clnt;
{
 
	memset((char *)clnt_resp, 0, sizeof (statstime));
	if (clnt_call(clnt, RSTATPROC_STATS,
 	(xdrproc_t) xdr_void, (caddr_t) argp,
		(xdrproc_t) xdr_statstime, (caddr_t) clnt_resp,
		TIMEOUT) != RPC_SUCCESS) {
 	return (FALSE);
 
	}
	return (TRUE);
}
 

RPC_SVC_MTMODE_SET()

マルチスレッドモードの設定 

RPC_SVC_MTMODE_GET()

マルチスレッドの取得 

RPC_SVC_THRMAX_SET()

最大スレッド数の設定 

RPC_SVC_THRMAX_GET()

最大スレッド数の取得 

RPC_SVC_THRTOTAL_GET ()

現在アクティブなスレッドの合計数 

RPC_SVC_THRCREATES_GET()

RPC ライブラリ作成のスレッドの累積数 

RPC_SVC_THRERRORS_GET()

RPC ライブラリ内の thr_create エラー数

$ cc time_svc.c -lnsl -lthread

		#include <stdio.h>
		#include <rpc/rpc.h>
 	#include <synch.h>
		#include <thread.h>
 	#include "time_prot.h"
 
		void time_prog();
 
	 main(argc, argv)
		int argc;
		char *argv[];
 	{
		int transpnum;
		char *nettype;
 	int mode = RPC_SVC_MT_AUTO;
		int max = 20;      /* スレッド最大数を 20 に設定 */
 
	 if (argc > 2) {
	 	fprintf(stderr, "usage: %s [nettype]¥n", argv[0]);
			exit(1);
 	}
 
		if (argc == 2)
			nettype = argv[1];
		else
			nettype = "netpath";
 
	 if (!rpc_control(RPC_SVC_MTMODE_SET, &mode)) {
			printf("RPC_SVC_MTMODE_SET: failed¥n");
			exit(1);
		}
 	if (!rpc_control(RPC_SVC_THRMAX_SET, &max)) {
			printf("RPC_SVC_THRMAX_SET: failed¥n");
			exit(1);
		}
 	transpnum = svc_create( time_prog, TIME_PROG, TIME_VERS,
 			nettype);
 
		if (transpnum == 0) {
 		fprintf(stderr, "%s: cannot create %s service.¥n",
			argv[0], nettype);	
			exit(1);
		}
	 svc_run();
	}
 
	/*
  * サーバーのディスパッチプログラムです。RPC サーバーライブラリは、
	 * サーバーのディスパッチャルーチン time_prog () を実行するスレッドを
	 * 作成します。RPC ライブラリがスレッドを廃棄した後に行われます。
  */
 
	static void
	time_prog(rqstp, transp)
		struct svc_req *rqstp;
		SVCXPRT *transp;
 {
 
		switch (rqstp->rq_proc) {
 		case NULLPROC:
				svc_sendreply(transp, xdr_void, NULL);
 			return;
			case TIME_GET:
				dotime(transp);
 			break;
			default:
				svcerr_noproc(transp);
 			return;
		}
	}
	dotime(transp)
 SVCXPRT *transp;
	{
	
		struct timev rslt;
		time_t thetime;
	
 	thetime = time((time_t *)0);
		rslt.second = thetime % 60;
 	thetime /= 60;
		rslt.minute = thetime % 60;
 	thetime /= 60;
		rslt.hour = thetime % 24;
 	if (!svc_sendreply(transp, xdr_timev,(caddr_t) &rslt)) {
 		svcerr_systemerr(transp);
		}
	}

		include <rpc/types.h>
 
	 struct timev {
			int second;
			int minute;
 		int hour;
		};
 
		typedef struct timev timev;
		bool_t xdr_timev();
 
	 #define TIME_PROG 0x40000001
		#define TIME_VERS 1
 	#define TIME_GET 1
 

	#define	SVC2_PROG 0x30000002
	#define	SVC2_VERS 1
	#define SVC2_PROC_ADD 1)
	#define SVC2_PROC_MULT 2
 
	struct intpair {
		u_short a;
		u_short b;
	};
 
	typedef struct intpair intpair;
 
	struct svc2_add_args {
		int argument;
		SVCXPRT *transp;
 };
 
	struct svc2_mult_args {
	 intpair mult_argument;
		SVCXPRT *transp;
	};
 
	extern bool_t xdr_intpair();
 
	#define NTHREADS_CONST 500

#define	 _REENTRANT
#include <stdio.h>
#include <rpc/rpc.h>
#include <sys/uio.h>
#include <netconfig.h>
#include <netdb.h>
#include <rpc/nettype.h>
#include <thread.h>
#include "rpc_test.h"
void *doclient();
int NTHREADS;
struct thread_info {
	thread_t client_id;
	int client_status;
};
struct thread_info save_thread[NTHREADS_CONST];
main(argc, argv)
 int argc;
	char *argv[];
{
	int index, ret;
	int thread_status;
	thread_t departedid, client_id;
	char *hosts;
	if (argc < 3) {
 	printf("Usage: do_operation [n] host¥n");
		printf("¥twhere n is the number of threads¥n");
		exit(1);
 } else
		if (argc == 3) {
			NTHREADS = NTHREADS_CONST;
 		hosts = argv[1];  /* live_host */
		} else {
 		NTHREADS = atoi(argv[1]);
			hosts = argv[2];
 	}
	for (index = 0; index < NTHREADS; index++){
 	if (ret = thr_create(NULL, NULL, doclient,
		(void *)  hosts, THR_BOUND, &client_id)){
			printf("thr_create failed: return value %d", ret);
			printf(" for %dth thread¥n", index);
 		exit(1);
		}
		save_thread[index].client_id = client_id;
	}
	for (index = 0; index < NTHREADS; index++){
		if (thr_join(save_thread[index].client_id, &departedid,	
		(void *)
		&thread_status)){
 		printf("thr_join failed for thread %d¥n",
			save_thread[index].client_id);
 		exit(1);
		}
		save_thread[index].client_status = thread_status;
	}
}
	void *doclient(host)
 char *host;
{
	struct timeval tout;
 enum clnt_stat test;
	int result = 0;
	u_short mult_result = 0;
	int add_arg;
	int EXP_RSLT;
 intpair pair;
	CLIENT *clnt;
	if ((clnt = clnt_create(host, SVC2_PROG, SVC2_VERS, "udp"
==NULL) {
		clnt_pcreateerror("clnt_create error: ");
		thr_exit((void *) -1);
	}
 tout.tv_sec = 25;
	tout.tv_usec = 0;
	memset((char *) &result, 0, sizeof (result));
	memset((char *) &mult_result, 0, sizeof (mult_result));
	if (thr_self() % 2){
 	EXP_RSLT = thr_self() + 1;
		add_arg = thr_self();
 	test = clnt_call(clnt, SVC2_PROC_ADD, (xdrproc_t) xdr_int,
 	(caddr_t) &add_arg, (xdrproc_t) xdr_int, (caddr_t) &result,
 	tout);
	} else {
		pair.a = (u_short) thr_self();
 	pair.b = (u_short) 1;
		EXP_RSLT = pair.a * pair.b;
 	test = clnt_call(clnt, SVC2_PROC_MULT, (xdrproc_t)
		xdr_intpair,
 	(caddr_t) &pair, (xdrproc_t) xdr_u_short,
		(caddr_t) &mult_result, tout);
		result = mult_result;
 }
	if (test != RPC_SUCCESS) {
		printf("THREAD: %d clnt_call hav
		thr_exit((void *) -1);
	};
 thr_exit((void *) 0);
}
 

#define 	_REENTRANT
#include <stdio.h>
#include <rpc/rpc.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/uio.h>
#include <signal.h>
#include <thread.h>
#include "operations.h"
 
SVCXPRT *xprt;
void add_mult_prog();
void *svc2_add_worker();
void *svc2_mult_worker();
main(argc, argv)
	int argc;
 char **argv;
{
	int transpnum;
 char *nettype;
	int mode = RPC_SVC_MT_USER;
       if(rpc_control(RPC_SVC_MTMODE_SET,&mode) == FALSE){
                printf(" rpc_control is failed to set AUTO mode¥n");
                exit(0);
        }
	if (argc > 2) {
		fprintf(stderr, "usage: %s [nettype]¥n", argv[0]);
 	exit(1);
	}
	if (argc == 2)
 	nettype = argv[1];
	else
		nettype = "netpath";
 transpnum = svc_create(add_mult_prog, SVC2_PROG,
 	SVC2_VERS, nettype);
	if (transpnum == 0) {
		fprintf(stderr, "%s: cannot create %s service.¥n", argv[0],
 		nettype);
 	exit(1);
	}
	svc_run();
}
void add_mult_prog (rqstp, transp)
	struct svc_req *rqstp;
 SVCXPRT *transp;
{
	int argument;
 u_short mult_arg();
	intpair mult_argument;
 bool_t (*xdr_argument)();
	struct svc2_mult_args *sw_mult_data;
 struct svc2_add_args *sw_add_data;
	int ret;
 thread_t worker_id;
	switch (rqstp->rq_proc){
 	case NULLPROC:
			svc_sendreply(transp, xdr_void, (char *) 0);
			svc_done(transp);
			break;
 	case SVC2_PROC_ADD:
			xdr_argument = xdr_int;
 		(void) memset((char *) &argument, 0, sizeof (argument));
 		if (!svc_getargs(transp, xdr_argument,
			(char *) &argument)){
 			printf("problem with getargs¥n");
				svcerr_decode(transp);
 			exit(1);
			}
			sw_add_data = (struct svc2_add_args *)
			malloc(sizeof (struct svc2_add_args));
 		sw_add_data->transp = transp;
			sw_add_data->argument = argument;
			if (ret = thr_create(NULL, THR_MIN_STACK + 16 * 1024,
			svc2_add_worker, (void *) sw_add_data, THR_DETACHED,
 			printf("SERVER: thr_create failed:");
				printf(" return value %d", ret);
				printf(" for add thread¥n");
 			exit(1);
			}
			break;
	 case SVC2_PROC_MULT:
			xdr_argument = xdr_intpair;
 		(void) memset((char *) &mult_argument, 0,
			sizeof (mult_argument));
 		if (!svc_getargs(transp, xdr_argument,
			(char *) &mult_argument)){
 			printf("problem with getargs¥n");
				svcerr_decode(transp);
 			exit(1);
			}
			sw_mult_data = (struct svc2_mult_args *)
			malloc(sizeof (struct svc2_mult_args));
 		sw_mult_data->transp = transp;
			sw_mult_data->mult_argument.a = mult_argument.a;
			sw_mult_data->mult_argument.b = mult_argument.b;
 		if (ret = thr_create(NULL, THR_MIN_STACK + 16 * 1024,
		 svc2_mult_worker, (void *) sw_mult_data, THR_DETACHED,
			&worker_id)){
 			printf("SERVER: thr_create failed:");
				printf("return value %d", ret);
				printf("for multiply thread¥n");
 			exit(1);
 
			break;
		default:
 		svcerr_noproc(transp);
			svc_done(transp);
 		break;
	}
}
 
u_short mult_arg();
int add_one();
void *svc2_add_worker(add_arg)
struct svc2_add_args *add_arg;
{	int *result;
	bool_t (*xdr_result)();
	xdr_result = xdr_int;
	result = *malloc(sizeof (int));
	*result = add_one(add_arg->argument);
 if (!svc_sendreply(add_arg->transp, xdr_result,
	(caddr_t) result)){
		printf("sendreply failed¥n");
	 svcerr_systemerr(add_arg->transp);
		svc_done(add_arg->transp);
 	thr_exit((void *) -1);
	}
	svc_done(add_arg->transp);
 thr_exit((void *) 0);
}
void *svc2_mult_worker(m_arg)
struct svc2_mult_args *m_arg;
{
	u_short *result;
 bool_t (*xdr_result)();
	xdr_result = xdr_u_short;
 result = (u_short *) malloc(sizeof (u_short));
	*result = mult_arg(&m_arg->mult_argument);
 if (!svc_sendreply(m_arg->transp, xdr_result,
	(caddr_t) result)){
 	printf("sendreply failed¥n");
		svcerr_systemerr(m_arg->transp);
 	svc_done(m_arg->transp);
		thr_exit((void *) -1);
 }
	svc_done(m_arg->transp);
	thr_exit((void *) 0);
}
u_short mult_arg(pair)
 intpair *pair;
{
	u_short result;
 result = pair->a * pair->b;
	return (result);}
int add_one(arg)
	int arg;
{
	return (++arg);
}
 

/*
 * XDR ルーチン:
 *      復号化時にネットワークを読み取り fp に書き込む
 *      符号化時に fp を読み取りネットワークに書き込む
 */
#include <stdio.h>
#include <rpc/rpc.h>
 
bool_t
xdr_rcp(xdrs, fp)
	XDR *xdrs;
	FILE *fp;
{
 unsigned long size;
	char buf[BUFSIZ], *p;
 
	if (xdrs->x_op == XDR_FREE)                 /* 解放するものなし */
		return(TRUE);
 while (TRUE) {
		if (xdrs->x_op == XDR_ENCODE) {
 		if ((size = fread( buf, sizeof( char ), BUFSIZ, fp))
			    == 0 && ferror(fp)) {
				fprintf(stderr, "can't fread¥n");
				return(FALSE);
			} else
 			return(TRUE);
		}
		p = buf;
 	if (! xdr_bytes( xdrs, &p, &size, BUFSIZ))
			return(0);
 	if (size == 0)
			return(1);
		if (xdrs->x_op == XDR_DECODE) {
			if (fwrite( buf, sizeof(char), size, fp) != size) {
				fprintf(stderr, "can't fwrite¥n");
 			return(FALSE);
			} else
				return(TRUE);
 	}
	}
}

/* 送信側のルーチン */
#include <stdio.h>
#include <netdb.h>
#include <rpc/rpc.h>
#include <sys/socket.h>
#include <sys/time.h>
#include "rcp.h"
 
main(argc, argv)
	int argc;
	char **argv;
{
	int xdr_rcp();
 
	if (argc != 2 7) {
		fprintf(stderr, "usage: %s servername¥n", argv[0]);
		exit(1);
	}
	if( callcots( argv[1], RCPPROG, RCPPROC, RCPVERS, xdr_rcp,
stdin,
 	  xdr_void, 0 ) != 0 )
		exit(1);
	exit(0);
}
 
callcots(host, prognum, procnum, versnum, inproc, in, outproc,
out)
 char *host, *in, *out;
	xdrproc_t inproc, outproc;
{
 enum clnt_stat clnt_stat;
	register CLIENT *client;
 struct timeval total_timeout;
 
	if ((client = clnt_create( host, prognum, versnum,
"circuit_v")
    == (CLIENT *) NULL)) {
		clnt_pcreateerror("clnt_create");
 	return(-1);
	}
	total_timeout.tv_sec = 20;
 total_timeout.tv_usec = 0;
	clnt_stat = clnt_call(client, procnum, inproc, in, outproc,
out,
	                       total_timeout);
	clnt_destroy(client);
 if (clnt_stat != RPC_SUCCESS)
		clnt_perror("callcots");
 return((int)clnt_stat);
}
 

/*
 * 受信側ルーチン
 */
#include <stdio.h>
#include <rpc/rpc.h
#include "rcp.h"
 
main()
{
 void  rcp_service();
	if (svc_create(rpc_service,RCPPROG,RCPVERS,"circuit_v") == 0) {
		fprintf(stderr, "svc_create: errpr¥n");
 	exit(1);
	}
	svc_run();                    /* この関数は戻らない */
	fprintf(stderr, "svc_run should never return¥n");
}
 
void
rcp_service(rqstp, transp)
	register struct svc_req *rqstp;
	register SVCXPRT *transp;
{
	switch(rqstp->rq_proc) {
 	case NULLPROC:
			if (svc_sendreply(transp, xdr_void, (caddr_t) NULL) == FALSE)
				fprintf(stderr, "err: rcp_service");
 		return;
		case RCPPROC:
			if (!svc_getargs( transp, xdr_rcp, stdout)) {
				svcerr_decode(transp);
 			return();
			}
			if(!svc_sendreply(transp, xdr_void, (caddr_t) NULL)) {
				fprintf(stderr, "can't reply¥n");
 			return();
			}
			return();
 	default:
			svcerr_noproc(transp);
			return();
 }
 
}

xdr_chararr1(xdrsp, chararr)
   XDR *xdrsp;
   char chararr[];
{
   char *p;
   int len;
 
   p = chararr;
   len = SIZE;
   return (xdr_bytes(xdrsp, &p, &len, SIZE));
} 

char chararr[SIZE];
 
svc_getargs(transp, xdr_chararr1, chararr);

xdr_chararr2(xdrsp, chararrp)
   XDR *xdrsp;
   char **chararrp;
{
 
  int len;
 
  len = SIZE;
  return (xdr_bytes(xdrsp, charrarrp, &len, SIZE));
}
 

char *arrptr;
arrptr = NULL;
svc_getargs(transp, xdr_chararr2, &arrptr);
/*
 * ここで戻り値を使用
 */
svc_freeargs(transp, xdr_chararr2, &arrptr);
 

clnt_create()  

svc_create() 

clnt_call() 

clnt_create_timed() 

clnt_tli_create()  

svc_tli_create() 

clnt_dg_create() 

svc_dg_create() 

clnt_vc_create() 

svc_vc_create() 

デフォルトのトランスポート選択 

TI-RPC では TLI インタフェースを使用する。 

TS-RPC ではソケットインタフェースを使用する。 

RPC アドレス結合 

TI-RPC ではサービスの結合に rpcbind() を使用する。rpcbind() はアドレスを汎用アドレス形式で扱う。

TS-RPC ではサービスの結合に portmap を使用する。

トランスポート情報  

トランスポート情報はローカルファイル /etc/netconfig に保存する。netconfig で指定したトランスポートはすべてアクセス可能になる。

トランスポートは TCP と UDP だけをサポートする。 

ループバックトランスポート  

rpcbind サービスではサーバー登録に安全なループバックトランスポートが必要。

TS-RPC サービスではループバックトランスポートは不要。 

ホスト名の解決 

TI-RPC のホスト名の解決順序は、/etc/netconfig で指定した動的ライブラリのエントリ順で決定される。

ホスト名の解決はネームサービスが実行する。順序は hosts データベースの状態で設定される。

ファイル記述子 

ファイル記述子は TLI 端点とみなす。 

ファイル記述子はソケットとみなす。 

rpcgen

TI-RPC の rpcgen では、複数引数、値渡し、サンプルクライアントとサンプルサーバーファイルのサポートを追加。

SunOS 4.1 と直前のリリースは TI-RPC rpcgen に対して一覧表示された特徴はサポートしない。

ライブラリ 

TI-RPC では、アプリケーションが libnsl ライブラリにリンクしていることを必要とする。

TS-RPC の機能はすべて libc で提供される。

マルチスレッドのサポート 

マルチスレッド RPC クライアントとサーバーがサポートされる。 

マルチスレッド RPC はサポートされない。 

	struct hostent *h;
	struct sockaddr_in sin;
 int sock = RPC_ANYSOCK;
	u_short port;
	struct timeval wait;
 
	if ((h = gethostbyname( "host" )) == (struct hostent *) NULL)
{
		syslog(LOG_ERR, "gethostbyname failed");
		exit(1);
	}
 sin.sin_addr.s_addr = *(u_int *) hp->h_addr;
	if ((port = pmap_getport(&sin, PROGRAM, VERSION, "udp")) == 0) {
	 syslog (LOG_ERR, "pmap_getport failed");
		exit(1);
 } else
		sin.sin_port = htons(port);
	wait.tv_sec = 25;
	wait.tv_usec = 0;
	clntudp_create(&sin, PROGRAM, VERSION, wait, &sock);

	struct netconfig *nconf;
	struct netconfig *getnetconfigent();
	struct t_bind *tbind;
 struct timeval wait;
 
	nconf = getnetconfigent("udp");
 if (nconf == (struct netconfig *) NULL) {
		syslog(LOG_ERR, "getnetconfigent for udp failed");
		exit(1);
 }
	fd = t_open(nconf->nc_device, O_RDWR, (struct t_info *)NULL);
 if (fd == -1) {
		syslog(LOG_ERR, "t_open failed");
 	exit(1);
	}
	tbind = (struct t_bind *) t_alloc(fd, T_BIND, T_ADDR);
	if (tbind == (struct t_bind *) NULL) {
 	syslog(LOG_ERR, "t_bind failed");
		exit(1);
 }
	if (rpcb_getaddr( PROGRAM, VERSION, nconf, &tbind->addr, "host")
								== FALSE) {
		syslog(LOG_ERR, "rpcb_getaddr failed");
		exit(1);
	}
 cl = clnt_tli_create(fd, nconf, &tbind->addr, PROGRAM, VERSION,
                       0, 0);
	(void) t_free((char *) tbind, T_BIND);
	if (cl == (CLIENT *) NULL) {
		syslog(LOG_ERR, "clnt_tli_create failed");
		exit(1);
	}
 wait.tv_sec = 25;
	wait.tv_usec = 0;
	clnt_control(cl, CLSET_TIMEOUT, (char *) &wait);
 

statstime sw;
extern int collectnames();
 
clnt_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS,         
    	xdr_void, NULL, xdr_statstime, &sw, collectnames);
	...
collectnames(resultsp, raddrp)
	char *resultsp;
	struct sockaddr_in *raddrp;
{
	u_int addr;
	struct entry *entryp, *lim;
	struct hostent *hp;
	extern int curentry;
 
	/* 重複アドレスはカット */
 addr = raddrp->sin_addr.s_addr;
	lim = entry + curentry;
 for (entryp = entry; entryp < lim; entryp++)
		if (addr == entryp->addr)
			return (0);
	...
 /* ホスト名がわかればホスト名、わからなければアドレスを表示 */
	hp = gethostbyaddr(&raddrp->sin_addr.s_addr, sizeof(u_int),
	    AF_INET);
	if( hp == (struct hostent *) NULL)
		printf("0x%x", addr);
	else
 	printf("%s", hp->h_name);
}
 

statstime sw;
extern int collectnames();
 
rpc_broadcast(RSTATPROG, RSTATVERS_TIME, RSTATPROC_STATS,
     xdr_void, NULL, xdr_statstime, &sw, collectnames, (char *)
0);
	...
collectnames(resultsp, taddr, nconf)
	char *resultsp;
	struct t_bind *taddr;
	struct netconfig *nconf;
{
 struct entry *entryp, *lim;
	struct nd_hostservlist *hs;
 extern int curentry;
	extern int netbufeq();
 
	/* 重複アドレスはカット */
	lim = entry + curentry;
	for (entryp = entry; entryp < lim; entryp++)
		if (netbufeq( &taddr->addr, entryp->addr))
			return (0);
 ...
	/* ホスト名がわかればホスト名、わからなければアドレスを表示 */
	if (netdir_getbyaddr( nconf, &hs, &taddr->addr ) == ND_OK)
 	printf("%s", hs->h_hostservs->h_host);
	else {
 	char *uaddr = taddr2uaddr(nconf, &taddr->addr);
		if (uaddr) {
			printf("%s¥n", uaddr);
			(void) free(uaddr);
 	} else
			printf("unknown");
	}
}
netbufeq(a, b)
	struct netbuf *a, *b;
{
	return(a->len == b->len && !memcmp( a->buf, b->buf, a->len));
}