计算机防火墙论文

计算机防火墙论文
【 摘要 】：防火墙是目前网络安全领域广泛使用的设备，其主要目的就是限制非法流量，以保护内部子网。从部署位置来看，防火墙往往位于网络出口，是内部网和外部网之间的唯一通道，因此提高防火墙的性能、避免其成为瓶颈，就成为防火墙产品能否成功的一个关键问题。
本文引用了叙述性的文字概述了防火墙的概念、功能及类型等，让我们全面了解了一个理论上的防火墙。描述了一个模拟的大型离散事件可视化网络仿真器NS-2（Network Simulator V.2）在Windows下的安装过程与出错处理。本文的重点是提出了对防火墙过滤规则进行优化的方案，对通过防火墙的数据包进行统计分析，并根据统计数据动态调整过滤规则的相对次序，使得使用最频繁的规则位于规则列表的最前面，使其和当前网络流量特性相一致，从而达到降低后继数据包规则匹配时间、提高防火墙性能之目的，并在Windows下利用仿真器NS-2对两个方案（一方案：不采用此优化算法，二方案：采用此优化算法）进行仿真实验，通过对仿真结果的比较分析得出此优化算法真的能提高防火墙的性能。
 【 关键词 】：NS-2、防火墙、规则匹配、统计分析
【 Abstract 】: Firewall is the present network safe field equipment used extensively, its major purpose is to restrict illegal rate of flow in order to protect internal son net. From disposition location, firewall is often located in network export , is the only passageway between internal net and external net , therefore raises the performance of firewall , avoid it to become bottleneck , become firewall product whether a successful key problem.
This paper has quoted the writing of statement, is general to have stated type, function and the concept of firewall, leting us overall have known one theoretically firewall. It is analog to have described one Large scale dispersed incident visualized network emulator NS-2(Network Simulator V.2) when WindowsNext installation process and make mistakes to handle. This paper focal point is put forward for firewall filter rule carry out optimization scheme, for through firewall data bale carry out statistics analysis, and according to statistics data development adjustment filter rule relative order, make use most frequently rule is located in rule list before most, make it with current network rate of flow property appearance consistent, so reach reduction succeed data bale rule match time , raising firewall performance purpose, and in WindowsNext use Emulator NS-2Is for two schemes ( the case of one side: Do not adopt this optimization algorithm and 2 schemes: Adopt this optimization algorithm) carry out emulation experiment, can really raise the performance of firewall through reaching this optimization algorithm for the trade off study of emulation result.  
【 Keywords 】：NS-2、Firewall、Rule- matching、Statistic Analysis   3

计算机防火墙论文
引 言
近年来，随着网络的迅速发展，网络安全已经成为人们日益关心的问题。当前，网络面临的安全威胁大体上分为两种：一种是对网络数据的威胁；另一种是对网络设备的威胁。其中，来自外部或内部人员的恶意攻击和入侵是当前因特网所面临的最大威胁，是电子商务、政府上网工程等顺利发展的最大障碍，也是企业网络安全策略最需要解决的问题。目前解决网络安全问题的最有效办法是采用防火墙。因特网的迅速发展为人们提供了发布信息和检索信息的场所，但也带来了信息被污染或被破坏的危险，人们为了保护其数据和资源安全，发明了防火墙。防火墙从本质上说是一种保护装置，它主要用于保护数据、资源和用户的声誉。从部署位置来看，防火墙往往又位于网络出口，是内部网和外部网之间的唯一通道，因此提高防火墙的性能、避免其成为瓶颈，就成为防火墙产品能否成功的一个关键问题。
第一章  绪 论
1.1 防火墙概述
 
防火墙原是用于建筑物大厦防止火灾从大厦的一部分传播到另一部分。从理论上讲Internet 防火墙也类似于此目的。防火墙用于在内部网和外部网之间构造一个保护层。网络安全上所说的防火墙，是指在两个网络之间加强访问控制的一整套装置，是内部网络与外部网络之间的安全防范系统，通常安装在内部网络与外部网络的连接点上。所有来自Internet(外部网)的传输信息或从内部网络发出的信息都必须穿过防火墙。从逻辑上讲，防火墙是分离器、限制器、分析器。防火墙的物理实现方式又有所不同，通常一个防火墙由一套硬件(一个路由器或路由器的组合，一台主机)和适当的软件组成。
1.2 防火墙发展历史
 
第一代防火墙：该防火墙技术几乎与路由器同时出现，采用了包过滤技术。
　  第二、三代防火墙：1989年，贝尔实验室的Dave Presotto和Howard Trickey推出了第二代防火墙，即电路层防火墙，同时提出了第三代防火墙——应用层防火墙（代理防火墙）的初步结构。
　  第四代防火墙：1992年，USC信息科学院的BobBraden开发出了基于动态包过滤（Dynamic packet filter）技术的第四代防火墙，后来演变为状态检测（Stateful inspection）技术。1994年，以色列的CheckPoint公司开发出了第一个采用这种技术的商业化的产品。
　  第五代防火墙：1998年，NAI公司推出了一种自适应代理（Adaptive proxy）技术，并在其产品Gauntlet Firewall for NT中得以实现，给代理类型的防火墙赋予了全新的意义，可以称之为第五代防火墙。
1.3对网络安全构成威胁的主要因素
 
随着网络的广泛应用和普及，网络入侵行为、病毒破坏、垃圾邮件的处理和普遍存在的安全话题也成了人们日趋关注的焦点，做为网络边界的第一道防线，由最初的路由器设备配置访问策略进行安全防护，到形成专业独立的防火墙产品，已经充斥了整个网络世界。做为保护网络边界的安全产品，防火墙技术也已经逐步趋于成熟，并为广大用户所认可。但是防火墙所暴露的问题也慢慢的凸现出来，面对未来高端防火墙的发展趋势，无论是从用户还是产品供应商，都不可避免的推向了一种对新型防火墙技术需求的角度。
由于网络体系越来越复杂，应用系统越来越多，网络规模不断扩大，再加上与Internet的连接，网络用户也已经不单单是内部用户。由于内部网络直接与外部网络相连，对整个网络安全形成了巨大的威胁，因此整个网络承受着来自外部、内部、黑客、病毒等各方面威胁。
具体分析，对网络安全构成威胁的主要有以下几个因素：
（1） 黑客的攻击、入侵内部网络和外部网络之间的连接为直接连接，外部用户不但可以访问对外服务的服务器，同时也容易地访问内部的网络服务器，这样，由于内部和外部没有隔离措施，内部系统较容易遭到攻击。
（2）病毒的侵害通过网络传送的病毒和Internet的电子邮件夹带的病毒。来自Internet 的Web浏览可能存在的恶意Java/ActiveX控件。病毒、木马发送大量数据包，造成系统资源的消耗，以至系统停止服务，造成数据丢失，机器、网络系统瘫痪，必须断开网络逐一进行杀毒，增加网络工作量，影响正常工作。
（3）内部的无限制访问内部用户的恶意攻击、误操作；访问不健康的站点，获取有害信息；工作学习时间无限制上网，游戏、聊天等。
（4）系统存在的漏洞缺乏一套完整的安全策略、政策，缺乏有效的手段监视、评估网络系统和操作系统的安全性。目前流行的许多操作系统均存在网络安全漏洞，如UNIX服务器，NT服务器及Windows桌面PC等。
1.4 防火墙的功能
1.防火墙是网络安全的屏障
一个防火墙（作为阻塞点、控制点）能极大地提高一个内部网络的安全性，并通过过滤不安全的服务而降低风险。由于只有经过精心选择的应用协议才能通过防火墙，所以网络环境变得更安全。如防火墙可以禁止诸如众所周知的不安全的NFS协议进出受保护网络，这样外部的攻击者就不可能利用这些脆弱的协议来攻击内部网络。防火墙同时可以保护网络免受基于路由的攻击，如IP选项中的源路由攻击和ICMP重定向中的重定向路径。防火墙应该可以拒绝所有以上类型攻击的报文并通知防火墙管理员。

计算机防火墙论文
2.防火墙可以强化网络安全策略
　　通过以防火墙为中心的安全方案配置，能将所有安全软件（如口令、加密、身份认证、审计等）配置在防火墙上。与将网络安全问题分散到各个主机上相比，防火墙的集中安全管理更经济。例如在网络访问时，一次一密口令系统和其它的身份认证系统完全可以不必分散在各个主机上，而集中在防火墙一身上。
3.对网络存取和访问进行监控审计
如果所有的访问都经过防火墙，那么，防火墙就能记录下这些访问并作出日志记录，同时也能提供网络使用情况的统计数据。当发生可疑动作时，防火墙能进行适当的报警，并提供网络是否受到监测和攻击的详细信息。另外，收集一个网络的使用和误用情况也是非常重要的。首先的理由是可以清楚防火墙是否能够抵挡攻击者的探测和攻击，并且清楚防火墙的控制是否充足。而网络使用统计对网络需求分析和威胁分析等而言也是非常重要的。
4.防止内部信息的外泄
通过利用防火墙对内部网络的划分，可实现内部网重点网段的隔离，从而限制了局部重点或敏感网络安全问题对全局网络造成的影响。再者，隐私是内部网络非常关心的问题，一个内部网络中不引人注意的细节可能包含了有关安全的线索而引起外部攻击者的兴趣，甚至因此而暴漏了内部网络的某些安全漏洞。使用防火墙就可以隐蔽那些透漏内部细节如Finger，DNS等服务。Finger显示了主机的所有用户的注册名、真名，最后登录时间和使用shell类型等。但是Finger显示的信息非常容易被攻击者所获悉。攻击者可以知道一个系统使用的频繁程度，这个系统是否有用户正在连线上网，这个系统是否在被攻击时引起注意等等。防火墙可以同样阻塞有关内部网络中的DNS信息，这样一台主机的域名和IP地址就不会被外界所了解。
除了安全作用，防火墙还支持具有Internet服务特性的企业内部网络技术体系VPN（虚拟专用网）。
1.5 防火墙所具有的基本特性    （一）内部网络和外部网络之间的所有网络数据流都必须经过防火墙     这是防火墙所处网络位置特性，同时也是一个前提。因为只有当防火墙是内、外部网络之间通信的唯一通道，才可以全面、有效地保护企业网部网络不受侵害。     根据美国国家安全局制定的《信息保障技术框架》，防火墙适用于用户网络系统的边界，属于用户网络边界的安全保护设备。所谓网络边界即是采用不同安全策略的两个网络连接处，比如用户网络和互联网之间连接、和其它业务往来单位的网络连接、用户内部网络不同部门之间的连接等。防火墙的目的就是在网络连接之间建立一个安全控制点，通过允许、拒绝或重新定向经过防火墙的数据流，实现对进、出内部网络的服务和访问的审计和控制。     典型的防火墙体系网络结构如下图所示。从图1.1可以看出，防火墙的一端连接企事业单位内部的局域网，而另一端则连接着互联网。所有的内、外部网络之间的通信都要经过防火墙。若图片无法显示请联系QQ3710167

