使用rpcgen构建分布式程序的一个简单例子

使用rpcgen构建分布式程序的一个简单例子

一. RPC概念

1.1 介绍

        在中间件的实现中，引入了远程过程调用RPC（Remote Procedure Call）的概念。同时，许多分布式系统是基于进程间的显式消息交换的，然而消息的发送和接收过程无法隐藏通信的存在，而通信的隐藏对于在分布式系统中实现访问透明性是极为重要的。因此这个问题在很长一段时间内都没有找到合适的解决办法，后来Birrel和Nelson在1984年的一篇论文中引入了一套与传统方法截然不同的通信处理手段。他们认为应该允许程序调用位于其它机器上的进程。当机器A上的进程调用B上的进程时，A上的调用进程被挂起，而B上的被调用进程开始执行。调用方可以通过使用参数将信息传送给被调用方，然后可以通过传回的结果得到信息。编程人员看不到任何消息传递过程。这种方法就称为远程过程调用RPC。目前，RPC作为一种广泛使用的技术，已成为许多分布式系统的基础。
1.2 构建分布式程序的两种模式
在设计分布式应用时，程序员可以使用下列两种方法之一：
面向通信的设计
        由通信协议开始。设计报文格式和语法，指明对每个传入报文将如何反应以及如何产生每个外发报文，以此来设计客户和服务器各构件。
面向应用的设计
        由应用开始。设计常规的应用程序来解决问题。构建并测试可在单台机器上运行的常规程序的工作版本。将这个程序划分成两个或多个程序片，加入通信协议以允许每片程序在单独的计算机上执行。
        远程过程调用模型使用面向应用的方法，它强调的是所要解决的问题而不是所需要的通信。利用远程过程调用，程序员首先设计一个解决问题的常规程序，接着将其划分成若赶干片，这些程序片运行在两台或更多的计算机上。程序员可遵循良好的设计原则，以便使代码模块化并且可维护。
        在理想的情况下，远程过程调用提供的不只是抽象上的概念。它允许程序员在将一个程序划分成若干片之前，先构建，编译和测试一个解决该问题的常规程序的版本，以便确保能够正确解决问题。不但如此，因为RPC以方法调用为边界划分程序，所以将程序划分为本地部分和远程部分并不会引起程序结构的很大变化。实际上，将某些过程从一个程序转移到远程机器上时，有可能不需要改变。
1.3 常规过程调用的概念性模型
        如下图所示，为常规的程序调用。
 
1.4 远程过程调用模型
        远程过程调用模型使用了和常规程序一样的过程抽象，但是它允许一个过程的边界跨越两台计算机。如下图所示。
 
1.5 常规过程调用的执行和返回
        程序从一个主程序开始执行，并一直继续下去，直到遇到一个过程调用。这个调用使程序的执行转入到某个指定的代码处继续执行。常规过程调用的执行流程如下图所示：
 
1.6 分布式系统的过程模型
        在分布式系统中，其中的某个过程有可能在另外的机器上，因此，其调用过程模型如下图如示：
 
1.7 客户-服务器和RPC之间的对比
        远程过程调用允许程序员以一种他所熟悉的环境来思考客户和服务器的交互，如同常规的过程调用，远程过程调用把控制权传递给被调用的进程。也像常规过程调用一样，在调用进程中，系统把调用过程的执行挂起。而只允许被调用过程执行。
        当远程程序发出响应时，这对应于在常规过程调用中执行return。控制权返回给调用者，被调用过程停止执行。嵌套的过程调用的想法也可应用到远程过程调用。远程过程调用也许要调用另一个远程过程。如上图所示。

二. 分布式程序的生成原理

        RPC的实现包括一个工具，它自动地生成实现分布式程序所需要的大多数代码。这个工具叫做rpcgen，它读取一个规约文件作为输入，生成C的源文件作为输出。规范文件包含常量，全局数据类型，全局数据以及远程过程（包括过程参数和结果类型）的声明。rpcgen产生的代码包含了实现客户和服务器程序所需要的大部分源代码。具体地说，rpcgen包括参数整理，发送RPC报文，把传入调用分派到正确的过程，发送应答，在参数和结构的外部表示和本地数据表示之间进行转换。rpcgen的输出与应用程序和程序员编写的少数文件相结合后，便产生出了完整的客户和服务器程序。
        rpcgen读取输入文件，该文件包含有对远程过程的说明。它产生四个输出文件，每个文件都包含有源代码，如果输入的文件（即规约文件）具有名字q.x， 则输出的文件如下所示：
