標準インタフェース

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()