图1.1    （二）只有符合安全策略的数据流才能通过防火墙     防火墙最基本的功能是确保网络流量的合法性，并在此前提下将网络的流量快速的从一条链路转发到另外的链路上去。从最早的防火墙模型开始谈起，原始的防火墙是一台“双穴主机”，即具备两个网络接口，同时拥有两个网络层地址。防火墙将网络上的流量通过相应的网络接口接收上来，按照OSI协议栈的七层结构顺序上传，在适当的协议层进行访问规则和安全审查，然后将符合通过条件的报文从相应的网络接口送出，而对于那些不符合通过条件的报文则予以阻断。因此，从这个角度上来说，防火墙是一个类似于桥接或路由器的、多端口的（网络接口>=2）转发设备，它跨接于多个分离的物理网段之间，并在报文转发过程之中完成对报文的审查工作。若图片无法显示请联系QQ3710167

图1.2
    （三）防火墙自身应具有非常强的抗攻击免疫力     这是防火墙之所以能担当企业内部网络安全防护重任的先决条件。防火墙处于网络边缘，它就像一个边界卫士一样，每时每刻都要面对黑客的入侵，这样就要求防火墙自身要具有非常强的抗击入侵本领。它之所以具有这么强的本领防火墙操作系统本身是关键，只有自身具有完整信任关系的操作系统才可以谈论系统的安全性。其次就是防火墙自身具有非常低的服务功能，除了专门的防火墙嵌入系统外，再没有其它应用程序在防火墙上运行。当然这些安全性也只能说是相对的。若图片无法显示请联系QQ3710167

图1.3
1.6 防火墙的基本类型
 
根据防火墙所采用的技术，防火墙主要分为分组过滤、应用代理、复合型这几大类。
（一）分组过滤型防火墙
包过滤是最简单的防火墙。数据分组过滤或包过滤，就是在网络中适当的位置，依据系统内设置的过滤规则，对数据包实施有选择的通过，包过滤原理和技术可以认为是各种网络防火墙的基础构件，防火墙经常利用包过滤路由器进行对IP 包过滤的工作，称为包过滤路由器。包过滤网关在收到数据包后，先扫描报文头，检查报文头中的类型TCP、UDP 等)源IP 地址、目的IP 地址和目的TCP/UDP 端口等域，然后将安全规则库中的规则应用到该报文头上，以决定是转发出去还是丢弃，管理员可以根据自己的安全规则来配置路由器。数据包过滤的优点有：一个数据包过滤路由器能协助保护整个网络；数据包过滤不要求任何自定义软件或客户机配置；许多路由器可以做数据包过滤。虽然数据包过滤有许多优点，但它也存在一些不足；当前的过滤工具不是完美的；一些协议不适合于数据包过滤；正常的数据包过滤路由器无法执行某些策略。
（二）应用代理型防火墙
应用代理型防火墙是内部网与外部网的隔离点，起着监视和隔绝应用层通信流的作用。代理服务是运行在防火墙主机上的专门的应用程序或服务器程序，这些程序根据安全策略接受用户对网络服务的请求并将它们转发到实际的服务，由于代理提供替代连接并充当服务的网关，因而，代理有时被称为应用级网关。代理服务不允许通信直接经过外部网和内部网。所以跨越防火墙的网络通信链路分为两段：外部主机和代理服务器主机之间的连接，以及代理服务器主机和内部主机之间的连接。代理服务器检查来自代理客户的请求，根据安全策略认可和否认这些请求。代理服务器不仅仅能够转送用户的请求到真正的网络主机，代理服务器还能够控制用户能做什么，根据安全策略，请求可以被允许或拒绝。使用代理服务有很多优点：代理服务允许用户直接的使用网络服务。代理服务器能够优化日志服务。使用代理服务同时也存在着一些缺点：代理服务落后于非代理服务。对于每项服务代理可能要求不同的服务器。代理服务通常要求对客户、过程之一或对两者同时进行限制。代理服务对于一些服务是不适用的。代理服务不能保护所有协议的弱点。
（三）复合型防火墙
复合型防火墙将数据包过滤和代理服务结合在一起使用，从而实现了网络安全性、性能和透明度的优势互补。随着技术的发展，防火墙产品还在不断完善、发展，目前出现的
计算机防火墙论文
新技术类型主要有以下几种：状态监视技术、安全操作系统、自适应代理技术、实时侵入检测系统等。混合使用数据包过滤技术、代理服务技术和其他一些新技术是未来防火墙的趋势。
 
1.7 防火墙的选择和实施
 
（一）选择
防火墙是一类防范措施的总称，简单的防火墙可以只用路由器实现，复杂的要用一台主机甚至一个子网来实现，它可以在IP 层设置屏障，也可以用应用层软件来阻止外来攻击，所以我们要根据实际需要，对防火墙进行选择应用，技术人员的任务是权衡利弊，在网络服务高效灵活、安全保障和应用成本之间找到一个“最佳平衡点”，我们通过对防火墙的评价、分析来决定采用什么样的防火墙。
1.对防火墙的主要类型和各种类型的优缺点要有所了解；
2.防火墙的稳定性和它所支持的平台种类，一个防火墙产品用户群的大小可以很好的体现其稳定性；
3.本单位愿意为防火墙投资多少经费；
4.本单位的技术力量如何，能否维护那些维护量大的防火墙。
（二）管理和维护
选择、安装适合的防火墙后，我们还要对防火墙进行管理和维护，这是是一项长期而细致的工作，其目的是使防火墙正常发挥作用并延长使用寿命。管理和维护的主要要求有：
1.管理维护人员必须经过一定的专业培训，对单位自身的网络必须有一个清楚的了解和认识；
2.定期进行扫描和检测，以便及时发现问题，及时堵上漏洞；
3.保证系统监控及防火墙通信线路畅通，使发生的安全问题能及时报警，及时处理有关安全信息；
4.分清工作重点，根据不同时期或不同时间进行网络安全监控；
5.由于防火墙技术还处于发展阶段，不能把网络安全的重任全部压在防火墙上；
6.要与厂家保持联系，以便及时获得有关升级、维护信息。
1.8 防火墙仿真的重要意义
 
众所周知, 防火墙是目前最为流行也是最为广泛的一种网络安全技术, 它最大限度地阻止了网络中的黑客来访问自己的网络, 防止他们进行非法的更改、复制和毁坏网络内重要信息。虽然防火墙的技术在迅速的发展，但是还是存在着许多缺陷。人们对防火墙技术的研究一直在继续着。长时间以来，大多数人反映对这方面的研究枯燥，其实，这主要是因为防火墙原理涉及到很多协议和算法，这些内容在传统的实验环境下很难模拟或成本太高。为此，我们引入了仿真技术，仿真技术不仅可以演示防火墙的工作原理，通过自己修改协议参数来改进协议并进行验证，还可以模拟网络拓扑和一些网络设备的工作方式。对防火墙的仿真在一定程度上方便了研究，大大提高了效率。
1.9 章节构架
 
本文对过滤规则在一定时间内的使用频率进行统计分析，并根据分析结果动态调整规则在规则列表中的相对次序，使得使用最频繁的规则位于规则列表的最前面，从而达到降低后继数据包规则匹配时间、提高防火墙性能之目的。本文分为以下几个部分：
第一章为绪论，具体介绍了防火墙的概念极其一些理论说明了防火墙仿真的重要意义。
第二章为网络仿真软件的介绍，介绍了目前比较常用的仿真软件，着重介绍免费软件NS-2，及NS-2的安装过程。对NS-2的构成跟仿真原理进行了一番阐述，研究分析了NS的主代码的基类跟功能模块。
第三章为基于统计分析的防火墙规则匹配优化算法，说明了此优化算法确实能提高防火墙的性能。
第四章为仿真实验及结果，写出了这次仿真实验的结果及对结果的分析附上了一些代码。
第五章为总结，为本研究做一总结也阐述了此优化算法同样适宜别的研究。
计算机防火墙论文
第二章  网络仿真软件NS-2介绍
网络仿真软件是网络性能理论分析、评估网络设计方案以及网络故障诊断的有力工具。在网络系统方案设计阶段，对于规模稍大的互连网络目前还没有哪个理论能够对其进行较精确的分析，一般都是依靠仿真的方法对设计方案进行评估，这对于减少投资风险，降低网络实现费用等都有着巨大的好处。在网络仿真软件中，比较有名的有MIL3公司的OPNET软件、Cadence公司的VCC软件，这些软件一般的价格都在20-30万美元左右， 每年还需要几万美元的服务费，对于研究单位、学校甚至大型的公司来讲都是一笔巨大的投资。除了上面的商业软件，在网络仿真领域还有一些免费软件、这里面比较有名的就是VINT的ns-2（Network Simulator V.2）软件。
2.1 NS-2 网络仿真软件介绍
 
在研究和设计网络协议时通常需要利用仿真软件对其性能进行测试和评价,NS 作为一种免费软件,以其协议代码与真实网络应用代码的相似性和仿真结果的可靠性,成为众多仿真软件中的首选。NS 是一种面向对象的离散事件驱动的网络模拟器, 支持多个流行的网络协议如各个版本的TCP、UDP 和路由调度、拥塞控制算法等。NS源代码完全公开,可供使用者在Unix、Linux、Windows 等系统平台上使用和进行二次开发,并可以提供有线网络、无线网络中链路层及其高层精确到数据包的诸多网络行为的模拟与仿真,目前国内利用该模拟器来仿真和分析的研究人员也逐渐开始增多。
2.1.1 NS构成与仿真原理
NS 是一个面向对象的、一个可扩展的、容易配置的、可编程的事件驱动仿真引擎( simulation engine) , 由LBNL(Lawrence Berkeley National Laboratory) 的网络研究组研制开发,是DARPA 支持的VINT 项目的核心部分,其源代码全部公开,提供开放的用户接口,可用于各类IP 网络模拟。
（1）NS 软件包及NS2 的基本结构
NS 软件包主要包括Tcl/ Tk、OTcl 、NS、Tclcl 四部分。软件包各个部分的相互联系可由图2.1来简单刻画。若图片无法显示请联系QQ3710167