q.h：常量和类型的声明
q_xdr.c XDR过程调用
q_clnt.c 客户端的通信接口
q_svc.c 服务器端的通信接口

三. 分布式程序的生成步骤

       在这里列举出一个例子。这个例子可以很好的解释出rpcgen是如何工作的。

3.1 查找字典

       在这个例子中，考虑实现一个简单的数据库功能的程序。该数据库提供四个基本的操作：初始化，插入一个新的条目，删除一个条目，查找一个条目。假设每个条目都是一个单词。因此该数据库的功能就可以看作是一个字典。应用程序插入一组单词，接着使用数据库来检查新单词，以便知道这个单词是否在该字典中。

3.2 构建程序的八个步骤

（1）构建解决该问题的常规应用程序

  要构建这个字典应用例子的分布式版本，第一步要求程序员构造解决该问题的常规程序。文件dict.c包含了该常规程序：

[cpp]  view plain copy print ?

1. /* dict.c */  
2. #include<stdio.h>  
3. #include<stdlib.h>  
4. #include<ctype.h>  
5. #include<string.h>  
6.   
7. #define MAXWORD 50                 /* 每个单词的长度限制*/  
8. #define DICTSIZ 100             /* 字典一共可以存放多少个单词 */  
9.   
10. char dict[DICTSIZ][MAXWORD+1];  
11. int nwords = 0;  
12.   
13. /* 
14.   * nextin(): 读入命令与单词 
15.   */  
16. int nextin(char *cmd, char *word)  
17. {  
18.         int i, j;  
19.         char buf[100] = {0};  
20.   
21.         if (fgets(buf, sizeof(buf)-1, stdin) == NULL)  
22.                 return -1;  
23.           
24.         for (i = 0; i < 100; i++)  
25.                 if (buf[i] != ' ')  
26.                         break;  
27.         if (i == 100)  
28.                 return -1;  
29.         *cmd = buf[i];  
30.           
31.         while (1)  
32.         {  
33.                 if (i == 100)  
34.                         return -1;  
35.                 i++;  
36.                 if (buf[i] == ' ')  
37.                         continue;  
38.                 else if (buf[i] == '\n')  
39.                         return 0;  
40.                 else   
41.                         break;  
42.         }  
43.           
44.         j = 0;  
45.         while (buf[i] != '\n')  
46.         {  
47.                 *word++ = buf[i];  
48.                 i++;  
49.                 j++;  
50.         }  
51.   
52.           
53.         return j;  
54. }  
55.   
56. /* 
57.   * initw(): 初始化这个字典 
58.   */  
59. int initw()  
60. {  
61.         nwords = 0;  
62.         return 1;  
63. }  
64.   
65. /* 
66.   * insertw(const char *word): 向这个字典中加入单词 
67.   */  
68. int insertw(const char *word)  
69. {  
70.         strcpy(dict[nwords], word);  
71.         nwords++;  
72.         return nwords;  
73. }  
74.   
75. /* 
76.   * deletew(const char *word): 从这个字典中删除单词 
77.   */  
78. int deletew(const char *word)  
79. {  
80.         int i;  
81.         for (i = 0; i < nwords; i++)  
82.         {  
83.                 if (strcmp(word, dict[i]) == 0)  
84.                 {          
85.                         nwords--;  
86.                         strcpy(dict[i], dict[nwords]);  
87.                         return 1;  
88.                 }  
89.         }  
90.         return 0;  
91. }  
92.   
93. /* 
94.   * lookupw(const char *word): 在字典中查找某个单词 
95.   */  
96. int lookupw(const char *word)  
97. {  
98.         int i;  
99.         for (i = 0; i < nwords; i++)  
100.         {  
101.                 if (strcmp(word, dict[i]) == 0)  
102.                         return 1;  
103.         }  
104.         return 0;  
105. }  
106.   
107. int main(int argc, char **argv)  
108. {  
109.         char word[MAXWORD+1];  
110.         char cmd;  
111.         int wrdlen;  
112.         while (1)  
113.         {  
114.                 wrdlen = nextin(&cmd, word);  
115.                 if (wrdlen < 0)  
116.                         exit(0);  
117.                 word[wrdlen] = '\0';  
118.                 switch(cmd)  
119.                 {  
120.                         case 'I':   
121.                                 initw();  
122.                                 printf("Dictionary initialized to empty.\n");  
123.                                 break;  
124.                         case 'i':  
125.                                 insertw(word);  
126.                                 printf("%s inserted.\n", word);  
127.                                 break;  
128.                         case 'd':  
129.                                 if (deletew(word))  
130.                                         printf("%s deleted.\n", word);  
131.                                 else  
132.                                         printf("%s not found.\n", word);  
133.                                 break;  
134.                         case 'l':  
135.                                 if (lookupw(word))  
136.                                         printf("%s is found.\n", word);  
137.                                 else  
138.                                         printf("%s is not found.\n", word);  
139.                                 break;  
140.                         case 'q':  
141.                                 printf("program quits.\n");  
142.                                 exit(0);  
143.                         default:  
144.                                 printf("command %c invalid.\n", cmd);  
145.                                 break;  
146.                 }  
147.         }  
148.         return 0;  
149. }  

