/*************************************************
* author: 王胜祥 *
* email: <mantx@21cn.com> *
* date: 2005-03-07 *
* version: *
* filename: ceh.h *
*************************************************/

/********************************************************************

This file is part of CEH(Exception Handling in C Language).

CEH is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

CEH is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

　　注意：这个异常处理框架不支持线程安全，不能在多线程的程序环境下使用。
如果您想在多线程的程序中使用它，您可以自己试着来继续完善这个
框架模型。
*********************************************************************/

#include <stdio.h>
#include <signal.h>
#include <setjmp.h>
#include <stdlib.h>
#include <float.h>
#include <math.h>
#include <string.h>

////////////////////////////////////////////////////
/* 与异常有关的结构体定义 */
typedef struct _CEH_EXCEPTION {
int err_type; /* 异常类型 */
int err_code; /* 错误代码 */
char err_msg[80]; /* 错误信息 */
}CEH_EXCEPTION; /* 异常对象 */

typedef struct _CEH_ELEMENT {
jmp_buf exec_status;
CEH_EXCEPTION ex_info;

struct _CEH_ELEMENT* next;
} CEH_ELEMENT; /* 存储异常对象的链表元素 */
////////////////////////////////////////////////////

////////////////////////////////////////////////////
/* 内部接口定义，操纵维护链表数据结构 */
extern void CEH_push(CEH_ELEMENT* ceh_element);
extern CEH_ELEMENT* CEH_pop();
extern CEH_ELEMENT* CEH_top();
extern int CEH_isEmpty();
////////////////////////////////////////////////////

/* 以下是外部接口的定义 */
////////////////////////////////////////////////////
/* 抛出异常 */
extern void thrower(CEH_EXCEPTION* e);

/* 抛出异常 (throw)
a表示err_type
b表示err_code
c表示err_msg
*/
#define throw(a, b, c) \
{ \
CEH_EXCEPTION ex; \
memset(&ex, 0, sizeof(ex)); \
ex.err_type = a; \
ex.err_code = b; \
strncpy(ex.err_msg, c, sizeof(c)); \
thrower(&ex); \
}

/* 重新抛出原来的异常 (rethrow)*/
#define rethrow thrower(ceh_ex_info)
////////////////////////////////////////////////////

////////////////////////////////////////////////////
/* 定义try block（受到监控的代码）*/
#define try \
{ \
int ___ceh_b_catch_found, ___ceh_b_occur_exception; \
CEH_ELEMENT ___ceh_element; \
CEH_EXCEPTION* ceh_ex_info; \
memset(&___ceh_element, 0, sizeof(___ceh_element)); \
CEH_push(&___ceh_element); \
ceh_ex_info = &___ceh_element.ex_info; \
___ceh_b_catch_found = 0; \
if (!(___ceh_b_occur_exception=setjmp(___ceh_element.exec_status))) \
{

/* 定义catch block（异常错误的处理模块）
catch表示捕获所有类型的异常
*/
#define catch \
} \
else \
{ \
CEH_pop(); \
___ceh_b_catch_found = 1;

/* end_try表示前面定义的try block和catch block结束 */
#define end_try \
} \
{ \
/* 没有执行到任何的catch块中 */ \
if(!___ceh_b_catch_found) \
{ \
CEH_pop(); \
/* 出现了异常，但没有捕获到任何异常 */ \
if(___ceh_b_occur_exception) thrower(ceh_ex_info); \
} \
} \
}