图2.1
OTcl 是Tcl（Tool Command Language) 的面向对象扩展,是NS 的仿真描述语言。NS 仿真器共用到了六种Otcl 接口类,分别是Tcl 类、TclObject 类、TclCommand 类、EmbededTcl 类和InstVar 类。其中TclObject 在类的层次结构中处于最高层,所有其他主要的类都从它派生而来。它有一个静态链表记录了用户创建的所有对象,每一个对象都有一个唯一的标识,记录了每个对象所属的类名。InstVar 类定义了一些方法和机制,在编译类结构对象的成员变量和对应的解释类结构对象的成员变量之间建立映射,使两类变量一致共享; TK是Tcl 的图形界面开发工具,帮助用户在图形环境中开发图形界面。
NS 是整个软件的核心,采用编译和解释双层结构,编译层由C+ + 类组成,它的前端是一个Otcl解释器。仿真器内核定义了有层次结构的多种类,称为编译类结构;在Otcl 解释器中有相似的类结构,称为解释类结构。用户通过解释器创立新的仿真对象之后,解释器对它进行初始化,与编译类结构中相应的对象建立映射。从用户的角度看,C + +代码层与OTcl 代码层是一一对应的。NS 中同时使用两种语言是因为C + + 语言执行速度快而修改和编译速度慢,故只用于编译层协议细节的实现,而Otcl 修改快且可用于交互操作,用于解释层中仿真对象的设置。NS 采用策略跟机制分离的原则,提高了代码的重用率;同时为了降低分组和事件的处理时间,事件调度器和基本的网络元素用C + + 进行编译,C + + 对象的控制权交给Otcl 。
NS 由事件调度器( Event Schedualer) 、网络元素对象库和网络设置模型库三个主要部分组成。其中调度器是仿真器的重要组成部分,它记录当前时间,调度网络事件链表中的事件。它有一个静态成员变量instance-供所有的类访问同一个调度器,并提供函数产生新事件,指定事件发生的时间。事件和TCP 分组( Event&TCP Packet) 事件表示仿真器产生的实际事件,包括事件产生的时间、处理事件的事件处理器(是指所有处理事件类的基类,它只是一个虚拟函数,每个继承类实现自己的功能) 。网络元素对象包括节点、链路、代理(Agent) 、业务追踪(Trace) 和数据源等;节点、链路、代理同时继承了NsObject 和事件处理器类,来处理多项事务;代理是实际产生和消费分组的对象,它们属于传输层实体,运行在端主机(模拟) ,节点的每一个代理自动被赋与一个唯一的端口号(模拟TCP/ UDP 端口) 。NS 提供了丰富的网络元素,使用者只需要熟悉相关研究方向的基本元素,其它的可做“透明”处理。Tclcl 用于提供C + + 和OTcl 之间的接口,使对象和变量能同时出现在两种语言中。
（2）NS 仿真原理
用户在用NS 仿真器进行仿真工作以前,首先需要分析该仿真过程所涉及是解释层还是编译层。
如果仅涉及解释层,则只需要利用现成的网络元素编写OTcl 脚本,构造合适的网络拓扑并确定链路的基本特性(如延迟、带宽和丢包策略等) 以及对节点的特性化配置(如进行节点的代理、路由协议、事件调度等的初始化) ;此外还要建立追踪文件对仿真过程中用户感兴趣的网络元素的变化或特定的网络现象进行跟踪,以便于仿真过程结束后用XGraph进行静态或者用NAM(Network Animator) 进行动态分析。其中NAM可以表现仿真的全部宏观过程,显示从开始到结束整个过程中的拓扑结构、代理行为和链路状态;XGRAPH 用__于对网络微观特性进行跟踪纪录并生成图形。此类模拟主要用于加深对网络协议和算法的形象理解和网络协议类教学。
如果仿真方案涉及C + + 代码层,途径有二,其一根据现有网络元素的C + + 代码进行某个算法修改或增加某个功能的实现来满足对一些现有协议功能完善的类的仿真;其二通过编写全新的协议代码,满足一些网络工程师新的设计需要。建立新的协议必须注意以下几个问题:
1) 首先必须定义头文件,包括数据结构和新代理的继承结构,并建立适当的类定义;
2) 定义C + + 代码和OTcl 代码之间的接口连接;
3) 定义接收函数recv() 和Tcl 命令触发函数Command ( )及时钟类函数等必要的函数;
4) 新协议代码完成后需对相关程序进行必要改动,并在NS 目录下运行Make Depend 和Make ,重新编译NS 内核,直至生成新的NS。使用NS2 进行网络仿真,最终目的是要得到实验的结果。NS 提供跟踪和监视两种方式收集输出数据并存到指定文件中,来对仿真结果进行评价。其中跟踪是指使用trace - all 记录每个包在队列或链路的行为(到达、离开、丢弃等) ;它的输出文件为:

计算机防火墙论文
+ 1. 13450 tcp 1000 ———21. 1. 3. 2. 24 184
- 1. 13450 tcp 1000 ———21. 1. 3. 2. 24 184
+ 1. 13450 tcp 1000 ———21. 1. 3. 2. 24 184
- 1. 13450 tcp 1000 ———21. 1. 3. 2. 24 184
+ 1. 26454 cbr 300 ———13. 01. 0 37 186
r 1. 26570 ack 40 ———23. 21. 1 12 179
　　⋯⋯
各列的具体含义解释如下:第1 列表示跟踪类型( + 入队列、- 出队列、r 接收、d 丢弃) ;第2 列表示事件发生时间;第3、4列是源和目的节点号;第5 列是包类型;第六列表示包大小;第七列表示当前支持ECN;第8 列是IP 流标识号;9、10 两列表示源和目的地址;第11 列是流内顺序号;第12 列表示仿真生成包的标识号。而监视是指有选择的记录包的行为(如某链路上丢包的数目) 或使用流监视器(flow monitor) 记录每个流的情况。其输出数据包括事先约定的流标识、包类型、流的字节数,丢包数、丢包字节数等,最多可有19 项。监视获得的数据可在Linux 下用Xgraph 或Xmgr ,也可在Windows下用Excel 或Origin 等画图工具转换成便于观察和分析的X、Y坐标图。此外,在仿真的过程中可以启动NAM进行动态模拟,但是无法进行定量分析。整个流程从用户的角度看来如图2.2所示。

若图片无法显示请联系QQ3710167图2.2
所以说,用NS2 进行仿真的过程就是根据需要先对C + +编译层进行修改或建立新的协议集,然后编写OTcl 脚本源程序,包括用NS 命令定义网络拓扑结构、配置业务源、业务接收点、收集统计信息,然后启动NS 仿真器,调用其C + + 程序内核运行仿真,输出感兴趣的仿真结果,并对结果进行分析。
2.1.2 NS主代码的基类分析
NS基类共有6种，这一小节详细说明每一基类的作用、构造和工作机制。
Ø        Tcl类：C++代码与Tcl代码之间的桥梁;
Ø        TclObject类：所有仿真对象的基类;
Ø        TclClass类：定义了解释类的类层次，并允许用户实例化TclObject，与TclObject一一对应；
Ø        TclCommand类：封装了C++代码和Tcl代码相互调用命令的方法；
Ø        EmbeddedTcl类：封装了装载更高级别的内置命令的方法；
Ø        InstVar类：访问C++成员变量，如Otcl变量方法。
Tcl类最重要的功能有以下六种：
（1）获得访问Tcl实例的入口：
C++代码将整个Tcl平台视为一个类，首先取到访问此类的入口：
Tcl& tcl = Tcl::instance();
（2）通过解释器调用Otcl过程，总共有四种方法，对应有四个成员函数：
void eval(char *s)：通过调用解释器的Tcl_GlobalEval()执行命令*s。
void evalc(const char *s)：将串*s复制入内部buffer，然后调用[char *s]eval，完成对*s的执行。
void eval：假定命令已存入Tcl.bp_，先通过tcl.buffer()获得Tcp.bp_的指针p，然后调用tcl.eval（char *p）,执行命令*p。
void evalf(const char *fmt,…) 带不定个数的参数，第一参数*fmt为输出格式。
举例如下：
Tcl& tcl = Tcl::instance();
char wrk[128];
strcpy(wrk, "Simulator set NumberInterfaces_ 1");
tcl.eval(wrk);
sprintf(tcl.buffer(), "Agent/SRM set requestFunction_ %s", "Fixed");
tcl.eval();
tcl.evalc("puts stdout hello world");
tcl.evalf("%s request %d %d", name_, sender, msgid);
（3）与解释器交换结果：
解释器调用C++方法，期望将结果返回并写入私有成员变量tcl_->result。有两种方法：
tcl.result(const char *s)：将结果串*s写入tcl_->result。
tcl.resultf(const char* fmt, . . . )：按格式*fmt，将结果写入tcl_->result。
看个例子：    if (strcmp(argv[1], "now") == 0) {
tcl.resultf("%.17g", clock());
return TCL_OK;
}
tcl.result("Invalid operation specified");
return TCL_ERROR;
当C++方法调用Otcl命令时，解释器也将结果返回到tcl_->result，使用的方法是不带参数的tcl.result(void)，应该注意到返回的结果是字串，所以，还要将它转变成相应的数据类型。例如：
tcl.evalc("Simulator set NumberInterfaces_");
char* ni = tcl.result();
if (atoi(ni) != 1)
tcl.evalc("Simulator set NumberInterfaces_ 1");
（5）报告出错状况，并以统一方式退出：
相应的成员函数是：tcl.error(const char*s)，此函数将*s、tcl->result写入stdout，退出并置error code为1。
tcl.resultf("cmd = %s", cmd);
tcl.error("invalid command specified");
注：调用Tcl::error()，不同于函数tcl.result()中返回TCL_ERROR。后者在解释器内部产生一个异常，用户可以跟踪此异常，并有可能从错误中恢复，若用户没有指定任何跟踪，解释器将输出错误信息，并退出。但如果代码调用了error()，则仿真用户不能跟踪错误，同时，ns不会输出任何错误信息。
（5）存储、查找TclObject类对象：
ns将每一个TclObject对象的入口都存储在一个哈希表里，并以TclObject对象名为关键字，对哈希表进行操作。类Tcl提供了一组方法：
tcl.enter(TclObject*)：将一个指向TclObject对象的指针插入哈希表，通常是在生成一个新的对象时，由函数TclClass::create_shadow()调用。
tcl.lookup(char*)：参数为TclObject对象名，由TclObject::lookup()调用。
tcl.remove(TclObject*)：当需要释放一TclObject对象TclClass::delete_shadow()调用此函数。
注：以上三个函数只在类TclObject或类TclClass内部使用
（6）取解释器的句柄：
若以上的方法不够用，我们只好直接取到解释器的句柄，再自己写代码，获得解释器句柄的方法是：
tcl.interp(void)
（2） TclObject类：
类TclObject是ns中绝大多数类的基类，封装了绑定、跟踪和对相关命令的调用机制。
（1）    生成和释放：new{}和delete{}。
生成(create)：new操作返回类TclObject的解释对象。解释器调用对象的构造函数，初始函数init{}，还有相应的编译类的构造函数以生成相应的编译对象。最后，new{}返回对象的句柄。
详细过程如下：
Ø        New{}调用方法name(){}，在解释器的名字空间（name space）取一句柄返回给用户。通常，句柄由getid{}产生，为_o型, 此处是一整数。
Ø        执行新对象的构造函数，该构造函数会调用其父类的构造函数，最后会调用到TclObject的构造函数。
Ø        TclObject的构造函数为调用实例过程create-shadow（void）{}，构造编译对象，并完成一系列的初始化、绑定。
Ø        生成编译对象后，create_shadow(void) 还要完成以下工作：将新对象加入TclObjects哈希表中；为新的解释对象实现cmd{}，cmd{}过程将用来调用编译对象的command() 完成想要的操作。
注：以上的过程仅发生在用户通过解释器构造新的对象，而直接用C++代码生成对象不会如此。其流程图如下：若图片无法显示请联系QQ3710167

 