该dict.c程序使用了一个二维数组来存储单词。全局变量nwords记录了任何时刻字典中单词的数量。主程序包含一个循环，在每次循环中读取并处理输入文件中的一行。
        该程序就是普通的常规程序，编译并运行：
        gcc dict.c –o dict
        ./dict
        可以如下来实验：

        I
        i hello
        i world
        l hello
        d hello
        l hello
        q

（2）将程序划分为两个部分

      常规程序一旦构建完成并经过测试，就可以将它划分成本地构件和远程构件了。下图为这个程序的过程调用情况：

        在考虑哪个过程可以转移到远程机器上时，程序员必须考虑每个过程所需要的资源。例如nextin在每次被调用时要读取下一个输入行，并对它进行分析。因为它需要访问程序的标准输入，所以nextin必须放在主程序的机器中。简单来说就是执行I/O或者访问文件描述符的过程不能轻易地转移到远程机器中。
        同时还要考虑每个过程所要访问的数据所处的位置。例如，lookupw需要访问全部单词数据库，如果执行lookupw的机器不同于字典所处的机器，对lookupw的RPC调用就必须将整个字典作为参数来传递。将巨大的数据结构作为参数传递给远程过程的效率非常低。一般来说执行过程的机器应当与放置过程所要访问数据的机器是同一台，将巨大的数据结构传递给远程过程的效率是很低的。
        对于本应用来说，应当把过程insertw，deletew，initw，lookupw和字典本身放在同一台机器中。下图说明了这种划分方式：
 
相当于将dict.c 划分成了两个文件dict1.c和dict2.c。这里的两个程序只是一个示例，不需要写出来，但是后面将要编写与这两个程序相似的另外两个程序。
        文件dict1.c包含主程序和过程nextin：

[cpp]  view plain copy print ?

1. /* dict1.c */  
2. #include<stdio.h>  
3. #include<stdlib.h>  
4. #include<ctype.h>  
5. #include<string.h>  
6.   
7. #define MAXWORD 50  
8.   
9. char dict[DICTSIZ][MAXWORD+1];  
10. int nwords = 0;  
11.   
12. int nextin(char *cmd, char *word)  
13. {  
14.         int i, j;  
15.         char buf[100] = {0};  
16.   
17.         if (fgets(buf, sizeof(buf)-1, stdin) == NULL)  
18.                 return -1;  
19.           
20.         for (i = 0; i < 100; i++)  
21.                 if (buf[i] != ' ')  
22.                         break;  
23.         if (i == 100)  
24.                 return -1;  
25.         *cmd = buf[i];  
26.           
27.         while (1)  
28.         {  
29.                 if (i == 100)  
30.                         return -1;  
31.                 i++;  
32.                 if (buf[i] == ' ')  
33.                         continue;  
34.                 else if (buf[i] == '\n')  
35.                         return 0;  
36.                 else   
37.                         break;  
38.         }  
39.           
40.         j = 0;  
41.         while (buf[i] != '\n')  
42.         {  
43.                 *word++ = buf[i];  
44.                 i++;  
45.                 j++;  
46.         }  
47.   
48.           
49.         return j;  
50. }  
51.   
52. int main(int argc, char **argv)  
53. {  
54.         char word[MAXWORD+1];  
55.         char cmd;  
56.         int wrdlen;  
57.         while (1)  
58.         {  
59.                 wrdlen = nextin(&cmd, word);  
60.                 if (wrdlen < 0)  
61.                         exit(0);  
62.                 word[wrdlen] = '\0';  
63.                 switch(cmd)  
64.                 {  
65.                         case 'I':   
66.                                 initw();  
67.                                 printf("Dictionary initialized to empty.\n");  
68.                                 break;  
69.                         case 'i':  
70.                                 insertw(word);  
71.                                 printf("%s inserted.\n", word);  
72.                                 break;  
73.                         case 'd':  
74.                                 if (deletew(word))  
75.                                         printf("%s deleted.\n", word);  
76.                                 else  
77.                                         printf("%s not found.\n", word);  
78.                                 break;  
79.                         case 'l':  
80.                                 if (lookupw(word))  
81.                                         printf("%s is found.\n", word);  
82.                                 else  
83.                                         printf("%s is not found.\n", word);  
84.                                 break;  
85.                         case 'q':  
86.                                 printf("program quits.\n");  
87.                                 exit(0);  
88.                         default:  
89.                                 printf("command %c invalid.\n", cmd);  
90.                                 break;  
91.                 }  
92.         }  
93.         return 0;  
94. }  