/* 定义catch block（异常错误的处理模块）
catch_part表示捕获一定范围内的异常
*/
#define catch_part(i, j) \
} \
else if(ceh_ex_info->err_type>=i && ceh_ex_info->err_type<=j) \
{ \
CEH_pop(); \
___ceh_b_catch_found = 1;

/* 定义catch block（异常错误的处理模块）
catch_one表示只捕获一种类型的异常
*/
#define catch_one(i) \
} \
else if(ceh_ex_info->err_type==i) \
{ \
CEH_pop(); \
___ceh_b_catch_found = 1;
////////////////////////////////////////////////////

////////////////////////////////////////////////////
/* 其它可选的接口定义 */
extern void CEH_init();
////////////////////////////////////////////////////

2、另外还有一个简单的实现文件，主要实现功能封装。代码如下：

/*************************************************
* author: 王胜祥 *
* email: <mantx@21cn.com> *
* date: 2005-03-07 *
* version: *
* filename: ceh.c *
*************************************************/

/********************************************************************

This file is part of CEH(Exception Handling in C Language).

CEH is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

CEH is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

注意：这个异常处理框架不支持线程安全，不能在多线程的程序环境下使用。
如果您想在多线程的程序中使用它，您可以自己试着来继续完善这个
框架模型。
*********************************************************************/

#include "ceh.h"

////////////////////////////////////////////////////
static CEH_ELEMENT* head = 0;

/* 把一个异常插入到链表头中 */
void CEH_push(CEH_ELEMENT* ceh_element)
{
if(head) ceh_element->next = head;
head = ceh_element;
}

/* 从链表头中，删除并返回一个异常 */
CEH_ELEMENT* CEH_pop()
{
CEH_ELEMENT* ret = 0;

ret = head;
head = head->next;

return ret;
}

/* 从链表头中，返回一个异常 */
CEH_ELEMENT* CEH_top()
{
return head;
}

/* 链表中是否有任何异常 */
int CEH_isEmpty()
{
return head==0;
}
////////////////////////////////////////////////////

////////////////////////////////////////////////////
/* 缺省的异常处理模块 */
static void CEH_uncaught_exception_handler(CEH_EXCEPTION *ceh_ex_info)
{
printf("捕获到一个未处理的异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
fprintf(stderr, "程序终止!\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
////////////////////////////////////////////////////

////////////////////////////////////////////////////
/* 抛出异常 */
void thrower(CEH_EXCEPTION* e)
{
CEH_ELEMENT *se;

if (CEH_isEmpty()) CEH_uncaught_exception_handler(e);

se = CEH_top();
se->ex_info.err_type = e->err_type;
se->ex_info.err_code = e->err_code;
strncpy(se->ex_info.err_msg, e->err_msg, sizeof(se->ex_info.err_msg));

longjmp(se->exec_status, 1);
}
////////////////////////////////////////////////////

////////////////////////////////////////////////////
static void fphandler( int sig, int num )
{
_fpreset();

switch( num )
{
case _FPE_INVALID:
throw(-1, num, "Invalid number" );
case _FPE_OVERFLOW:
throw(-1, num, "Overflow" );
case _FPE_UNDERFLOW:
throw(-1, num, "Underflow" );
case _FPE_ZERODIVIDE:
throw(-1, num, "Divide by zero" );
default:
throw(-1, num, "Other floating point error" );
}
}

void CEH_init()
{
_control87( 0, _MCW_EM );

if( signal( SIGFPE, fphandler ) == SIG_ERR )
{
fprintf( stderr, "Couldn't set SIGFPE\n" );
abort();
}
}
////////////////////////////////////////////////////
　　体验上面设计出的异常处理框架
请花点时间仔细揣摩一下上面设计出的异常处理框架。呵呵！程序员朋友们，大家是不是发现它与C++提供的异常处理模型非常相似。例如，它提供的基本接口有 try、catch、以及throw等三条语句。还是先看个具体例子吧！以便验证一下这个C语言环境中异常处理框架是否真的比较好用。代码如下：

#include "ceh.h"

int main(void)
{
//定义try block块
try
{
int i,j;
printf("异常出现前\n\n");

// 抛出一个异常
// 其中第一个参数，表示异常类型；第二个参数表示错误代码
// 第三个参数表示错误信息
throw(9, 15, "出现某某异常");

printf("异常出现后\n\n");
}
//定义catch block块
catch
{
printf("catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 这里稍有不同，需要定义一个表示当前的try block结束语句
// 它主要是清除相应的资源
end_try
}

　　注意，上面的测试程序可是C语言环境下的程序（文件的扩展名请使用.c结尾），虽然它看上去很像C++程序。请编译运行一下，发现它是不是运行结果如下：
异常出现前

catch块，被执行到

　　捕获到一个异常，错误原因是：出现某某异常! err_type:9 err_code:15

　　呵呵！程序的确是在按照我们预想的流程在执行。再次提醒，这可是C程序，但是它的异常处理却非常类似于C++中的风格，要知道，做到这一点其实非常地 不容易。当然，上面异常对象的传递只是在一个函数的内部，同样，它也适用于多个嵌套函数间的异常传递，还是用代码验证一下吧！在上面的代码基础下，小小修 改一点，代码如下：

#include "ceh.h"

void test1()
{
throw(0, 20, "hahaha");
}

void test()
{
test1();
}

int main(void)
{
try
{
int i,j;
printf("异常出现前\n\n");

// 注意，这个函数的内部会抛出一个异常。
test();

throw(9, 15, "出现某某异常");

printf("异常出现后\n\n");
}
catch
{
printf("catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try
}

　　同样，在上面程序中，test1()函数内抛出的异常，可以被上层main()函数中的catch block中捕获到。运行结果就不再给出了，大家可以自己编译运行一把，看看运行结果。
另外这个异常处理框架，与C++中的异常处理模型类似，它也支持try catch块的多层嵌套。很厉害吧！还是看演示代码吧！，如下：

#include "ceh.h"

int main(void)
{
// 外层的try catch块
try
{
// 内层的try catch块
try
{
throw(1, 15, "嵌套在try块中");
}
catch
{
printf("内层的catch块被执行\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);

printf("外层的catch块被执行\n");
}
end_try

throw(2, 30, "再抛一个异常");
}
catch
{
printf("外层的catch块被执行\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try
}

　　请编译运行一下，程序的运行结果如下：
　　内层的catch块被执行
　　捕获到一个异常，错误原因是：嵌套在try块中! err_type:1 err_code:15
　　外层的catch块被执行
　　捕获到一个异常，错误原因是：再抛一个异常! err_type:2 err_code:30

　　还有，这个异常处理框架也支持对异常的分类处理。这一点，也完全是模仿C++中的异常处理模型。不过，由于C语言中，不支持函数名重载，所以语法上略有不同，还是看演示代码吧！，如下：

#include "ceh.h"

int main(void)
{
try
{
int i,j;
printf("异常出现前\n\n");

throw(9, 15, "出现某某异常");

printf("异常出现后\n\n");
}
// 这里表示捕获异常类型从4到6的异常
catch_part(4, 6)
{
printf("catch_part(4, 6)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 这里表示捕获异常类型从9到10的异常
catch_part(9, 10)
{
printf("catch_part(9, 10)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 这里表示只捕获异常类型为1的异常
catch_one(1)
{
printf("catch_one(1)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 这里表示捕获所有类型的异常
catch
{
printf("catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try
}

　　请编译运行一下，程序的运行结果如下：
　　异常出现前

catch_part(9, 10)块，被执行到
　　捕获到一个异常，错误原因是：出现某某异常! err_type:9 err_code:15

　　与C++中的异常处理模型相似，它这里的对异常的分类处理不仅支持一维线性的；同样，它也支持分层的，也即在当前的try catch块中找不到相应的catch block，那么它将会到上一层的try catch块中继续寻找。演示代码如下：

#include "ceh.h"

int main(void)
{
try
{
try
{
throw(1, 15, "嵌套在try块中");
}
catch_part(4, 6)
{
printf("catch_part(4, 6)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try

printf("这里将不会被执行到\n");
}
catch_part(2, 3)
{
printf("catch_part(2, 3)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 找到了对应的catch block
catch_one(1)
{
printf("catch_one(1)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
catch
{
printf("catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try

}

　　到目前为止，大家是不是已经觉得，这个主人公阿愚封装的在C语言环境中异常处理框架，已经与C++中的异常处理模型95%相似。无论是它的语法结构；还是所完成的功能；以及它使用上的灵活性等。下面我们来看一个各种情况综合的例子吧！代码如下：

#include "ceh.h"

void test1()
{
throw(0, 20, "hahaha");
}

void test()
{
test1();
}

int main(void)
{
try
{
test();
}
catch
{
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try

try
{
try
{
throw(1, 15, "嵌套在try块中");
}
catch
{
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try

throw(2, 30, "再抛一个异常");
}
catch
{
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);

try
{
throw(0, 20, "嵌套在catch块中");
}
catch
{
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
end_try
}
end_try
}

　　请编译运行一下，程序的运行结果如下：
　　捕获到一个异常，错误原因是：hahaha! err_type:0 err_code:20
　　捕获到一个异常，错误原因是：嵌套在try块中! err_type:1 err_code:15
　　捕获到一个异常，错误原因是：再抛一个异常! err_type:2 err_code:30
　　捕获到一个异常，错误原因是：嵌套在catch块中! err_type:0 err_code:20

　　最后，为了体会到这个异常处理框架，更进一步与C++中的异常处理模型相似。那就是它还支持异常的重新抛出，以及系统中能捕获并处理程序中没有catch到的异常。看代码吧！如下：

#include "ceh.h"

void test1()
{
throw(0, 20, "hahaha");
}

void test()
{
test1();
}

int main(void)
{
// 这里表示程序中将捕获浮点数计算异常
CEH_init();

try
{
try
{
try
{
double i,j;
j = 0;
// 这里出现浮点数计算异常
i = 1/j ;

test();

throw(9, 15, "出现某某异常");
}
end_try
}
catch_part(4, 6)
{
printf("catch_part(4, 6)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
catch_part(2, 3)
{
printf("catch_part(2, 3)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);
}
// 捕获到上面的异常
catch
{
printf("内层的catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);

// 这里再次把上面的异常重新抛出
rethrow;

printf("这里将不会被执行到\n");
}
end_try
}
catch_part(7, 9)
{
printf("catch_part(7, 9)块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);

throw(2, 15, "出现某某异常");
}
// 再次捕获到上面的异常
catch
{
printf("外层的catch块，被执行到\n");
printf("捕获到一个异常，错误原因是：%s! err_type:%d err_code:%d\n",
ceh_ex_info->err_msg, ceh_ex_info->err_type, ceh_ex_info->err_code);

// 最后又抛出了一个异常，
// 但是这个异常没有对应的catch block处理，所以系统中处理了
throw(2, 15, "出现某某异常");
}
end_try
}

写于：2002/07/10 最后更新： Mon, 21 Feb 2005 08:46:12 GMT
Feed Back >> (Read this before you ask question)

版权声明：可以任意转载，转载时请务必以超链接形式标明文章原始出处和作者信息及本声明
http://www.chedong.com/tech/cvs_card.html

关键词：CVS CVSWeb CVSTrac WinCVS CVSROOT

内容摘要：

CVS是一个C/S系统，多个开发人员通过一个中心版本控制系统来记录文件版本，从而达到保证文件同步的目的。工作模式如下：

       CVS服务器（文件版本库）
     /     |       \
     （版 本 同 步）
   /       |         \
开发者1  开发者2   开发者3

作为一般开发人员挑选2,6看就可以了，CVS的管理员则更需要懂的更多一些，最后还简单介绍了一些Windows下的cvs客户端使用，CVS远 程用户认证的选择及与BUG跟踪系统等开发环境的集成问题。

1. CVS环境初始化：CVS环境的搭建 管理员
2. CVS的日常使用：日常开发中最常用的CVS命令， 开发人员 管理员
3. CVS的分支开发：项目按照不同进度和目标并发进行 管理员
4. CVS的用户认证：通过SSH的远程用户认证，安全，简单 管理员
5. CVSWEB：CVS的WEB访问界面大大提高代码版本比较的效率 管理员
6. CVS TAG：将$Id$ 加入代码注释中，方便开发过程的跟踪 开发人员
7. CVS vs VSS: CVS和Virsual SourceSafe的比较 开发人员 管理员
8. WinCVS: 通过SSH认证的WinCVS认证设置
9. 基于CVSTrac的小组开发环境搭建：通过CVSTrac实现web界面的CVS用户管 理,集成的BUG跟踪和WIKI交流
10. CVS中的用户权限管理：基于系统用户的CVS权限管理和基于CVSROOT/passwd的虚拟 用户管理
    

一个系统20%的功能往往能够满足80%的需求，CVS也不例外，以下是CVS最常用的功能，可能还不到它全部命令选项的20%，作为一般开发人员 平时会用cvs update和cvs commit就够了，更多的需求在实际应用过程中自然会出现，不时回头看看相关文档经常有意外的收获。

CVS环境初始化

tcsh
setenv CVSROOT /path/to/cvsroot
bash
CVSROOT=/path/to/cvsroot ; export CVSROOT

后面还提到远程CVS服务器的设置：
CVSROOT=:ext:$USER@test.server.address#port:/path/to/cvsroot CVS_RSH=ssh; export CVSROOT CVS_RSH

初始化：CVS版本库的初始化。
cvs init

一个项目的首次导入
cvs import -m "write some comments here" project_name vendor_tag release_tag
执行后：会将所有源文件及目录导入到/path/to/cvsroot/project_name目录下
vender_tag: 开发商标记
release_tag: 版本发布标记

项目导出：将代码从CVS库里导出
cvs checkout project_name
cvs 将创建project_name目录，并将最新版本的源代码导出到相应目录中。这个checkout和Virvual SourceSafe中的check out不是一个概念，相对于Virvual SourceSafe的check out是cvs update， check in是cvs commit。

CVS的日常使用

注意：第一次导出以后，就不是通过cvs checkout来同步文件了，而是要进入刚才cvs checkout project_name导出的project_name目录下进行具体文件的版本同步（添加，修改，删除）操作。

将文件同步到最新的版本
cvs update
不制定文件名，cvs将同步所有子目录下的文件，也可以制定某个文件名/目录进行同步
cvs update file_name
最好每天开始工作前或将自己的工作导入到CVS库里前都要做一次，并养成“先同步 后修改”的习惯，和Virvual SourceSafe不同，CVS里没有文件锁定的概念，所有的冲突是在commit之前解决，如果你修改过程中，有其他人修改并commit到了CVS 库中，CVS会通知你文件冲突，并自动将冲突部分用
>>>>>>
content on cvs server
<<<<<<
content in your file
>>>>>>
标记出来，由你确认冲突内容的取舍。
版本冲突一般是在多个人修改一个文件造成的，但这种项目管理上的问题不应该指望由CVS来解决。

确认修改写入到CVS库里
cvs commit -m "write some comments here" file_name

注意：CVS的很多动作都是通过cvs commit进行最后确认并修改的，最好每次只修改一个文件。在确认的前，还需要用户填写修改注释，以帮助其他开发人员了解修改的原因。如果不用写-m "comments"而直接确认`cvs commit file_name` 的话，cvs会自动调用系统缺省的文字编辑器(一般是vi)要求你写入注释。
注释的质量很重要：所以不仅必须要写，而且必须写一些比较有意义的内容：以方便其他开发人员能够很好的理解
不好的注释，很难让其他的开发人员快速的理解：比如： -m "bug fixed" 甚至 -m ""
好的注释，甚至可以用中文: -m "在用户注册过程中加入了Email地址校验"

修改某个版本注释：每次只确认一个文件到CVS库里是一个很好的习惯，但难免有时候忘了指定文件名，把多个文件以同样注释commit到CVS库里了，以 下命令可以允许你修改某个文件某个版本的注释：
cvs admin -m 1.3:"write some comments here" file_name

添加文件
创建好新文件后，比如：touch new_file
cvs add new_file
注意：对于图片，Word文档等非纯文本的项目，需要使用cvs add -kb选项按2进制文件方式导入(k表示扩展选项，b表示binary)，否则有可能出现文件被破坏的情况
比如：
cvs add -kb new_file.gif
cvs add -kb readme.doc

如果关键词替换属性在首次导入时设置错了怎么办？
cvs admin -kkv new_file.css

然后确认修改并注释
cvs ci -m "write some comments here"

删除文件
将某个源文件物理删除后，比如：rm file_name
cvs rm file_name
然后确认修改并注释
cvs ci -m "write some comments here"
以上面前2步合并的方法为：
cvs rm -f file_name
cvs ci -m "why delete file"
注意：很多cvs命令都有缩写形式：commit=>ci; update=>up; checkout=>co/get; remove=>rm;

添加目录
cvs add dir_name

查看修改历史
cvs log file_name
cvs history file_name

查看当前文件不同版本的区别
cvs diff -r1.3 -r1.5 file_name
查看当前文件（可能已经修改了）和库中相应文件的区别
cvs diff file_name
cvs的web界面提供了更方便的定位文件修改和比较版本区别的方法，具体安装设置请看后面的cvsweb使用

正确的通过CVS恢复旧版本的方法：
如果用cvs update -r1.2 file.name
这个命令是给file.name加一个STICK TAG： "1.2" ，虽然你的本意只是想将它恢复到1.2版本
正确的恢复版本的方法是：cvs update -p -r1.2 file_name >file_name
如果不小心已经加成STICK TAG的话：用cvs update -A 解决

移动文件/文件重命名
cvs里没有cvs move或cvs rename，因为这两个操作是可以由先cvs remove old_file_name，然后cvs add new_file_name实现的。

删除/移动目录
最方便的方法是让管理员直接移动，删除CVSROOT里相应目录（因为CVS一个项目下的子目录都是独立的，移动到$CVSROOT目录下都可以作为新的 独立项目：好比一颗树，其实砍下任意一枝都能独立存活），对目录进行了修改后，要求其开发人员重新导出项目cvs checkout project_name 或者用cvs update -dP同步。

项目发布导出不带CVS目录的源文件
做开发的时候你可能注意到了，每个开发目录下，CVS都创建了一个CVS/目录。里面有文件用于记录当前目录和CVS库之间的对应信息。但项目发布的时候 你一般不希望把文件目录还带着含有CVS信息的CVS目录吧，这个一次性的导出过程使用cvs export命令，不过export只能针对一个TAG或者日期导出，比如：
cvs export -r release1 project_name
cvs export -D 20021023 project_name
cvs export -D now project_name

CVS Branch：项目多分支同步开发

cvs tag release_1_0

开始一个新的里程碑：
cvs commit -r 2 标记所有文件开始进入2.x的开发

注意：CVS里的revsion和软件包的发布版本可以没有直接的关系。但所有文件使用和发布版本一致的版本号比较有助于维护。

版本分支的建立
在开发项目的2.x版本的时候发现1.x有问题，但2.x又不敢用，则从先前标记的里程碑：release_1_0导出一个分支 release_1_0_patch
cvs rtag -b -r release_1_0 release_1_0_patch proj_dir

一些人先在另外一个目录下导出release_1_0_patch这个分支：解决1.0中的紧急问题，
cvs checkout -r release_1_0_patch
而其他人员仍旧在项目的主干分支2.x上开发

在release_1_0_patch上修正错误后，标记一个1.0的错误修正版本号
cvs tag release_1_0_patch_1

如果2.0认为这些错误修改在2.0里也需要，也可以在2.0的开发目录下合并release_1_0_patch_1中的修改到当前代码中：
cvs update -j release_1_0_patch_1

CVS的远程认证通过SSH远程访问CVS

常见的登陆格式如下：
cvs -d :pserver:cvs_user_name@cvs.server.address:/path/to/cvsroot login
例子：
cvs -d :pserver:cvs@samba.org:/cvsroot login

不是很安全，因此一般是作为匿名只读CVS访问的方式。从安全考虑，通过系统本地帐号认证并通过SSH传输是比较好的办法，通过在客户机的 /etc/profile里设置一下内容：
CVSROOT=:ext:$USER@cvs.server.address#port:/path/to/cvsroot CVS_RSH=ssh; export CVSROOT CVS_RSH
所有客户机所有本地用户都可以映射到CVS服务器相应同名帐号了。

比如:

CVS服务器是192.168.0.3，上面CVSROOT路径是/home/cvsroot，另外一台开发客户机是192.168.0.4，如果 tom在2台机器上都有同名的帐号，那么从192.168.0.4上设置了：
export CVSROOT=:ext:tom@192.168.0.3:/home/cvsroot
export CVS_RSH=ssh
tom就可以直接在192.168.0.4上对192.168.0.3的cvsroot进行访问了（如果有权限的话）
cvs checkout project_name
cd project_name
cvs update
...
cvs commit

如果CVS所在服务器的SSH端口不在缺省的22，或者和客户端与CVS服务器端SSH缺省端口不一致，有时候设置了：
:ext:$USER@test.server.address#port:/path/to/cvsroot

仍然不行，比如有以下错误信息：
ssh: test.server.address#port: Name or service not known
cvs [checkout aborted]: end of file from server (consult above messages if any)

解决的方法是做一个脚本指定端口转向（不能使用alias，会出找不到文件错误）：
创建一个/usr/bin/ssh_cvs文件，假设远程服务器的SSH端口是非缺省端口：34567
#!/bin/sh
/usr/bin/ssh -p 34567 "$@"
然后：chmod +x /usr/bin/ssh_cvs
并CVS_RSH=ssh_cvs; export CVS_RSH

注意：port是指相应服务器SSH的端口，不是指cvs专用的pserver的端口

CVSWEB：提高文件浏览效率

使用的样例可以看：http://www.freebsd.org/cgi/cvsweb.cgi

CVSWEB的下载：CVSWEB从最初的版本已经演化出很多功能界面更丰富的版本，这个是我个人感觉安装设置比较方便的：
原先在：http://www.spaghetti-code.de/software/linux/cvsweb/，但目前已经删除，目前仍可以在本站下载CVSWEB， 其实最近2年FreeBSD的CVSWeb项目已经有了更好的发展吧，而当初没有用FreeBSD那个版本 主要就是因为没有彩色的文件Diff功能。
下载解包：
tar zxf cvsweb.tgz
把配置文件cvsweb.conf放到安全的地方（比如和apache的配置放在同一个目录下），
修改：cvsweb.cgi让CGI找到配置文件：
$config = $ENV{'CVSWEB_CONFIG'} || '/path/to/apache/conf/cvsweb.conf';

转到/path/to/apache/conf下并修改cvsweb.conf：

1. 修改CVSROOT路径设置：
   %CVSROOT = (
   'Development' => '/path/to/cvsroot', #<==修改指向本地的CVSROOT
   );
2. 缺省不显示已经删除的文档：
   "hideattic" => "1",#<==缺省不显示已经删除的文档
3. 在配置文件cvsweb.conf中还可以定制页头的描述信息，你可以修改$long_intro成你需要的文字

CVSWEB可不能随便开放给所有用户，因此需要使用WEB用户认证：
先生成 passwd:
/path/to/apache/bin/htpasswd -c cvsweb.passwd user

修改httpd.conf: 增加
<Directory "/path/to/apache/cgi-bin/cvsweb/">
AuthName "CVS Authorization"
AuthType Basic
AuthUserFile /path/to/cvsweb.passwd
require valid-user
</Directory>

CVS TAGS: $Id: cvs_card.html,v 1.5 2003/03/09 08:41:46 chedong Exp $

几个常用的缺省文件：
default.php
<?php
/*
 * Copyright (c) 2002 Company Name.
 * $Header: /home/cvsroot/tech/cvs_card.html,v 1.9 2003/11/09 07:57:11 chedong Exp $
 */

?>
====================================
Default.java: 注意文件头一般注释用 /* 开始 JAVADOC注释用 /** 开始的区别
/*
 * Copyright (c) 2002 MyCompany Name.
 * $Header: /home/cvsroot/tech/cvs_card.html,v 1.9 2003/11/09 07:57:11 chedong Exp $
 */

package com.mycompany;

import java.;

/**
 * comments here
 */
public class Default {
    /**
     * Comments here
     * @param
     * @return
     */
    public toString() {

    }
}
====================================
default.pl:
#!/usr/bin/perl -w
# Copyright (c) 2002 Company Name.
# $Header: /home/cvsroot/tech/cvs_card.html,v 1.9 2003/11/09 07:57:11 chedong Exp $

# file comments here

use strict;

CVS vs VSS

CVS没有文件锁定模式，VSS在check out同时，同时记录了文件被导出者锁定。

CVS的update和commit， VSS是get_lastest_version和check in

对应VSS的check out/undo check out的CVS里是edit和unedit

在CVS中，标记自动更新功能缺省是打开的，这样也带来一个潜在的问题，就是不用-kb方式添加binary文件的话在cvs自动更新时可能会导致 文件失效。

$Header: /home/cvsroot/tech/cvs_card.html,v 1.5 2003/03/09 08:41:46 chedong Exp $ $Date: 2003/11/09 07:57:11 $这样的标记在Virsual SourceSafe中称之为Keyword Explaination，缺省是关闭的，需要通过OPITION打开，并指定需要进行源文件关键词扫描的文件类型：*.txt,*.java, *.html...

对于Virsual SourceSafe和CVS都通用的TAG有：
$Header: /home/cvsroot/tech/cvs_card.html,v 1.5 2003/03/09 08:41:46 chedong Exp $
$Author: chedong $
$Date: 2003/11/09 07:57:11 $
$Revision: 1.9 $

我建议尽量使用通用的关键词保证代码在CVS和VSS都能方便的跟踪。

WinCVS

cvs Windows客户端：目前稳定版本为1.2
http://cvsgui.sourceforge.net
ssh Windows客户端
http://www.networksimplicity.com/openssh/

安装好以上2个软件以后：
WinCVS客户端的admin==>preference设置
1 在general选单里
设置CVSROOT： username@192.168.0.123:/home/cvsroot
设置Authorization: 选择SSH server

2 Port选单里
钩上：check for alternate rsh name
并设置ssh.exe的路径，缺省是装在 C:\Program Files\NetworkSimplicity\ssh\ssh.exe

然后就可以使用WinCVS进行cvs操作了，所有操作都会跳出命令行窗口要求你输入服务器端的认证密码。

当然，如果你觉得这样很烦的话，还有一个办法就是生成一个没有密码的公钥/私钥对，并设置CVS使用基于公钥/私钥的SSH认证（在general 选单里）。

可以选择的diff工具：examdiff
下载：
http://www.prestosoft.com/examdiff/examdiff.htm
还是在WinCVS菜单admin==>preference的WinCVS选单里
选上：Externel diff program
并设置diff工具的路径，比如：C:\Program Files\ed16i\ExamDiff.exe
在对文件进行版本diff时，第一次需要将窗口右下角的use externel diff选上。

基于CVSTrac的小组开发环境搭建

这里首先说一下CVS的pserver模式下的用户认证，CVS的用户认证服务是基于inetd中的：
cvspserver stream tcp nowait apache /usr/bin/cvs cvs --allow-root=/home/cvsroot pserver
一般在2401端口（这个端口号很好记：49的平方）

CVS用户数据库是基于CVSROOT/passwd文件，文件格式：
[username]:[crypt_password]:[mapping_system_user]
由于密码都用的是UNIX标准的CRYPT加密，这个passwd文件的格式基本上是apache的htpasswd格式的扩展（比APACHE的 PASSWD文件多一个系统用户映射字段），所以这个文件最简单的方法可以用
apache/bin/htpasswd -b myname mypassword
创建。注意：通过htpasswd创建出来的文件会没有映射系统用户的字段
例如：
new:geBvosup/zKl2
setup:aISQuNAAoY3qw
test:hwEpz/BX.rEDU

映射系统用户的目的在于：你可以创建一个专门的CVS服务帐号，比如用apache的运行用户apache，并将/home/cvsroot目录下 的所有权限赋予这个用户，然后在passwd文件里创建不同的开发用户帐号，但开发用户帐号最后的文件读写权限都映射为apache用户，在SSH模式下 多个系统开发用户需要在同一个组中才可以相互读写CVS库中的文件。

进一步的，你可以将用户分别映射到apache这个系统用户上。
new:geBvosup/zKl2:apache
setup:aISQuNAAoY3qw:apache
test:hwEpz/BX.rEDU:apache

CVSTrac很好的解决了CVSROOT/passwd的管理问题，而且包含了BUG跟踪报告系统和集成WIKIWIKI交流功能等，使用的 CGI方式的安装，并且基于GNU Public License：

在inetd里加入cvspserver服务：
cvspserver stream tcp nowait apache /usr/bin/cvs cvs --allow-root=/home/cvsroot pserver

xietd的配置文件：%cat cvspserver
service cvspserver
{
disable = no
socket_type = stream
wait = no
user = apache
server = /usr/bin/cvs
server_args = -f --allow-root=/home/cvsroot pserver
log_on_failure += USERID
}

注意：这里的用户设置成apache目的是和/home/cvsroot的所有用户一致，并且必须让这个这个用户对/home/cvsroot/下的 CVSROOT/passwd和cvstrac初始化生成的myproj.db有读取权限。

安装过程

1. 下载：可以从http://www.cvstrac.org 下载
   我用的是已经在Linux上编译好的应用程序包：cvstrac-1.1.2.bin.gz，
   %gzip -d cvstrac-1.1.2.bin.gz
   %chmod +x cvstrac-1.1.2.bin
   #mv cvstarc-1.1.1.bin /usr/bin/cvstrac

如果是从源代码编译：
从 http://www.sqlite.org/download.html 下载SQLITE的rpm包：
rpm -i sqlite-devel-2.8.6-1.i386.rpm
从 ftp://ftp.cvstrac.org/cvstrac/ 下载软件包
解包，假设解包到/home/chedong/cvstrac-1.1.2下，并规划将cvstrac安装到/usr/local/bin目录下， cd /home/chedong/cvstrac-1.1.2 编辑linux-gcc.mk:
修改：
SRCDIR = /home/chedong/cvstrac-1.1.2
INSTALLDIR = /usr/local/bin
然后
mv linux-gcc.mk Makefile
make
#make install


2. 初始化cvstrac数据库：假设数据库名是 myproj
   在已经装好的CVS服务器上（CVS库这时候应该已经是初始化好了，比如：cvs init初始化在/home/cvsroot里），运行一下
   %cvstrac init /home/cvsroot myproj
   运行后，/home/cvsroot里会有一个的myproj.db库，使用CVSTRAC服务，/home/cvsroot/myproj.db /home/cvsroot/CVSROOT/readers /home/cvsroot/CVSROOT/writers /home/cvsroot/CVSROOT/passwd这几个文件对于web服务的运行用户应该是可写的，在RedHat8上，缺省就有一个叫 apache用户和一个apache组，所以在httpd.conf文件中设置了用apache用户运行web服务：
   User apache
   Group apache，
   然后设置属于apache用户和apache组
   #chown -R apache:apache /home/cvsroot
   -rw-r--r-- 1 apache apache 55296 Jan 5 19:40 myproj.db
   drwxrwxr-x 3 apache apache 4096 Oct 24 13:04 CVSROOT/
   drwxrwxr-x 2 apache apache 4096 Aug 30 19:47 some_proj/
   此外还在/home/cvsroot/CVSROOT中设置了：
   chmod 664 readers writers passwd
   
3. 在apche/cgi-bin目录中创建脚本cvstrac:
   #!/bin/sh
   /usr/bin/cvstrac cgi /home/cvsroot
   设置脚本可执行：
   chmod +x /home/apache/cgi-bin/cvstrac
   
4. 从 http://cvs.server.address/cgi-bin/cvstrac/myproj 进入管理界面
   缺省登录名：setup 密码 setup
   对于一般用户可以从：
   http://cvs.server.address/cgi-bin/cvstrac/myproj
5. 在setup中重新设置了CVSROOT的路径后，/home/cvsroot
   如果是初次使用需要在/home/cvsroot/CVSROOT下创建passwd, readers, writers文件
   touch passwd readers writers
   然后设置属于apache用户，
   chown apache.apache passwd readers writers
   这样使用setup用户创建新用户后会同步更新CVSROOT/passwd下的帐号
   

修改登录密码，进行BUG报告等，
更多使用细节可以在使用中慢慢了解。

对于前面提到的WinCVS在perference里设置：
CVSROOT栏输入：username@ip.address.of.cvs:/home/cvsroot
Authenitication选择：use passwd file on server side
就可以了从服务器上进行CVS操作了。

CVS的用户权限管理

CVS的权限管理分2种策略：

• 基于系统文件权限的系统用户管理：适合多个在Linux上使用系统帐号的开发人员进行开发。
• 基于CVSROOT/passwd的虚拟用户管理：适合多个在Windows平台上的开发人员将帐号映射成系统帐号使用。

Linux上通过ssh连接CVS服务器的多个开发人员：通过都属于apache组实现文件的共享读写
开发人员有开发服务器上的系统帐号：sysuser1 sysuser2，设置让他们都属于apache组，因为通过cvs新导入的项目都是对组开放的：664权限的，这样无论那个系统用户导入的项目文件，只 要文件的组宿主是apache，所有其他同组系统开发用户就都可以读写；基于ssh远程认证的也是一样。

   apache(system group)
/            |           \
sysuser1   sysuser2     sysuser3

Windows上通过cvspserver连接CVS服务器的多个开发人员：通过在passwd文件种映射成 apache用户实现文件的共享读写
他们的帐号通过CVSROOT/passwd和readers writers这几个文件管理；通过cvstrac设置所有虚拟用户都映射到apache用户上即可。

   apache(system user)
/            |            \
windev1     windev2      windev3             

利用CVS WinCVS/CVSWeb/CVSTrac 构成了一个相对完善的跨平台工作组开发版本控制环境。

相关资源：

CVS HOME：
http://www.cvshome.org

CVS FAQ：
http://www.loria.fr/~molli/cvs-index.html

相关网站:
http://directory.google.com/Top/Computers/Software/Configuration_Management/Tools/Concurrent_Versions_System/

CVS--并行版本系统
http://www.soforge.com/cvsdoc/zh_CN/book1.html

CVS 免费书:
http://cvsbook.red-bean.com/

CVS命令的速查卡片 refcards.com/refcards/cvs/

WinCVS:
http://cvsgui.sourceforge.net/

CVSTrac: A Web-Based Bug And Patch-Set Tracking System For CVS
http://www.cvstrac.org

StatCVS：基于CVS的代码统计工具：按代码量，按开发者的统计表等
http://sourceforge.net/projects/statcvs

　P2P技术不仅为个人用户提供了前所未有的自由和便利，同时也试图有效地整合互联网的潜在资源，将基于网页的互联网转变成动态存取、自由交互的海量信息网络。

　P2P技术的发展以及P2P与网格技术的结合，将影响整个计算机网络的概念和人们的信息获取模式，真正实现“网络就是计算机，计算机就是网络”的梦想。

　　作为改变现有Internet应用模式的主要技术之一，计算机对等网络(P2P)是目前新一代互联网技术研究的热点之一。

　　自1999年以来，P2P的研究得到了国内外学术界和商业组织的广泛关注，同时，由于P2P本质特性不可避免地存在着许多社会、法律和技术上的问题，在学术界和产业界也一直存在着一些怀疑的力量，这在很长一段时期使人们难以对P2P做出一个准确和公平的判断。

　　本文较为完整地分析了P2P网络的4种典型结构，并对P2P的主要应用模式、存在的问题以及可能的发展方向进行简要阐述。

1 P2P网络模型
　　P2P网络是一种具有较高扩展性的分布式系统结构，其对等概念是指网络中的物理节点在逻辑上具有相同的地位，而并非处理能力的对等。以Napster软件为代表的P2P技术其实质在于将互联网的集中管理模式引向分散管理模式，将内容从中央单一节点引向网络的边缘，从而充分利用互联网中众多终端节点所蕴涵的处理能力和潜在资源。相对于传统的集中式客户/服务器(C/S)模型，P2P弱化了服务器的概念，系统中的各个节点不再区分服务器和客户端的角色关系，每个节点既可请求服务，也可提供服务，节点之间可以直接交换资源和服务而不必通过服务器。

　　P2P系统最大的特点就是用户之间直接共享资源，其核心技术就是分布式对象的定位机制，这也是提高网络可扩展性、解决网络带宽被吞噬的关键所在。迄今为止，P2P网络已经历了三代不同网络模型，各种模型各有优缺点，有的还存在着本身难以克服的缺陷，因此在目前P2P技术还远未成熟的阶段，各种网络结构依然能够共存，甚至呈现相互借鉴的形式。

1.1 集中目录式结构
　　集中目录式P2P结构是最早出现的P2P应用模式，因为仍然具有中心化的特点也被称为非纯粹的P2P结构。用于共享MP3音乐文件的Napster是其中最典型的代表，其用户注册与文件检索过程类似于传统的C/S模式，区别在于所有资料并非存储在服务器上，而是存贮在各个节点中。查询节点根据网络流量和延迟等信息选择合适的节点建立直接连接，而不必经过中央服务器进行。这种网络结构非常简单，但是它显示了P2P系统信息量巨大的优势和吸引力，同时也揭示了P2P系统本质上所不可避免的两个问题：法律版权和资源浪费的问题。

1.2 纯P2P网络模型
　　纯P2P模式也被称作广播式的P2P模型。它取消了集中的中央服务器，每个用户随机接入网络，并与自己相邻的一组邻居节点通过端到端连接构成一个逻辑覆盖的网络。对等节点之间的内容查询和内容共享都是直接通过相邻节点广播接力传递，同时每个节点还会记录搜索轨迹，以防止搜索环路的产生。

　　Gnutella模型是现在应用最广泛的纯P2P非结构化拓扑结构，它解决了网络结构中心化的问题，扩展性和容错性较好，但是Gnutella网络中的搜索算法以泛洪的方式进行，控制信息的泛滥消耗了大量带宽并很快造成网络拥塞甚至网络的不稳定。同时，局部性能较差的节点可能会导致Gnutella网络被分片，从而导致整个网络的可用性较差，另外这类系统更容易受到垃圾信息，甚至是病毒的恶意攻击。

1.3 混合式网络模型
　　Kazaa模型是P2P混合模型的典型代表，它在纯P2P分布式模型基础上引入了超级节点的概念，综合了集中式P2P快速查找和纯P2P去中心化的优势。Kazaa模型将节点按能力不同(计算能力、内存大小、连接带宽、网络滞留时间等)区分为普通节点和搜索节点两类(也有的进一步分为三类节点，其思想本质相同)。其中搜索节点与其临近的若干普通节点之间构成一个自治的簇，簇内采用基于集中目录式的P2P模式，而整个P2P网络中各个不同的簇之间再通过纯P2P的模式将搜索节点相连起来，甚至也可以在各个搜索节点之间再次选取性能最优的节点，或者另外引入一新的性能最优的节点作为索引节点来保存整个网络中可以利用的搜索节点信息，并且负责维护整个网络的结构。

　　由于普通节点的文件搜索先在本地所属的簇内进行，只有查询结果不充分的时候，再通过搜索节点之间进行有限的泛洪。这样就极为有效地消除纯P2P结构中使用泛洪算法带来的网络拥塞、搜索迟缓等不利影响。同时，由于每个簇中的搜索节点监控着所有普通节点的行为，这也能确保一些恶意的攻击行为能在网络局部得到控制，并且超级节点的存在也能在一定程度上提高整个网络的负载平衡。

　　总的来说，基于超级节点的混合式P2P网络结构比以往有较大程度的改进。
然而，由于超级节点本身的脆弱性也可能导致其簇内的结点处于孤立状态，因此这种局部索引的方法仍然存在一定的局限性。这导致了结构化的P2P网络模型的出现。

1.4 结构化网络模型
　　所谓结构化与非结构化模型的根本区别在于每个节点所维护的邻居是否能够按照某种全局方式组织起来以利于快速查找。结构化P2P模式是一种采用纯分布式的消息传递机制和根据关键字进行查找的定位服务，目前的主流方法是采用分布式哈希表(DHT)技术，这也是目前扩展性最好的P2P路由方式之一。由于DHT各节点并不需要维护整个网络的信息，只在节点中存储其临近的后继节点信息，因此较少的路由信息就可以有效地实现到达目标节点，同时又取消了泛洪算法。该模型有效地减少了节点信息的发送数量，从而增强了P2P网络的扩展性。同时，出于冗余度以及延时的考虑，大部分DHT总是在节点的虚拟标识与关键字最接近的节点上复制备份冗余信息，这样也避免了单一节点失效的问题。

　　目前基于DHT的代表性的研究项目主要包括加州大学伯克利分校的CAN项目和Tapestry项目，麻省理工学院的Chord项目、IRIS项目，以及微软研究院的Pastry项目等。这些系统一般都假定节点具有相同的能力，这对于规模较小的系统较为有效。但这种假设并不适合大规模的Internet部署。同时基于DHT的拓扑维护和修复算法也比Gnutella模型和Kazaa模型等无结构的系统要复杂得多，甚至在Chord项目中产生了“绕路”的问题。事实上，目前大量实际应用还大都是基于无结构的拓扑和泛洪广播机制，现在大多采用DHT方式的P2P系统缺乏在Internet中大规模真实部署的实例，成功应用还比较少见。

2 P2P网络应用模式
　　Internet最初产生和发展的一个主动力就是资源共享，也正是文件交换的需求直接导致了P2P技术的兴起，这是P2P最初也是最成功的应用之一，也正是针对这类应用的Napster使得人们在客户/服务器模式下开始重新认识P2P思想对人们使用网络习惯的影响。

　　随着人们对P2P思想的理解和技术的发展，作为一种软件架构，P2P还可以被开发出种类繁多的应用模式，除了最初的文件交换之外，还出现了一些分布式存储、深度搜索、分布式计算、个人即时通信和协同工作等新颖应用。其中最著名的例子是基于分布式计算的搜索外星文明SETI@home科学实验，每个志愿参加者只需下载并运行类似屏幕保护的方式，就可以贡献自己闲置的计算能力，参与分析Arecibo射电望远镜的无线电磁波数据并回送计算数据，截至2004年12月，已有528万志愿者参加进来，获得了相当于216万年的CPU时间，仅一天的综合计算就相当于67.46Tflops运算。另外，随着SUN公司将其JXTA协议扩展到诸如个人数字助理(PDA)和移动电话等手持终端上，并允许人们屏蔽具体的物理平台进行资料共享和文件交换等，P2P技术在移动通信和智能网领域也开始呈现出较大应用前景。

3 P2P网络存在的问题
　　P2P最大的优点在于能够提供可靠的信息查询，但从社会和法律意义来说，绝大多数的P2P服务都将不可避免地遇到知识产权冲突，也可能成为一些非法内容传播的平台。同时由于缺乏中心监管以及自由平等的动态特性，自组织的P2P网络在技术层面也有许多难以解决的问题。

　　从某种意义上来说，P2P网络和人际网络具有一定的相似性。一般来说，每个P2P网络都是众多参与者按照共同兴趣组建起来的一个虚拟组织，节点之间存在着一种假定的相互信任关系，但随着P2P网络规模的扩大，这些P2P节点本质所特有的平等自由的动态特性往往与网络服务所需要的信任协作模型之间产生矛盾。激励作用的缺失使节点间更多表现出“贪婪”、“抱怨”和“欺诈”的自私行为，因此P2P中预先假设的信任机制实际上非常脆弱，同时这种信任也难以在节点之间进行推理，导致了全局性信任的缺乏，这直接影响了整个网络的稳定性与可用性。此外，相对于传统客户/服务器模式的服务器可以做主动和被动的防御，由于P2P节点安全防护手段的匮乏以及P2P协议缺乏必要的认证机制和计算机操作系统的安全漏洞，安全问题在P2P网络中更为严重，这将直接影响P2P的大规模商用。另外，P2P网络中的节点本身往往是计算能力相差较大的异构节点，每一个节点都被赋予了相同的职责而没有考虑其计算能力和网络带宽，局部性能较差的点将会导致整体网络性能的恶化，在这种异构节点的环境中难以实现优化的资源管理和负载平衡。同时，由于用户加入离开P2P网络的随意性使得用户获得目标文件具有不确定性，导致许多并非必要的文件下载，而造成大量带宽资源的滥用。特别是大多数P2P用户更喜欢传送音频、视频这些较大的媒体文件，这将使得带宽浪费问题更为突出，尤其在中国大量的用户还是拨号用户，较窄的带宽也成为P2P应用难以逾越的障碍。

4 结论与展望
　　P2P技术在最近几年获得了高速的发展，也出现了较多应用，但截至目前，P2P中仍有很多的关键技术问题并没有得到解决，其中最典型的就是带宽吞噬、网络可扩展性差和路由效率低下等问题。这导致P2P至少在目前的技术水平而言只能是一种小范围不可靠的应用或是满足特定任务需求的专门应用。并且，作为一种潜在的商业应用，如何在P2P网络中有效地保护知识产权以及如何设计盈利模式将会面临更为严格的考验。

　　未来的网络将呈现大规模分布式、全球性计算和全球性存储的特征，从长远的趋势来看，对于访问和传输服务的需求必将远远大于对于计算功能的需要。尽管P2P技术现在还不成熟，但是迄今为止，至少在理论上P2P仍是最有吸引力的个人通信技术。尤其是P2P与网格技术的结合将是分布式计算技术最有吸引力的发展趋势，虽然现在还没有成熟的方案，但随着分布式系统经典问题的解决以及优化的资源动态分配和资源恢复技术的成熟，P2P与网格技术必将结合起来以影响整个计算机网络的概念和人们的信息获取模式。