计算机防火墙论文
释放(deletion)：Delete操作将释放解释对象和相应的编译对象，可以说是new操作的逆过程。使用的语句是：delete scheduler_
（2）变量的绑定（bindding）
一般而言，编译代码只能访问编译变量，解释代码只能访问解释变量。因此，每一实体都由两个变量来表示，需要系统进行双向绑定。在这里，绑定的意思是，相应的两个变量时刻保持一致，当一方发生改变，另一方也要发生同样的变化。
变量的绑定有显式、隐式两种。隐式变量绑定是在初始化一个对象时，由编译对象的构造函数建立的。之后，解释对象便将它视为实例变量。
（4）变量的跟踪（Trace）
跟踪变量（traced variable）由C++ 或Tcl生成、修改。它又分为对解释变量的跟踪和对编译变量的跟踪。
对解释变量的跟踪：若想用Tcl代码对变量进行跟踪，则此变量必须是Tcl代码可见的，比如：已绑定的C++/Tcl变量，或是纯的Tcl变量。根据被跟踪变量的拥有者不同，可分两种情况：
1)         拥有者为自己，例如\$tcp跟踪自己的变量cwnd_：
\$tcp trace cwnd_
2)         拥有者为别人，例如，有一普通跟踪者\$tracer跟踪\$tcp的变量ssthresh_：
set tracer [new Trace/Var]
\$tcp trace ssthresh_ \$tracer
对编译变量的跟踪：被跟踪的变量必须属于TraceVar类的派生类。虚基类TracedVar的部分定义如下：
class TracedVar {
                     virtual char* value(char* buf) = 0;
protected:
TracedVar(const char* name);
const char* name_; // name of the variable
TclObject* owner_; // the object that owns this variable
TclObject* tracer_; // callback when the variable is changed
…… …… ……
};
TclCL库对int型和double型变量分别定义了两类TracedVar：TracedInt和TracedDouble。它们重载了所有的操作符。当变量的值发生改变时，用assign方法给变量赋新值，并调用tracer 。TracedInt和 TracedDouble还实现了value ，将变量的值转为串
（5）命令方法的定义和调用
ns为每一的TclObject 建立一个实例过程 cmd{}，cmd{}自动调用编译对象的command()函数。用户可以通过两种方法调用cmd{} ：显示调用，指定想要的操作为第一参数；或是隐式调用，就好像存在与想要的操作同名的实例过程。绝大多数的脚本使用后一种形式。我们先介绍这种方式，简单起见，以srmObject对象为例子：
SRM中有关距离的计算是由编译对象完成的，而由解释对象使用。调用如下：
$srmObject distance?  （agentAddress）
若不存在名为 distance? 实例过程，解释器将调用实例过程unknown{}，（在基类TclObject中定义），然后unknown{}调用：
$srmObject cmd distance? _ agentAddress
通过编译对象的command()过程来执行操作。
当然用户可以显式调用操作，好处是可以重载，对应的Otcl代码和C++代码如下：
Agent/SRM/Adaptive instproc distance? addr {
$self instvar distanceCache_
if ![info exists distanceCache_($addr)] {
set distanceCache_($addr) [$self cmd distance? $addr]
}
set distanceCache_($addr)
}
int ASRMAgent::command(int argc, const char*const*argv) {
Tcl& tcl = Tcl::instance();
if (argc == 3) {
if (strcmp(argv[1], "distance?") == 0) {
int sender = atoi(argv[2]);
SRMinfo* sp = get_state(sender);
tcl.tesultf("%f", sp->distance_);       
return TCL_OK;
}
}
return (SRMAgent::command(argc, argv));
}
int ASRMAgent::command（）函数有两个参数：
第一个参数(argc)指出命令行中的参数个数。
第二个为命令行参数向量，解释如下：argv[0]——方法名“cmd”；argv[1]——指定想要的操作；若用户还指定了其余参数，在argv[2...(argc - 1)]中。
参数是以字串形式给出的，应该先转化成相应的数据类型。
若操作匹配成功，返回操作结果，tcl.tesultf("%f", sp->distance_);
command() 必须返回TCL_OK或TCL_ERROR ；
如果操作不匹配，调用父类的command()函数，返回相应结果，若一直到最底层的基类都不匹配，返回错误信号。这样做，允许子类继承其父类的命令。
在多继承情况下，可以有两种选择：1、指定继承一个咐嗟腸ommand()；2、按某种顺序访问几个父类的command（），一找到匹配的，就不再试下一个，如果都不行，返回一个错误信号。
 
（3） TclClass类:
类TclClass是一个纯虚类，从它派生的子类需实现两个成员函数：其一是构造函数，构造解释类层次来镜像编译类层次；其二是生成函数，生成与之相对应的TclObjects对象。在~ns/tclcl.h中可以找到定义。
用个简单的例子说明一下整个的流程。比如，脚本中有这样一行：
set o [new B/A ]
则：对象o的解释构造函数在ns第一次启动时执行
Ø        此构造函数以解释类的名字B/A调用ABClass的构造函数
Ø        然后，ABClass构造函数将调用其父类TclClass的构造函数
Ø        TclClass构造函数存储类的名字，并将对象插入TclClass对象链中
Ø        在simulator的初始化过程中，Tcl_AppInit(void)调用TclClass::bind(void)。
bind()调用以解释类的名为参数register{}，
register{}建立类层次，生成需要而还没有的类。
Ø        最后，bind()为新类定义实例过程create-shadow和delete-shadow，生成并返回对象o。
其流程示意图如图2.4所示：若图片无法显示请联系QQ3710167

图2.4
 
（4） TclCommand类:
    类TclCommond的作用就在为解释器提供全局命令。
由TclCommand在C++中的定义（~ns/tclcl.h），可以看出，它也是个纯虚类，需要派生类实现实现两个成员函数：构造函数和command()。
比如，如果用户希望敲入命令：％ say  I am ns user返回：>hellow, I am ns user。
则我们可以从TclCommand派生出子类MyCommand，它的构造函数用“say”为参数，代码为：
class say_hello : public TclCommand {
public:say_hello();
int command(int argc, const char*const* argv);};
class MyClass：TclCommand（”say”）{}
然后，再实现MyCommand::command()即可。
注意:TclCommand定义里有一个dispatch_cmd()的静态函数，实现了从“say”

 

计算机防火墙论文
到子类MyCommand的匹配，并调用MyCommand::command（）。其流程图如图2.5所示：若图片无法显示请联系QQ3710167

图2.5
 
（5）EmbeddedTcl类:
用户对脚本tclcl/tcl-object.tcl进行修改，或是修改、增加tcl/lib的文件来对ns进行扩展。对于新文件的装载是由类EmbeddedTcl的对象来完成的。
Tcl脚本其实就是由char类型数据组成的文本文件，所以类Embedded的构造函数可以用char*型指针指向脚本代码，并将此指针值赋与成员变量 code_。EmbeddedTcl的定义中（tclcl/tclcl.h）有一load()成员函数。Load()用Tcl::instance()获得解释器句柄，然后调用Tcl::evalc，调用Tcl命令eval，完成对代码的装载：
void EmbeddedTcl::load()  { Tcl::instance().evalc(code_); }
（6） InstVar类:
类InstVar定义了显式实现绑定机制的方法。
绑定过程bind（）通常需要指定解释变量名和编译对象的成员变量的地址。基类InstVar的构造函数在解释器里创建一个实例变量，建立陷阱例程（trap routine），捕捉所有通过解释器对变量的访问。当解释器有对变量的读操作发生时，触发陷阱例程，陷阱例程调用适当的get函数，取对应的编译对象的成员变量的当前值，并给解释变量赋值。对写操作，只是触发时间略有不同，在解释器写完解释变量之后，触发陷阱例程，陷阱例程调用适当的set函数，将改变后的值写回编译对象。
类InstVar有一个成员变量tracedvar_指向类TracedVar对象，TracedVar对象封装了有关编译对象方面的信息和方法，定义如下（~/ns/tclcl/tracedvar.h）:
class TracedVar {
public:
       TracedVar();
       virtual char* value(char* buf, int buflen) = 0;
       inline const char* name() { return (name_); }          //取变量名
       inline void name(const char* name) { name_ = name; }  //置变量名
       inline TclObject* owner() { return owner_; }          //返回owner_
       inline void owner(TclObject* o) { owner_ = o; }       //置owner_
       inline TclObject* tracer() { return tracer_; }           //返回tracer_
       inline void tracer(TclObject* o) { tracer_ = o; }        //置tracer_protected:
       TracedVar(const char* name);
       const char* name_;                           //变量名
       TclObject* owner_;                         //拥有该变量的对象指针
       TclObject* tracer_;                          //当变量改变时回叫tracer_public:
       TracedVar* next_;                           //指向下一个TracedVar变量，形成队列
};
从基类InstVar又派生了五个子类：class InstVarReal、class InstVarTime、class InstVarBandwidth、class InstVarInt和class InstVarBool。分别用来绑定real型、time型、bandwidth型、integer型和boolean型变量。
2.1.3 NS主代码功能模块简析
NS对网络实体的仿真和各种功能模块都封装在派生类中。
首先澄清两个问题：
（1）由于NS是由C++代码与Otcl代码组成的，其派生类的构成也因此很复杂，会由相应的解释类与编译类绑定而成。解释类基本上是与编译类是相对应的，这里的对应，指的是名字相似的C++类与Otcl类一般实现对同一实体的仿真。但两者的作用是不一样的，一般说来，C++类实现底层的计算和操作，比如说路由计算、数据包的接收丢弃等等。Otcl类在高层配置节点和拓扑图，提供用户接口，调用C++代码完成实际工作。值得注意的是，许多复杂的解释类在C++代码里没有相应的编译类，比如说以下提到的类simulator，它由node、link等成员类组成，在C++里就没有相应的类。
 