文件dict2.c包含了来自最初的应用程序的一些函数。它们将成为远程程序的一部分。另外，还包含对各个函数要共享的全局数据的声明。

[cpp]  view plain copy print ?

1. /* dict2.c */  
2. #include<string.h>  
3.   
4. #define MAXWORD 50  
5. #define DICTSIZ 100  
6.   
7. char dict[DICTSIZ][MAXWORD+1];  
8. int nwords = 0;  
9.   
10. int initw()  
11. {  
12.         nwords = 0;  
13.         return 1;  
14. }  
15.   
16. int insertw(char *word)  
17. {  
18.         strcpy(dict[nwords], word);  
19.         nwords++;  
20.         return nwords;  
21. }  
22.   
23. int deletew(char *word)  
24. {  
25.         int i;  
26.         for (i = 0; i < nwords; i++)  
27.         {  
28.                 if (strcmp(word, dict[i]) == 0)  
29.                 {  
30.                         nwords--;  
31.                         strcpy(dict[i], dict[nwords]);  
32.                         return 1;  
33.                 }  
34.         }  
35.         return 0;  
36. }  
37.   
38. int lookupw(char *word)  
39. {  
40.         int i;   
41.         for (i = 0; i < nwords; i++)  
42.                 if (strcmp(word, dict[i]) == 0)  
43.                         return 1;  
44.         return 0;  
45. }  

注意，对符号常量MAXWORD的定义在两个构件中都出现了，因为它们都要声明用于存储字的变量，然而，只有在文件dict2.c中才含有用于存储字典的数据结构的声明，因为只有远程过程才包含字典的数据结构。
        此时
        gcc –c dict1.c
        gcc –c dict2.c
        编译一下检查是否有语法错误。

（3）创建rpcgen规约
        程序员一旦为某个分布式程序选择了一种结构，就可以准备rpc规约了。从本质上说，rpcgen规约文件包含了对远程程序的声明以及它所使用的数据结构。
        该规约文件包含常量，类型定义，以及对客户和服务器程序的声明。即：
        声明在客户或服务器中所使用的常量
        声明所使用的数据类型
        声明远程程序，每个程序中所包含的过程以及它们的参数类型
        所有这些声明必须用RPC编程语言来给出。对于该例子的规约如下，rdict.x：

[cpp]  view plain copy print ?

1. /* rdict.x */  
2. const MAXWORD = 50;  
3. const DICTSIZ = 100;  
4.   
5. struct example  
6. {  
7.         int exfield1;  
8.         char exfield2;  
9. };  
10.   
11. program RDICTPROG                                /* 远程程序的名称 */  
12. {  
13.         version RDICTVERS                                        /* 版本 */  
14.         {  
15.                 int INITW(void)        = 1;                       /* 第一个函数 */  
16.                 int INSERTW(string)        = 2;                       /* 第二个函数 */  
17.                 int DELETEW(string)        = 3;                       /* 第三个函数 */  
18.                 int LOOKUPW(string)= 4;                       /* 第四个函数 */  
19.         } = 1;                                        /* 该程序的版本号 */  
20. } = 0x30090949;                                        /* 远程程序标识, 必须唯一 */  