（2）C++代码中的派生类大多数为TclObject和TclClass派生类。如前述，TclObject的派生类与TclClass的派生类几乎是一一对应的，每一TclClass派生类有一create()函数创建对应的TclObject对象。但两类之间有很多不同。网络中各实体、功能、结构大不一样，且本身就存在许多层次和组合。所以模拟网络实体的TclObject系列，结构都比较复杂，经常由几个相关类又组合成一个新的类，甚至会有多继承现象发生。而TclClass系列则简单得多，几乎所有的子类都不再有派生类，也就是说几乎所有的子类都直接从基类TclClass派生，只有一个特殊情况，就是它的子类PackHeaderClass派生出许多子类，比如ARPHeaderClass、encapHeaderClass等等。
1、仿真器类
整个仿真器是由一个Tcl的仿真器类(class Simulator)来描述的，它提供了一个接口的集合。这个接口集合被用于设置一个仿真过程和选择用于驱动仿真事件的调度程序类型。一个仿真的脚本文件一般情况下开始于建立这种类的实例，并且应用不同方法来建立结点拓扑结构和配置仿真的其它部分。
仿真器类是一个解释类，没有相应的编译类。但仿真器类是由许多更小的类构成的，这些类有相应的编译类。从ns外部看来，整个的仿真过程可以看成对仿真器的操作。因此，我们的工作从创建一个仿真器的实例对象开始，之后，通过这个仿真器调用各种方法生成节点，进而构造拓扑图，对仿真的各个方面进行配置，定义事件，然后，根据定义的事件，模拟整个网络活动的过程。
有关仿真器的文件有ns/tcl/lib/ns-lib.tcl，ns/scheduler.{cc,h}，和  ns/heap.h。相对于C++代码中类的构造函数，OTcl代码有类的初始化函数，仿真器类的初始化函数如下：
Simulator instproc init args {
             $self create_packetformat
             $self use-scheduler Calendar
             $self set nullAgent_ [new Agent/Null]
             $self set-address-format def
             eval $self next $args
}
在解释器中创建一个新的仿真器对象，初始化函数执行以下操作：
Ø      初始化数据包格式(又称create_packetformat)
Ø      创建一个调度员（scheduler）
调度员以事件驱动的方式控制仿真的运行，缺省的调度员为calendar scheduler。当然，用户可以指定别的调度员，以实现别的调度策略。目前可用的调度员有四种：Sceduler/Link，Sceduler/Heap，Sceduler/Calendar queue和Sceduler/RealTime。
Ø      创建一个“null agent”
语句set nullAgent_ [new Agent/Null]可以创建一个null agent，用来发送、接收一个数据包。
总的说来，仿真器提供了一系列的方法，可以分三类：创建、管理拓扑图(通过管理节点，和链来实现)，跟踪，协调函数与调度。
仿真器封装了许多功能模块，最基本的是节点、链路、代理、数据包格式等等。下面分别是这些模块的解释。
2、 事件调度器和事件
（1）事件调度器（event scheduler）
NS仿真器是一个以事件来驱使的仿真器，目前NS支持2种类型的事件调度器：非实时的（none real-time）和实时的（real-time）。非实时的调度器又分为3种:linked-list(链表)、heap(堆栈)、calendar (队列,这是缺省的scheduler)；从逻辑上说这3种scheduler是相同的，但他们采用的数据结构不同。之所以要保留3种scheduler，主要是为了使NS能够向前兼容，因此我们在使用非实时的scheduler时，一般只需要用缺省的calendar

 

计算机防火墙论文
scheduler就可以了。Scheduler的主要功能是处理分组（pack）的延迟和充当定时器。一个scheduler的执行过程是这样的；从所有事件中选择发生时刻最早的事件，调用它的handler函数，把该事件执行完毕，然后在剩余事件中选择发生时刻最早的事件执行，如此反复。NS 仿真器是单线程的，在任何给定的时刻它只能运行一个事件，如果多于一个事件要在同一时刻执行，它们的执行将按照事件代码插入的先后次序执行。
下面简单介绍一下这3个非实时的事件调度器。链表结构中按照时间先后顺序保存事件目录，通过查表方式插入和删除事件，通常用于FIFO 方式的仿真事件仿真中。在多事件应用中，堆栈结构优于链表结构，例如n 个事件的插入删除次数是O(logn) 。Calendar 队列类似一个全年的日历，年份不同但日月相同的事件可记录在一年的同一天中；它的执行效率更高，因此是目前NS中缺省的非实时事件调度器。
实时的事件调度器（Scheduler/RealTime类）尽可能使得事件的执行和真实的时间同步。目前它是用list Scheduler的一个子类实现的。NS该功能还在开发中，它能把一个NS的仿真网络引入到真实世界的拓扑中，但它只能在较慢的数据传输速率下工作。因为仿真器必须要能跟的上真实网络中的数据速率。
（2）事件
一个事件通常由触发时间（firing time）和Handler函数组成，Event类的定义如下（参考源文件ns/common/ Scheduler.h）：
class Event {
public:
      Event* next_;              /* 指向下一个需要被Scheduler执行的事件 */
      Handler* handler_;      /* 事件触发后Scheduler会调用handler_指向的函数*/
      double time_;        /* 事件的触发时间 */
      scheduler_uid_t uid_;   /* 事件编号 */
      Event() : time_(0), uid_(0) {}
};
class Handler {
 public:
      virtual void handle(Event* event) = 0;
};
与本节相关的Tcl命令：
Ø      set ns [new Simulator]；#建立仿真对象的一个实例
Ø      $ns halt；            #停止或暂停scheduler
Ø      $ns run；            #开始scheduler
Ø      $ns at ；#在时刻执行
$ns use-scheduler Heap; #让NS使用heap结构的事件调度器
3 、 节点
节点是ns最重要的模块，它主要的部件是分类器（classifier类）。节点也是一个由OTcl实现的解释类，也没有相应的编译对象。有关节点的函数可以在文件目录ns/tcl/lib下的文件ns-nodes.tcl, ns-rtmodule.tcl和ns目录下的rtmodule.{cc,h}、 classifier.{cc,h}、classifier-addr.cc、classifier-mcast.cc、classifiermpath.cc,和replicator.cc文件中找到。
当一个节点收到一个分组时，节点就需要检查分组的某些域(fields) ，通常是检查分组的目的地址，某些场合是源地址。然后就需要寻找与这个域的值相匹配的接收者。在NS中，这个工作是由一个简单的classifier对象执行的，NS中有各种不同的classifier对象，分别负责检查分组的不同部分，来完成不同的匹配和筛选工作。因此NS中的节点为了不同的目的会使用许多不同类型的classifiers类。
由以下Otcl代码可以得到一个节点：
set ns [new Simulator]
$ns node
缺省状况下，node为单播节点。要想得到多播节点需要加入参数“-multicast on”，如： set ns [new Simulator -multicast on]
节点的组分：分类器（Classifier）
node接收到一个包后，要检查特定的域，通常是目的地址（还有可能是源地址），决定如何处理这个包，如果是转发，则还要决定转发到哪里。这项任务由分类器对象来完成，不同类型的分类器对象分别负责检查分组的不同部分，以决定如何转发。
NS中共有五种分类器：base、address、multicast、multipath、replicator。
（1）      base基类分类器（在文件ns/classifier.h定义）是一虚基类：
每一分类器带一指针，指向一张slot表，这张slot表记录TclObject对象与槽号的对应关系。分类器的工作是判断哪个槽号与接收到的数据包相关，然后将包转发给相应的TclObject类对象。
它用方法recv()接收一个包，交给另一方法classify()处理。不同类型的分类器定义了不同的classify()方法。通常的格式是，classify()返回槽下标，若此下标有效，指向一个有效的TclObject对象，则classifier将数据包转发给这个对象，而该对象用自己的recv()方法接收，若下标无效，分类器调用实例过程no-slot{}。基类的no-slot{}仅是输出出错信息，中止执行。
command()方法还提供了以下的命令：
_ clear{ (slot) } ：清空slot表。
_ installNext{（object）}：将对象装入下一槽中，返回槽的号码。
_ slot{(index)}：返回指定的槽的对象。
_ install{_ index_ , _ object_ }：将指定的对象装入指定的槽中。
（2）      address classifier(在ns/classifier-addr.cc中定义)：
其功能是按照分组的目的地址进行匹配，用来支持单播分组转发。它通过对分组的目的地址作位移和掩码运算来产生一个slot表，从而将包的目的地址转化成槽的号码。
（3）      multicast classifier(在ns/classifier-mcast.cc中定义)：
保持一个哈希链表来匹配地址对和取到槽的号码。如为未知地址对，则用Node::new-group{}加入表中。
（4）      multipath classifier（在ns/classifier-mpath.cc中定义）：支持等价多路转发。
（5）      hash classifier：使用哈希表，将包分发给“流”
（6）      replicator：
replicator与普通的classifier不同，它不使用classify()函数，它的作用是生成一个分组的多个拷贝，并把这些拷贝转发给slot表中的所有对象。在组播分组转发时，一个分组需要被转发给多个目标对象，这个工作就是由replicator完成的。
与本节相关的Tcl命令有：
Ø      set $node [$ns node]；#建立一个节点实例
Ø      $ns id；#返回该节点id
Ø      $node neighbors；#返回邻居节点列表
Ø      $node add-neighbor ；#增加一个邻居节点（注意：这是单向的邻居
Ø      $node node-addr；#返回节点的地址
Ø      $node reset；#重置连到这个node上的所有agent
Ø      $node agent ；#返回port_num端口所指向的agent对象，如果port_num端口没有指向任何对象，返回null字符串。
Ø      $node attach ；#将agent对象连接到节点上，如果没有指定端口号，节点会自己分配一个空闲的端口，并把agent连接到该端口上；如果指定端口为port_num，节点就会连接到端口port_num上
$node detach ；#将agent与节点分离，并把一个null_agent连接到agent原来所在的端口上
4、  链路
这是继节点后的拓扑定义阶段。NS支持节点的简单连接，多通路 LAN的简单连接，无线和广播通讯媒体的连接。Link 类是Otcl的类中独立的一个类。SimpleLink 类提供两个结点之间的点到点连接的能力。
下面的Otcl语句创建了一条简单的连接：
set ns [new Simulator]
$ns simplex-link
函数创建了一条从node0到node1的链，指定了带宽、延迟和使用的队列类型。同时还创建了ttl值。
每条链有五个实例变量：
Ø      head_ 链的入口，指向链中的一个对象；
Ø      queue_ 指向链的主要队列元素，一条链可以拥有一个或几个队列；
Ø      link_ 指向由带宽、延迟等特性指定的链。
Ø      ttl_ 指向完成ttl计算的对象该对象由C++的类TTLChecker实现的，TTLChecker类的recv()函数会对分组的ttl值作判断，如果ttl小于0，则丢弃该分组，否则调用send()函数将分组递交给target_。
Ø      drophead_ 指向处理分组丢弃功能的对象。
链路的构造图如图2.6所示：若图片无法显示请联系QQ3710167

 

计算机防火墙论文
 图2.6链路的构造图
链的组分：连接器（Connector类） 若图片无法显示请联系QQ3710167
连接器的主要功能是：接收数据包，进行一些处理，将包放送给它的邻居，或者丢掉。Connector类的定义在~ns/common/connector.h中。它与Classifier类不同，它要么把分组递交给target_对象，要么把分组递交给drop_对象。
Ns中有不同类型的Connector类，每一种都完成不同的功能：
（1）      networkinterface：为接收到的包标注上接口id。
（2）      DynaLink：根据链路状态（连上/断开），决定是否传输数据。
（3）      DelayLink：模拟链路的延迟、带宽。如果不是动态链，则在接收到数据包后，经过一定时间后，发给下游节点；若是动态链，将接收到的数据包排队，然后，送出去。若在某一时刻链路断开了，调用reset()函数，丢弃所有的数据包。
（4）      Queues：模拟链路的输出缓冲。
（5）      TTLChecker：检查数据包的ttl值，若是正值，发送到链的下个元素。
这些不同类型的Connector类一般都通过重载Connector类的recv()函数，来完成各自独特的功能，就是说如果不重载recv()函数的话，所有分组都将直接传递给target_对象。
Connector类的recv()函数定义在ns/common/connector.cc中。
与本节相关的Tcl命令有：
Ø      $ns simplex-link ；创建一条从node0到node1的单向链路，链路的带宽为bw，延迟为delay，队列为qtype，根据队列类型的不同，有些队列可能需要通过args来设定一些参数。
Ø      $ns duplex-link ；创建一条从node0到node1的双向链路，其它参数含义与单向链路相同。
Ø      $link link ；返回$link对象的实例变量link_, link_是一个DelayLink对象，用来仿真延迟和带宽特性。
Ø      $link queue ；返回$link对象的实例变量queue _, queue _是链路的队列。
Ø      $link cost ；设定链路的开销。
Ø      $link cost ？ ；返回链路的开销，缺省开销为1。
Ø      $link up ；设定链路的状态为“up”
Ø      $link down ；设定链路的状态为“down”，只有存在dynamics_变量的队列才可以“down”。
Ø      $link up ？ ；返回链路的状态，如果链路没有dynamics_变量，则状态总是“up”
 
2.2 在LINUX下安装NS-2过程
 
在lnuix下使用allinone方式安装NS这是安装NS的最简单的方式，推荐使用。
（1）    下载ns-allinone-2.27.tar.gz
（2）    假定当前用户为new，当前目录为/home/new
（3）    在终端控制台中执行：cd /home/new/，进入 ns-allinone-2.27.tar.gz所在目录
（4）    用tar命令解压缩ns-allinone-2.27.tar.gz，具体做法为：tar xzvf ns-allinone-2.27.tar.gz
（5）    执行命令：cd ns-allinone-2.27
（6）    执行命令：./install
之后NS开始自动安装，如果没有出错的话，NS就算安装成功，安装结束后NS提示设置3个环境变量的值：PATH，LD_LIBRARY_PATH和TCL_LIBRARY。为了今后使用方便，我们可把这3个环境变量的设置放到/home/new/.bashrc文件中，修改.bashrc文件内容如下所示：
# .bashrc
# User specific aliases and functions
# Source global definitions
if [ -f /etc/bashrc ]; then
        . /etc/bashrc
Fi
export PATH="$PATH:/home/new/ns-allinone-2.27/bin: /home/new/ns-allinone-2.27/tcl8.4.5/unix:/home/new/ns-allinone-2.27/tk8.4.5/unix"
export LD_LIBRARY_PATH="$LD_LIBRARY_PATH:/home/new/ns-allinone-2.27/otcl-1.8,/home/new/ns-allinone-2.27/lib"
export TCL_LIBRARY="$TCL_LIBRARY:/home/new/ns-allinone-2.27/tcl8.4.5/li
brary"
2.3在WINDOWS下安装NS-2过程
 
由于本人此设计是在WINDOWS下做的，所以在这着重介绍NS-2在WINDOWS下的安装。
利用一个Windows下模拟的linux 环境(Cgywin) 来安装NS2,下面是将以ns- allinone-2.27为例具体介绍安装方法。
1 、Windows 下linux 仿真环境( cygwin) 的安装首先http://www.cygwin.com 选择链接Install or Update now(using setup.exe)并下载它。若图片无法显示请联系QQ3710167

图2.7
 
完成后, 执行下载文件setup.exe。
单击下一步, 选择Install from Internet, 并再单击下一步。

图2.8

图2.9
在Root Directory中, 可以选择安装的目录, 不过在这里建议大家使用默认的路径c:\cygwin。其它另外两个选项也使用默认值即可。若图片无法显示请联系QQ3710167

图2.10
然后单击下一步, 在Local Package Directory 中, 是让使用者设定下载cygwin 所需要文件的目录。例如本人在磁盘上建立了一个cygwin_down 文件夹, 用于存放下载cygwin 的安装文件。使用者可以自行更改路径或者使用与安装程序setup 相同的路径(默认值)。若图片无法显示请联系QQ3710167

图2.11
单击下一步, 选择因特网联机的方式: 第一项是直接联机方式, 第二项是使用IE5 方式, 第三项是使用HTTP/FTP Proxy 方式, 使用者可根据自己的实际情况灵活选择, 若使用者是學校的學生，建議採用第三種方式，可以增快下載的速度。这里本人选择了第一项使用直接联机方式。若图片无法显示请联系QQ3710167
 
图2.12
单击下一步, 选择下载的地点链接, 这里本人建议选择从交通大学的FTP站下载，速度比较快。

 

计算机防火墙论文
图2.13
再单击下一步, 选择要安装的软件套件。在这边可以先点选View 项, 使得旁边的Category 变成Full 状态,。这样就可以进行细节的选项选择。若图片无法显示请联系QQ3710167

图2.14
要选择的有XFree86-base、XFree86 - bin、XFree86 - prog、XFree86 - lib、XFree86 - etc、X -Startup- Scripts、make、patch、perl、gcc、gcc- g++、gawk、gnuplot、tar 和gzip。点选XFree86- base, 可以使得状态从new状态改变成4.3.0-11。

图2.15
单击下一步, 开始下载并安装。

图2.16
完成后, 系统会询问使用者是否想要产生小图示于桌面和开始菜单。单击完成选项, 以结束安装程序。若图片无法显示请联系QQ3710167

图2.17
若是还有其它软件的组件需要安装, 可以重新执行setup程序安装即可。
2、Windows 下安装NS-2的具体步骤：
（1）双击桌面上的cygwin 小图示。第一次执行的时候, 会根据目前计算机的使用者和计算机的名称等信息, 在cygwin 的home的目录下产一个使用者的数据文件夹, 并放入环境变量设定等相关档案(.bashrc、.bashrc_profile 和.inputrc)。以本人为例, 本人在Windows XP 操作系统下的使用者名称为new, 而使用计算机名称为EC53AA2097C645E, 则cygwin 会为administrator 在home 的目录下建立一个个人的目录(/home/new), 其对应于的路径为c:\cygwin\home\new; 而输入提示符号则为anew@EC53AA2097C645E~$。
(2)接下来到, 下载NS-2的程序代码, 并存放到自己的个人目录内( 比如: c:\cygwin\home\new) 。所下载的ns-allinone-2.27 软件包, 包括以下组件:
TCL release 8.4.5 (required component)
TK release 8.4.5 (required component)
Otcl release 1.9 (required component)
TclCL release 1.16 (required component)
Ns release 2.28 (required component)
Nam release 1.11 (optional component)
Xgraph version 12.1 (optional component)
CWeb (optional component)
SGB (optional component, builds sgblib for all UNIX type platforms)
Gt- itm (optional component)
Zlib version 1.1.4 (optional, but required when Nam is used)
(3) 使用tar xvfz ns-allinone-2.27.tar.gz 命令解开所下载的压缩文档
(4) 进入ns-allinone-2.27 的目录, 键入命令: cd ns- allinone-2.27, 进入ns- allinone- 2.27 文件夹, 键入命令: ./install 并开始安装NS2。

图2.18
在安装的过程中, 需要花一些时间, 所以请使用者耐心的等待安装完成。在安装的过程中，由于我们没有安装diff，所以安装程序会问使用者要不要继续，选择y继续安装。若图片无法显示请联系QQ3710167

图2.19
(5)完成NS2 的安装后, 开始设定环境变量。编辑自己的个人目录( 比如: c:\cygwin\home\new)下的.bashrc, 把NS2 相关的路径加入PATH 中。用写字板打开.bashrc文件, 将下列4 行信息加入文件的最后即可( ' pwd’代表着自己的个人目录) 。
export NS_HOME=`pwd`/ns-allinone-2.27
export PATH=$NS_HOME/tcl8.4.5/unix:$NS_HOME/tk8.4.5/unix:$NS_HOME/bin:$PATH
exportLD_LIBRARY_PATH=$NS_HOME/tcl8.4.5/unix:$NS_HOME/tk8.4.5/unix:$NS_HOME/otcl-1.8:$NS_HOME/lib:$LD_LIBRARY_PATH
export TCL_LIBRARY=$NS_HOME/tcl8.4.5/library
验证是否正确安装了NS2，可以使用命令: cd ns-allinone-2.27/ns-2.27 进入ns-2.27 子目录, 在命令行键入: ./validate, 即可完成整个验证。不过这会花很多时间, 可能得几个或十几个小时,具体由使用的计算机的性能决定, 需要耐心等候。还有一种简易的方法来直接检验ns 和nam, 就是运行一个小例子。在命令行中键入: startxwin.bat, 会产生一个新的窗口。

图2.20若图片无法显示请联系QQ3710167
在此命令窗口中输入命令: cd ns-2.27/ns-tutorial/examples

图2.21
再键入命令:ns example2.tcl
图2.22
ns模拟结束后, 会去自动执行nam 程序,在nam 窗口中按一下nam 的执行键,出现下图可视化的模拟过程。

图2.23

图2.24
至此, 说明NS-2 软件安装基本没有问题。如果想完全验证NS2 还需使用第一种方法。
起先本人一直不能成功安装此软件出现的问题是：
checking system version (for dynamic loading)... ./configure: line 7068: syntaxerror near unexpected token `)'./configure: line 7068: `       OSF*)'tcl8.3.2 configuration failed! Exiting ...Tcl is not part of the ns project.  Please see http://www.scriptics.com/to see if they have a fix for your platform.
通过上网查资料才解决了此问题，这个问题一般出现在使用网络安装cygwin(就是第一个选项)时，原因是网络安装的文件版本太高，例如在线安装的已经没有xfree86文件了改为xorg了，虽然理论上应该不会出错，但是实际上可能会有一些问题解决办法是用本地安装模式(第三个选项)。

 