（4）运行rpcgen
        在完成了规约后，程序员运行rpcgen来检查语法错误，并且生成四个代码文件：rdict.h rdict_clnt.c rdict_svc.c和rdict_xdr.c。 
        输入命令：rpcgen rdict.x 
        rdict.h为rpcgen产生的.h文件，即头文件。
        rdict_xdr.c为rpcgen产生的XDR转换文件，XDR即External Data Representation。是数据传输的一个规范。
        rdict_clnt.c为rpcgen产生的客户端的代码。
        rdict_svc.c为rpcgen产生的服务器端的代码。
        这些文件一旦生成，就可以被编译成目标代码的形式。
        gcc –c rdict_clnt.c
        gcc –c rdict_svc.c
        gcc –c rdict_xdr.c
        到了这一步，需要程序员再编写接口过程。程序员需要编写四个程序，分别为客户端程序与客户端的接口程序，服务器程序与服务器端的接口程序。如下图所示，图中阴影部分为需要程序员自己编写的代码：
 
（5）编写接口过程
        rpcgen产生的文件并没有构成完整的程序，它还要求程序员必须编写客户端和服务器端的接口。
        客户端接口rdict_cif.c程序如下所示：

[cpp]  view plain copy print ?

1. /* rdict_cif.c */  
2. #include<rpc/rpc.h>  
3. #include<stdio.h>  
4.   
5. #define RPC_CLNT  
6. #include"rdict.h"  
7.   
8. extern CLIENT *handle;  
9. static int *ret;  
10.   
11. int initw()  
12. {  
13.         ret = initw_1(0, handle);  
14.         return ret == NULL ? 0 : *ret;  
15. }  
16.   
17. int insertw(char *word)  
18. {  
19.         char **arg;  
20.         arg = &word;  
21.         ret = insertw_1(arg, handle);  
22.         return ret == NULL ? 0 : *ret;  
23. }  
24.   
25. int deletew(char *word)  
26. {  
27.         char **arg;  
28.         arg = &word;  
29.         ret = deletew_1(arg, handle);  
30.         return ret == NULL ? 0 : *ret;  
31. }  
32.   
33. int lookupw(char *word)  
34. {  
35.         char **arg;  
36.         arg = &word;  
37.         ret = lookupw_1(arg, handle);  
38.         return ret == NULL ? 0 : *ret;  
39. }  

服务器端接口例程rdict_sif.c如下：

[cpp]  view plain copy print ?

1. /* rdict_sif.c */  
2. #include<rpc/rpc.h>  
3. #define RPC_SVC  
4.   
5. #include"rdict.h"  
6. static int retcode;  
7.   
8. int initw(void), insertw(char *), deletew(char *), lookupw(char *);  
9.   
10. int *insertw_1_svc(char **w, struct svc_req* rqstp)  
11. {  
12.         retcode = insertw(*(char**)w);  
13.         return &retcode;  
14. }  
15.   
16. int *initw_1_svc(void* w, struct svc_req* rqstp)  
17. {  
18.         retcode = initw();  
19.         return &retcode;  
20. }  
21.   
22. int *deletew_1_svc(char **w, struct svc_req* rqstp)  
23. {  
24.         retcode = deletew(*(char**)w);  
25.         return &retcode;  
26. }  
27.   
28. int *lookupw_1_svc(char **w, struct svc_req *rqstp)  
29. {  
30.         retcode = lookupw(*(char**)w);  
31.         return &retcode;  
32. }  

（6）编译和链接客户程序
        首先
        gcc –c rdict_cif.c编译客户端的接口程序。
        再gcc –c rdict_xdr.c编译XDR程序。
        而客户端程序还需要声明并初始化一个句柄，RPC通信例程用该句柄和服务器通信。
        客户端程序rdict.c如下：

[cpp]  view plain copy print ?