计算机防火墙论文
第三章 基于统计分析的防火墙规则匹配优化算法
防火墙是目前网络安全领域广泛使用的设备，其主要目的就是限制非法流量，以保护内部子网。从部署位置来看，防火墙往往位于网络出口，是内部网和外部网之间的唯一通道，因此提高防火墙的性能、避免其成为瓶颈，就成为防火墙产品能否成功的一个关键问题。一般情况下，网络上的数据流总要持续一段时间，因此，若能通过对防火墙过滤规则的次序进行动态调整，使当前网络中流量最大的数据流所对应的过滤规则位于规则列表的前端，就能减少后继的同类数据包进行规则匹配所需的时间，从而提高防火墙性能。根据这一基本事实，本文提出了用统计分析方法对防火墙过滤规则进行优化的方案。并进行了仿真实验，给出了实验结果。
 
3.1 基于统计分析的防火墙规则匹配优化算法概述
 
所谓的用统计分析对防火墙过滤规则进行优化，指的是根据防火墙过滤规则在某一时期的使用频率，对过滤规则的相对次序进行动态调整，使得使用最频繁的规则位于规则列表的最前面，以达到降低后继数据包规则匹配时间、提高防火墙性能之目的。
在调整过滤规则次序时，可以依据全部历史数据流量的统计分析结果，也可以依据当前时间段T 内的数据流量的统计分析结果。前者依据过滤规则被所有历史数据包命中的频率，对规则列表进行排序，结果使命中频率高的规则位于规则列表的前端，那么匹配该规则所需的时间也就会减少。但该方法有着明显的缺点：不能灵敏反映当前的网络流量状况，也就是说不能将当前网络流量使用比较频繁的规则调整到规则集的最前面。而后者依据过滤规则被当前时间段T 内的数据包的命中频率，对规则列表进行排序，结果使当前时间段T 内命中频率高的规则被调整到规则集的前面。相对于前一种方法来讲，后一种方法更接近当前网络数据流的实际状况，我们将重点讨论后一种方法，并对该方法进行改进，使其能更接近当前网络的实际状况。
为了讨论的方便，本文假定防火墙包过滤规则先后顺序对安全没有影响。实际上，在某些情况下，过滤规则的次序对安全是有影响的。不过针对这种情况，本文后面的章节中会给出解决方案。
3.2 基于可变采样时间T的防火墙规则匹配动态优化
 
利用统计分析的方法对防火墙过滤规则进行优化，其关键在于统计数据能否实时地反映当前数据流，也就是说应该尽可能快地使当前过滤规则次序和当前的数据流特性相一致，只有这样，对规则列表的调整优化才有意义。实际上，在采样时间T固定不变时，统计数据的灵敏度和当前网络流量的大小有着直接的关系：当网络流量比较大的时候，由于能在较短时间内统计足够的数据，得到网络流量的发展趋势，因此就应该缩短统计时间，使过滤规则尽快适应当前网络流量，否则规则列表次序就很有可能滞后于当前的网络流量；当网络流量比较小时，如果T 也比较小，就不能统计足够多的数据包，从而不能准确预测当前网络流量的发展趋势，那么调整后的过滤规则次序当然也就不能同步于当前网络流量特性，此时就应该延长统计时间T。基于上面的考虑，要想使过滤规则次序尽可能地和当前网络流量特性相一致，就需要根据当前网络流量大小，动态地调整采样时间T。本文通过引入一个流量因子F 来表示当前的网络流量大小，统计时间T 和流量因子F 成反比。
3.3 算法描述
 
在下面的描述中，用D 表示防火墙缺省规则；R 表示其它过滤规则，用n 表示集合R 中的规则数，集合中的规则用r1，r2，⋯，rn 表示；用A（ri）（1≤i≤n）表示匹配第i 条过滤规则的数据包数目；用A（D）表示命中属于D 的过滤规则的数据包数目；用T 表示初始采样时间（即定时器时长）；Tnew表示调整后的采样时间；F 表示流量因子，F=防火墙最大处理流量÷当前网络流量（F≥1），这是和当前网络流量大小成反比的一个变量。
下面是具体的算法描述（如图3.1 所示）。若图片无法显示请联系QQ3710167
 
       
图3.1规则匹配优化算法流程图
（1）初始化。令A（D）=0，A（ri）=0，并假设在防火墙刚启动时过滤规则的顺序是：r1，r2，⋯，rn，启动一个周期为初始时长为T 的定时器。
（2）规则匹配，并统计每一条规则的匹配次数。当防火墙接收到一个数据包时，对数据包的IP 包头信息（例如目的IP 地址、目的端口号、源IP 地址、源端口号及协议类型等）进行分析，并根据制定的过滤规则决定该数据包是否可以通过防火墙。
如果该数据包符合规则集R 中的第i 条规则，则该规则所对应的计数器加1：A（ri）=A（ri）+1
如果该数据包不符合规则集R 中的任何一条规则，则缺省规则D 所对应的计数器加1：
A（D）=A（D）+1
（3）判断定时器计时是否结束。如果计时结束，则应该在重新启动该定时器之前，执行第（4）步，否则继续执行第（2）步。
（4）调整规则集R 中的规则顺序，这个操作应该在计时器重启之前进行。以A（ri）为关键字，对R 中的规则进行降序排序，形成新的规则次序：r1′，r2′，⋯，rn′。当计时器复位时，将A（R）、A（ri）、A（D）清零。
（5）根据当前网络流量，对T 的大小进行调整。其中：F=防火墙最大处理流量÷当前网络流量Tnew=F*T同时用Tnew作为计时器的新时长，重新启动定时器。
（6）跳到第（3）步，用新的规则次序继续进行规则匹配。
3.4 排序算法的改进
 