1. /* rdict.c */  
2. #include<rpc/rpc.h>  
3. #include<stdlib.h>  
4. #include<stdio.h>  
5. #include<ctype.h>  
6.   
7. #include"rdict.h"  
8.   
9. #define MAXWORD 50  
10. #define RMACHINE "127.0.0.1"   /* 服务器端ip address */  
11. CLIENT *handle;  
12.   
13. int nextin(char *cmd, char *word)  
14. {  
15.         int i, j;  
16.         char buf[100] = {0};  
17.   
18.         if (fgets(buf, sizeof(buf)-1, stdin) == NULL)  
19.                 return -1;  
20.           
21.         for (i = 0; i < 100; i++)  
22.                 if (buf[i] != ' ')  
23.                         break;  
24.         if (i == 100)  
25.                 return -1;  
26.         *cmd = buf[i];  
27.           
28.         while (1)  
29.         {  
30.                 if (i == 100)  
31.                         return -1;  
32.                 i++;  
33.                 if (buf[i] == ' ')  
34.                         continue;  
35.                 else if (buf[i] == '\n')  
36.                         return 0;  
37.                 else   
38.                         break;  
39.         }  
40.           
41.         j = 0;  
42.         while (buf[i] != '\n')  
43.         {  
44.                 *word++ = buf[i];  
45.                 i++;  
46.                 j++;  
47.         }  
48.   
49.         return j;  
50. }  
51.   
52. int main(int argc, char **argv)  
53. {  
54.         char word[MAXWORD+1];  
55.         char cmd;  
56.         int wrdlen;  
57.   
58.         handle = clnt_create(RMACHINE, RDICTPROG, RDICTVERS, "tcp");  
59.         if (handle == NULL)  
60.         {  
61.                 printf("cound not contact remote program.\n");  
62.                 exit(1);  
63.         }  
64.   
65.         while (1)  
66.         {  
67.                 wrdlen = nextin(&cmd, word);  
68.                 if (wrdlen < 0)  
69.                 {  
70.                         exit(0);  
71.                 }  
72.                 word[wrdlen] = '\0';  
73.                 switch(cmd)  
74.                 {  
75.                         case 'I':  
76.                                 initw();  
77.                                 printf("Dictionary initialized to empty.\n");  
78.                                 break;  
79.                         case 'i':  
80.                                 insertw(word);  
81.                                 printf("%s inserted.\n", word);  
82.                                 break;  
83.                         case 'd':  
84.                                 if (deletew(word))  
85.                                         printf("%s deleted.\n", word);  
86.                                 else  
87.                                         printf("%s not found.\n", word);  
88.                                 break;  
89.                         case 'l':  
90.                                 if (lookupw(word))  
91.                                         printf("%s is found.\n", word);  
92.                                 else  
93.                                         printf("%s is not found.\n", word);  
94.                                 break;  
95.                         case 'q':  
96.                                 printf("program quits.\n");  
97.                                 exit(0);  
98.                         default:  
99.                                 printf("command %c invalid.\n", cmd);  
100.                                 break;  
101.                 }  
102.         }  
103.         return 0;  
104. }  

         之后再进行编译gcc –c rdict.c
        最后将所有目标代码链接起来
        gcc –o rdict rdict.o rdict_clnt.o rdict_xdr.o rdict_cif.o

（7）编译和链接服务器程序
        和客户端程序一样，也需要编写服务器端的程序。
        远程过程的版本在文件rdict_srp.c中：

[cpp]  view plain copy print ?

1. /* rdict_srp.c */  
2. #include<rpc/rpc.h>  
3. #include<string.h>  
4. #include"rdict.h"  
5.   
6. char dict[DICTSIZ][MAXWORD+1];  
7. int nwords = 0;  
8.   
9. int initw()  
10. {  
11.         nwords = 0;  
12.         return 1;  
13. }  
14.   
15. int insertw(char *word)  
16. {  
17.         strcpy(dict[nwords], word);  
18.         nwords++;  
19.         return nwords;  
20. }  
21.   
22. int deletew(char *word)  
23. {  
24.         int i;  
25.         for (i = 0; i < nwords; i++)  
26.         {  
27.                 if (strcmp(word, dict[i]) == 0)  
28.                 {  
29.                         nwords--;  
30.                         strcpy(dict[i], dict[nwords]);  
31.                         return 1;  
32.                 }  
33.         }  
34.         return 0;  
35. }  
36.   
37. int lookupw(char *word)  
38. {  
39.         int i;  
40.         for (i = 0; i < nwords; i++)  
41.                 if (strcmp(word, dict[i]) == 0)  
42.                         return 1;  
43.         return 0;  
44. }  

        远程过程如下编译：
        gcc –c rdict_srp.c
        gcc –c rdict_svc.c 
        最后将所有目标程序链接起来
        gcc –o rdictd rdict_svc.o rdict_xdr.o rdict_sif.o rdict_srp.o 

（8）启动服务器和执行客户程序
        最后就启动运行这个分布式的版本，也可以将客户端程序放到另外一台机器上面编译运行(我将这个程序的客户端与服务器端在同一机器与不同机器上面都试过, 都没有问题)。不过在rdict.c中需要写明服务器的IP地址。
        ./rdictd 
        ./rdict