在规模较小的计算机网络中，防火墙过滤规则的数目比较少，也比较简单，相互之间没有什么关联，因此过滤规则的先后次序对安全没有什么影响。但在大规模的计算机网络中，防火墙过滤规则的数目会比较多，而且规则之间往往也有着一定的关联性，因而过滤规则的先后次序就会影响到系统的安全。为了解决这个问题，就需要对在前小节中用到的排序算法进行一些修正，以保证在重新排序时不改变关联过滤规则的相对次序。
首选需要对过滤规则的数据结构进行扩充，如下所述：
struct ruletype{
sometype rule；/* 过滤规则* /
int beforeindex[]；
int beforecount；/* beforecount 存放数组beforeindex中的元素数目* /

 

计算机防火墙论文
int afterindex[]；
int aftercount；/* aftercount 存放数组beforeindex 中的元素数目* / }
结构ruletype 表示一条规则的数据结构，其中：beforeindex数组中存放的是必须位于该规则之前的一些规则的索引序号，而afterindex 数组中存放的是必须位于该规则之后的一些规则的索引序号。如果某规则的beforecount 等于零，表示任何规则都可以位于该规则之前；如果某规则的aftercount 等于零，意味着任何规则都可以位于该规则之后。在排序算法中，如果A（ri）（1）如果ri.beforecount==0，则交换ri 和rj 位置；
（2）如果ri.beforecount！= 0，则进行下面的判断：
如果在rj 的beforeindex 数组中找到了i，也就是说rj 不能位于ri 之前，则不交换两者之间的位置；如果没有找到，则交换两者的位置。对排序算法进行上面的改进之后，就可以保证关联规则之间在过滤规则列表中的相对位置不变，从而保证了规则关联的完整性。

 

计算机防火墙论文
第四章仿真实验及结果
4.1 仿真实验运行环境
 
仿真实验的目的是要测试采用下面两种方案的防火墙在性能上的对比：方案1 不采用优化策略，方案2 则采用本文所讨论的优化策略，两方案采用相同的规则匹配算法，并且为了方便讨论，不考虑规则之间的相关性（这并不影响两个方案对比的结果）。在仿真实验中，假定该防火墙的最大包处理速率是2 000 个/s，每一次测试时间为10s，优化算法中的定时器初始时长设为2s。仿真实验所用的网络拓朴如图4.1所示，操作系统平台是windowsxp+Cygwin所用的模拟器是NS-2（Network Simulator v2.27）。若图片无法显示请联系QQ3710167

图4.1测试环境所用网络拓扑
在测试中，源结点0、1、2、3、4 以某速率向结点6发送大小为300 字节的UDP 数据包，不同结点的发送速率如表1所示。规则列表里有10条规则，每个源节点有两条对应的规则，并且在初始情况下，规则次序为：r1，r2，r3，r4，r5，r6，r7，r8，r9，r10。

表4.1不同时间段各节点数据包发送速率 个/S
4.2 实验结果及分析
 
 图4.2跟图4.3是利用NS-2仿真并用nam显示出来的图：

图4.2
图4.2为具有7个节点仿真初始阶段

图4.3
图4.3节点0、1、2、3、4分别同经过5向节点6传输数据包，再通过所仿真的结果数据绘画得出图4.4的X，Y坐标图若图片无法显示请联系QQ3710167
 

                   图4.4防火墙每秒处理500个数据包的仿真结果
其中坐标横轴表示仿真时间，纵轴表示的是防火墙每秒处理500个数据包所需要的时间，水平线表示两个方案的平均时间。从图中可以看到，经过优化后的规则匹配使防火墙的平均性能在一定程度上有了提高。从图中也可以看到，只要统计分析优化有足够的反应时间（数据流持续的时间超过两个定时器时长），就可以动态调整规则次序，使规则次序和当前数据流特性相一致，从而获得相对较小的数据处理时间。方案2 的曲线在第5s～6s 时急剧上升的原因是：虽然各个数据流在整个仿真时间内都没有中断，但在这一时间段内数据流大小的变化趋势和规则次序之间并不相一致，使流量较大的数据流对应的规则位于规则列表的后端，导致性能的下降。

 

 
4.3 一些仿真中的代码
 
规则匹配优化算法：
#include "stdafx.h"
#include
#include
using namespace std;
#define IDT_TIMER 1000
 
struct {
       int rule;
       int Count;
}Rule[100], mun_temp;
 
void main()
{
       CFile file;
       CString strPath, strData, strTime, str;
       strPath = "Rule.txt";
       file.Open(strPath, CFile::modeCreate|CFile::modeNoTruncate|CFile::modeRead);
       int i = file.GetLength();
       file.SeekToBegin();
       int len = file.Read(strData.GetBuffer(12408), 12408);
       strData.ReleaseBuffer();
       int nPos1 = 0;
       int nPos = 0;
       int nLength = 0;
       nLength = strData.GetLength();
       strData = strData.Left(nLength);
       cout <<"规则"<<"\t"<<"匹配次数"<       for(i = 0; ; i++)
       {
              nLength = strData.GetLength();
              nPos = strData.Find(" ", 0);
              str = strData.Left(nPos);
              strData = strData.Right(nLength-nPos-1);
              nPos1 = strData.Find("\n", 0);
              strTime = strData.Left(nPos1-1);
              strData = strData.Right(nLength-nPos1-nPos-1);
              if(nPos < 0)
                     break;
              int nstr = atoi(str);
              int nstrTime = atoi(strTime);
              cout << nstr << "\t"<              Rule[i].rule = nstr;
              Rule[i].Count = 0;
       }
       file.Close();
 
       cout << i <       cout <<"初始化成功!"<       cout <<"规则"<<"\t"<<"匹配次数"<       for(int j=0; j <= i-1; j++)
       {
              cout << Rule[j].rule << "\t"<       }
       cout <<"请输入数据 输入-1结束"<< endl;
 
       int Data;
       cin >> Data;
       while (Data!=-1) {
              for(j=0; j <= i-1; j++)
              {
                     if (Rule[j].rule == Data) {
                            Rule[j].Count++;
                     }
              }
              cin >> Data;
       }
       cout <<"规则"<<"\t"<<"匹配次数"<       for(j=0; j <= i-1; j++)
       {
              cout << Rule[j].rule << "\t"<       }
      
       for(int k=0; k       {
              for(int q=0; q              {
                     if (Rule[k].Count > Rule[q].Count) {
                            mun_temp = Rule[k];
                            Rule[k] = Rule[q];
                            Rule[q] = mun_temp;
 
                     }
              }
       }
       cout <<"排序后"<< endl;
       cout <<"规则"<<"\t"<<"匹配次数"<       for( j=0; j <= i-1; j++)
       {
              cout << Rule[j].rule << "\t"<       }
 
       CStdioFile ifile;
       ifile.Open(strPath,CFile::modeCreate|CFile::modeWrite);
       for(j=0; j <= i-1; j++)
       {
              CString strWrite;
              strWrite.Format("%d %d\n", Rule[j].rule, Rule[j].Count);
              ifile.SeekToEnd();
              ifile.WriteString(strWrite);
       }
      
       ifile.Close();
      
}
TCL代码：
 
# 产生一个模拟的对象
set ns [new Simulator]
 
#针对不同的资料流定义不同的颜色，这是要给NAM用的
$ns color 1 Blue
#开启一个NAM trace file
set nf [open out.nam w]
$ns namtrace-all $nf
 
#开启一个trace file，用来记录封包传送的过程
set nd [open out0.tr w]
$ns trace-all $nd
 
#定义一个结束的程序
proc finish {} {
        global ns nf nd
        $ns flush-trace
        close $nf 
        close $nd 
 
#以背景执行的方式去执行NAM
           exec nam out.nam &
        exit 0
}
 
#产生七个节点
set n0 [$ns node]
set n1 [$ns node]
set n2 [$ns node]
set n3 [$ns node]
set n4 [$ns node]
set n5 [$ns node]
set n6 [$ns node]
 
#把节点连接起来
$ns duplex-link $n0 $n5 10Mb 10ms DropTail
$ns duplex-link $n1 $n5 10Mb 10ms DropTail
$ns duplex-link $n2 $n5 10Mb 10ms DropTail
$ns duplex-link $n3 $n5 10Mb 10ms DropTail
$ns duplex-link $n4 $n5 10Mb 10ms DropTail
$ns duplex-link $n6 $n5 5Mb 20ms DropTail
 
#设定n5到n6之间的Queue Size为2000个封包大小
$ns queue-limit $n5 $n6 2000
 
#设定节点的位置，这是要给NAM用的
$ns duplex-link-op $n0 $n5 orient down
$ns duplex-link-op $n1 $n5 orient right-down
$ns duplex-link-op $n2 $n5 orient right
$ns duplex-link-op $n3 $n5 orient right-up
$ns duplex-link-op $n4 $n5 orient up
$ns duplex-link-op $n5 $n6 orient right
 
#观测n5到n6之间queue的变化，这是要给NAM用的
$ns duplex-link-op $n5 $n6 queuePos 0.5
 
#在n0节点建立一条UDP的连线
set udp0 [new Agent/UDP]
$ns attach-agent $n0 $udp0
set null0 [new Agent/Null]
$ns attach-agent $n6 $null0
$ns connect $udp0 $null0
#在UDP连线之上建立CBR应用程式
set cbr0 [new Application/Traffic/CBR]
$cbr0 attach-agent $udp0
$cbr0 set type_ CBR
$cbr0 set packet_size_ 300
$cbr0 set rate_ 1mb
$cbr0 set random_ false
set udp1 [new Agent/UDP]
$ns attach-agent $n1 $udp1
set null0 [new Agent/Null]
$ns attach-agent $n6 $null0
$ns connect $udp1 $null0
set cbr1 [new Application/Traffic/CBR]
$cbr1 attach-agent $udp1
$cbr1 set type_ CBR
$cbr1 set packet_size_ 300
$cbr1 set rate_ 1mb
$cbr1 set random_ false
set udp2 [new Agent/UDP]
$ns attach-agent $n2 $udp2
set null0 [new Agent/Null]
$ns attach-agent $n6 $null0
$ns connect $udp2 $null0
set cbr2 [new Application/Traffic/CBR]

 

计算机防火墙论文
$cbr2 attach-agent $udp2
$cbr2 set type_ CBR
$cbr2 set packet_size_ 300
$cbr2 set rate_ 1mb
$cbr2 set random_ false
set udp3 [new Agent/UDP]
$ns attach-agent $n3 $udp3
set null0 [new Agent/Null]
$ns attach-agent $n6 $null0
$ns connect $udp3 $null0
set cbr3 [new Application/Traffic/CBR]
$cbr3 attach-agent $udp3
$cbr3 set type_ CBR
$cbr3 set packet_size_ 300
$cbr3 set rate_ 1mb
$cbr3 set random_ false
set udp4 [new Agent/UDP]
$ns attach-agent $n4 $udp4
set null0 [new Agent/Null]
$ns attach-agent $n6 $null0
$ns connect $udp4 $null0
set cbr4 [new Application/Traffic/CBR]
$cbr4 attach-agent $udp4
$cbr4 set type_ CBR
$cbr4 set packet_size_ 300
$cbr4 set rate_ 1mb
$cbr4 set random_ false
#建立一个代理并且把它附加到节点n6
set sink0 [new Agent/LossMonitor]
$ns attach-agent $n6 $sink0
#把流量来源与接点相连接
$ns connect $udp0 $sink0
$ns connect $udp1 $sink0
$ns connect $udp2 $sink0
$ns connect $udp3 $sink0
$ns connect $udp4 $sink0
#设定CBR资料传送开始和结束时间
$ns at 0.1 "$cbr0 start"
$ns at 0.1 "$cbr1 start"
$ns at 0.1 "$cbr2 start"
$ns at 0.1 "$cbr3 start"
$ns at 0.1 "$cbr4 start"
$ns at 4.0 "$cbr4 stop"
$ns at 4.0 "$cbr3 stop"
$ns at 4.0 "$cbr2 stop"
$ns at 4.0 "$cbr1 stop"
$ns at 4.0 "$cbr0 stop"
#在模拟环境中，5秒后去呼叫finish来结束模拟
$ns at 5.0 "finish"
#执行模拟
$ns run

 

计算机防火墙论文第五章  总 结
本文主要研究的是防火墙规则匹配的优化算法，通过对防火墙过滤规则的次序进行动态调整，使当前网络中流量最大的数据流所对应的过滤规则位于规则列表的前端，从而减少后继的同类数据包进行规则匹配所需的时间，来提高防火墙性能。文章首先对防火墙的概念、功能、类型等进行了阐述让我们全面的了解了什么是防火墙。文章详细讲解了NS-2这个仿真软件在WINDOWS下的安装过程，及NS主代码的基类和模块。接着对一个基于统计分析的防火墙规则匹配优化算法研究，并利用了NS-2仿真软件进行仿真实验，对仿真实验结果的结果进行分析得出结论是此方法能提高防火墙的性能。当然，为了讨论的方便，本文假定防火墙包过滤规则先后顺序对安全没有影响。实际上，在某些情况下，过滤规则的次序对安全是有影响的，最后说明一点，此方法同样适应于其他研究。
参 考文 献
1.Terry William Ogletree著.防火墙原理与实施.电子工业出版社，2001
2.刘建伟、王盟著.浅谈防火墙技术极其应用. 研究院报第17期，2004
3.李志伟等编.统计分析概论.对外贸易教育出版社，1984
4.Thomas H Cormen et著.Introduction to algorithms.MIT Press，2001
5. K Fall, K Varadhan著.The ns Manual[EB/LO] .2002-04.
6. S Floyd, V Paxson著.Difficulties in Simulating the Internet，2001-02.
7. 陈文革等.仿真技术及其应用.广东省电信科学技术研究院，第19期，2004
8.徐雷鸣、庞博、赵耀著.NS与网络模拟.人民邮电出版社,2003-11.
9.林军、王燕著.基于Windows 环境下NS-2网络模拟软件的安装.电脑知识报30期，2005
10.王永胜、吴德伟、刘勇著.基于NS-2网络仿真研究.中国期刊第11期21卷，2004
11.李方敏等.网络仿真软件ns-2的结果输出和分析.计算机工程，2002
12.http://www.isi.edu/nsnam/ns/ns-build.html.
12.http://www.isi.edu/nsnam/ns/ns-cygwin.html.
13.http://140.116.72.80/smallko/ns2/ns2.htm.
谢  辞
时光飞逝，光阴荏苒，转眼间大学学习即将结束，回想起这四年的时光感慨颇多。
在这即将结束的时刻，我想感谢所有关心和帮助过我的人。
首先，感谢我的指导老师谭跟高老师。在段时间里，两位老师从课题的选择、资料查询、进度安排以及论文的写作都付出了大量的心血和宝贵的时间。谭老师言传身教深深感染了我，他的勤奋严谨的工作作风、一丝不苟的治学态度、知难而进的工作精神、积极向上的精神面貌，都将成为我今后学习、工作和做人的榜样！他的渊博学识，严谨的科研态度都给我深深地影响，这种影响会激励我更努力上进，我衷心地感谢他！
其次，在对课题的研究过程中得到了不少同学的大力帮助和不吝赐教，我真心感谢他们为我的毕业设计所做的辛苦工作。另外，我还要感谢所有教导过我的老师，没有他们的谆谆教导，就不可能有今天的好结果，感谢我的一些同学在设计中给我提出的大量的宝贵意见。
感谢所有关心和帮助过我的老师、同学和朋友们！