下载文档原格式
计算机网络自顶向下方法与Internet特色课程设计前言计算机网络作为现代计算机科学的核心领域之一，在全球范围内发挥着至关重要的作用，广泛应用于互联网、云计算、物联网等领域。
针对当前计算机网络师资缺乏、教材资源有限等现状，本文介绍了计算机网络自顶向下方法并结合Internet特色课程的设计思路，旨在提高本专业学生计算机网络相关知识的理论水平和实践能力。
自顶向下方法计算机网络自顶向下方法是计算机网络教育领域中的一门广为人知的学科，它按照应用层向底层进行讲解，是一种理论与实践紧密结合的教学方式。
计算机网络自上而下方法包括以下三个重要的方面：1.应用层：网页、电子邮件、远程登录、文件传输等的协议2.运输层：可靠传输、拥塞控制等的协议3.网络层：路由、选择最佳路径等的协议由于自顶向下方法具有良好的实践性以及与实际应用紧密相关的特性，使得该方法成为计算机网络教学中非常重要的一种方法。
Internet特色课程设计基于Internet的特点和计算机网络自顶向下方法，可以设计出一种更加高效、实用的计算机网络课程。
Internet特色课程设计包括以下三个重要的方面：1.课程设计目标：明确课程培养目标，是一个重要的前提条件。
在此基础上，制定具有内涵和外延的课程目标，充分反映教育和人才培养要求，从而有助于开发具有个性并充满活力的课程。
2.课程内容：课程内容是课程设计的核心，必须包容且整合IDC与互联网现代技术，并且结合实践教学与案例分析。
一般而言，需要涵盖计算机网络的所有方面，从应用层到物理层，可以根据不同的需求和实际情况来选择相应的课程内容，从而更好地使学生理解网络协议、网络安全等相关知识。
3.教学方法：教学方法直接关系到学生的学习效率和提高程度。
在计算机网络教育中采用自顶向下方法以及互联网特色教学方法，能够更好地激发学生的学习热情，提高学习主动性，同时循序渐进地推进协议的讲解，并加强和网络安全等相关实践训练，让学生能够更好地掌握网络知识和技能。
课后习题答案：Chapter 1:Review questions: 1,4,11,13,15,16,18,19,23,25,261没有不同，在本文书中，“主机”和“终端系统”可以互换使用。
终端系统包括PCs ，工作站，Web 服务器，电子邮件服务器，连接Internet 的PDA ，WebTV 等。
41 通过电话线拨号调制解调器：住宅2 通过电话线的DSL ：住宅或小型办公室3 光纤电缆：住宅4 100 Mbps 交换以太网：公司5 无线LAN ：移动电话6 蜂窝移动接入（例如WAP ）：移动电话11电路交换网络可以为一个通话保证特定数量的端到端带宽。
大多数现在分组交换网络（包括Internet ）可以提供所有端到端带宽保证。
13在时间t0发送主机开始传输。
在t1 = L/R1时，发送主机完成传输并且整个分组到达路由器（没有传播延迟）。
因为路由器在时间t1拥有整个分组，所以它在时间t1开始向接收主机传输此分组。
在时间t2 = t1 + L/R2，路由器完成传输并且接收主机接收整个分组（也没有传播延迟）。
因此端到端延迟是L/R1 + L/R2。
15a) 可以支持两个用户因为每个用户需要一半的链路带宽。
b) 因为在传输过程中每个用户需要1Mbps ，如果两个或更上用户同时传输，那么最大需要2Mbs 。
因为共享的链路的可用带宽是2Mbps ，所以在链接之前没有排队延迟。
然而，如果三个用户同时传输，那么需要的带宽将是3Mbps ，它大于共享链路的可用带宽，在这种情况下在链接前存在排队延迟。
c) 给定用户传输的概率是0.2。
d) 所有三个用户同时传输的概率是()333133--⎪⎪⎭⎫ ⎝⎛p p = (0.2)3 = 0.008。
因为当所有用户都传输时，队列增加，所以在队列增加的分数（它等于所有三个用户同时传输的概率）是0.008。
16延迟组件是处理延迟，传输延迟，传播延迟和排队延迟。
除了排队延迟是变化的，其它所有延迟都是固定的。
《计算机网络》课程设计学院 ____计算机学院 _______ 专业 ______软件工程 _______年级班别 ______12 级 4 班 _______ 学号91学生姓名指导教师__________林炳城梁路_ __ ___________成绩目录设计题目已知技术参数和设计要求设计内容与步骤设计工作计划与进度安排计算机网络课程设计任务书编程实现基于UDP 的 PING (Java)1.编程实现 PING 的服务器端和客户端，实现操作系统提供的 ping 命令的类似功能。
2.服务器端PingServer 功能：可以显示用户通过客户端发送来的消息内容(包含头部和payload)；能够模拟分组的丢失；能够模拟分组传输延迟；将用户发送来的请求request 在延迟一段随机选择的时间(小于 1s)后返回给客户端，作为收到请求的响应reply；通过如下命令行启动服务器：java PingServer port 。
port 为 PingServer 的工作端口号3.客户端 PingClient功能：启动后发送10 个 request。
发送一个request 后，最多等待 1 秒以便接收PingServer 返回的 reply 消息。
如果在该时间内没有收到服务器的reply ，则认为该请求或对该请求的 reply 已经丢失；在收到 reply 后立即发送下一个 request。
请求消息的payload 中至少包含关键字PingUDP 、序号、时间戳等内容。
如： PingUDP SequenceNumber TimeStamp CRLF其中： CRLF 表示回车换行符(0X0D0A) ； TimeStamp 为发送该消息的机器时间。
为每个请求计算折返时间(RTT) ，统计10 个请求的平均RTT 、最大 /小RTT 。
通过如下命令行启动：java PingClient host port 。
host 为 PingServer 所在的主机地址；port 为 PingServer 的工作端口号1.学习 ICMP ，了解 ping 命令的工作机理；2.学习 Java UDP Socket 通信机制；3.了解 Java 多线程程序设计；4.服务器 PingServer 程序设计；5.客户端 PingClient 程序设计。
计算机网络入门自学书籍推荐计算机网络是连接世界各地计算机和设备的体系结构，是信息通信的基础设施。
在当今信息时代，计算机网络已经成为现代社会的重要组成部分。
如果你对计算机网络感兴趣，并且想要深入了解计算机网络的基本知识和原理，那么下面将推荐一些入门级的自学书籍，帮助你对计算机网络有一个全面的认识。
为了更好地理解计算机网络的概念和原理，我们首先需要了解一些基础概念和术语。
下面将介绍一些适合自学的计算机网络入门书籍，帮助你迅速掌握计算机网络的基本知识。
1. 《计算机网络：自顶向下方法（原书第6版）》这是一本非常适合入门的计算机网络教材。
全书以“自顶向下”（即从应用层到物理层）的方法组织，确保读者可以对计算机网络的各个层次有一个清晰的认识。
每一章都提供了大量的案例和实践活动，方便读者理论与实践相结合，加深理解。
书中还包含了大量的习题和实验，帮助读者巩固所学知识。
这本书不仅适合计算机网络专业的学生，也适合对计算机网络感兴趣的非专业人士。
2. 《计算机网络》（第7版）这本书是由世界著名的计算机网络专家安德鲁·S·坦尼鲍姆（Andrew S. Tanenbaum）编著的经典教材。
全书以扎实的理论和丰富的实践案例为主线，深入浅出地介绍了计算机网络的各个方面，包括网络协议、网络体系结构、互联网、网络安全等。
书中还详细介绍了一些前沿的网络技术，如软件定义网络（SDN）、物联网（IoT）等，帮助读者了解最新的网络技术发展。
3. 《TCP/IP详解：卷1》这是一本深入讲解TCP/IP协议族的经典教材。
作者Richard Stevens是TCP/IP协议族的权威专家，全书通过详细地解析TCP/IP协议族的各个层次，包括IP、ICMP、ARP、RARP、UDP、TCP等，帮助读者深入理解TCP/IP协议族的工作原理和实现方法。
这本书适合对TCP/IP协议族有较深入了解的读者阅读，对于想要深入了解TCP/IP协议族的工作原理和实现方法的读者来说，是一本非常有价值的书籍。
3.复习题1.P127 源端口号为y，目的端口号为x。
2.P 131 应用程序开发者可能不想其应用程序使用TCP的拥塞控制，因为这会在出现拥塞时降低应用程序的传输速率。
通常，IP电话和IP视频会议应用程序的设计者选择让他们的应用程序运行在UDP上，因为他们想要避免TCP的拥塞控制。
还有，一些应用不需要TCP提供的可靠数据传输。
3.P131 是的，应用程序开发者可以将可靠数据传输放到应用层协议中完成。
但是这需要相当大的工作量和进行调试。
4.a) false b) false c) true d) false e) true f) false g) false5.a) 20 bytes (110-90=20bytes) b) ack number = 90 P155 第一个包丢失，发送第一个包之前的一个包的ACK6.P155 3个报文段，第一个报文段，客户机到服务器，seq＝43，ack＝80；第二个报文段，服务器到客户机，seq＝80，ack＝44；第三个报文段，客户机到服务器，seq＝44，ack＝81。
7.R/2 P180 R/28.P176 错误，其阈值将被设置为拥塞窗口目前值的一半（乘性减）。
习题1. A →S 源端口号：467 目的端口号：23b) B →S源端口号：513目的端口号：23c) S →A源端口号：23目的端口号：467d) S →B源端口号：23目的端口号：513e) Yes.f) No.2.P128 假设主机A,B,C的IP地址为a,b,c.（a,b,c各不相同）到主机A:源端口＝80，源IP地址＝b, 目的端口＝26145，目的IP地址＝a；到主机C:左边进程：源端口＝80，源IP地址＝b, 目的端口＝7532，目的IP地址＝c；到主机C:右边进程：源端口＝80，源IP地址＝b, 目的端口＝26145，目的IP地址＝c；3.P132 UDP检查和01010101+011100001100010111000101+01001100000100011的补码＝11101110为了检测错误，接收方将四个字相加（三个原始字和一个检测字）。
计算机网络自顶向下方法影印版第五版课程设计简介本课程设计的主要目的是帮助学生更好地理解计算机网络自顶向下方法影印版第五版这本教材，并通过课程设计的过程，进一步了解计算机网络的基本概念、协议和实现。
本设计要求学生通过编写各种网络应用程序，体验网络协议对应用程序的支持，并通过网络协议的实现剖析网络应用程序、网络协议和操作系统之间的关系。
设计内容网络协议分析以TCP协议为例，从应用程序、协议和操作系统三个层面分析TCP协议的工作过程，并通过编写简单的TCP协议栈实现，深入了解TCP协议的实现原理。
网络应用程序设计利用所学知识，编写一个简单的P2P文件共享程序，并使用Wireshark软件对程序进行抓包分析，深入了解网络应用程序和网络协议之间的关系。
网络安全实践通过模拟网络攻击和防御行为，加深对网络安全的理解，同时加强对常见网络攻击手段的防范能力。
设计步骤步骤一：网络协议分析1.理解TCP协议的基本概念和工作原理。
2.使用wireshark软件对TCP协议进行抓包分析，观察TCP协议的具体实现流程。
3.编写一个简单的TCP协议栈程序，实现TCP协议的基本功能并验证其正确性。
步骤二：网络应用程序设计1.设计一个简单的P2P文件共享程序，并利用TCP协议进行数据传输。
2.使用wireshark软件对程序进行抓包分析，观察程序和协议之间的交互过程。
3.根据观察的流量信息，分析网络应用程序和网络协议之间的关系，并进行相应的优化设计。
步骤三：网络安全实践1.模拟基本的网络攻击手段，如DoS、DDoS等。
2.根据模拟攻击的产生原因和过程，分析网络安全的薄弱点，并实现相关的防御措施。
3.验证防御措施的有效性，提高网络安全防护能力。
总结通过本课程设计，学生将会对计算机网络的基本概念、协议和实现有更深入的了解，并通过编写网络应用程序和网络协议栈，体验网络协议的实现和应用程序的支持。
同时，通过模拟网络攻击和防御行为，加强对网络安全的理解，提高网络安全防护能力。
计算机网络自顶向下方法计算机网络自顶向下方法是指从应用层开始逐步向下分析网络的工作原理和结构。
这种方法是一种自顶向下的学习方法，即从高层次的抽象概念开始，逐步深入地了解网络的各个层次和组成部分。
通过这种方法，我们可以更好地理解计算机网络的工作原理，为网络设计、优化和故障排查提供理论基础和实践指导。
在计算机网络自顶向下方法中，我们首先从应用层开始分析。
应用层是网络中最高层的一层，它包括了各种网络应用程序，例如Web浏览器、电子邮件客户端、文件传输工具等。
通过深入了解应用层协议和应用程序的工作原理，我们可以更好地理解不同应用是如何在网络中进行通信和交互的。
接下来是传输层，传输层负责端到端的数据传输和可靠性保证。
通过分析传输层的协议和机制，我们可以了解数据是如何在源主机和目标主机之间进行传输和交换的。
了解传输层的工作原理对于理解网络通信的可靠性和效率至关重要。
然后是网络层，网络层是整个网络的核心，它负责数据包的路由和转发。
通过深入了解网络层的路由算法和协议，我们可以更好地理解数据包是如何在网络中进行传输和转发的。
了解网络层的工作原理对于网络设计和优化至关重要。
最后是链路层和物理层，这两层负责数据在物理介质上传输和链路的建立和维护。
通过了解链路层和物理层的协议和技术，我们可以更好地理解数据是如何在计算机网络的物理介质上传输和处理的。
了解链路层和物理层的工作原理对于网络性能的优化和故障排查至关重要。
总的来说，计算机网络自顶向下方法是一种非常有效的学习和分析网络的方法。
通过这种方法，我们可以从高层次的抽象概念开始，逐步深入地了解网络的各个层次和组成部分，从而更好地理解网络的工作原理和结构。
这种方法不仅对于理论研究有帮助，也对于网络设计、优化和故障排查有很大的实际应用价值。
希望通过本文的介绍，读者能够对计算机网络自顶向下方法有一个更加深入和全面的了解。
udp实验报告计算机网络UDP实验报告一、引言计算机网络是现代社会中不可或缺的一部分，它使得信息的传输和共享变得更加便捷和高效。
在计算机网络中，UDP（User Datagram Protocol）是一种无连接的传输层协议，它与TCP（Transmission Control Protocol）相比，具有更低的开销和更高的传输速度。
本实验旨在通过实际操作和测试，深入了解UDP协议的特性和应用。
二、实验目的1. 了解UDP协议的基本特性和工作原理；2. 掌握UDP协议的使用方法和应用场景；3. 通过实验测试，分析UDP协议的性能和优缺点。
三、实验环境本次实验使用了一台运行Windows操作系统的计算机，该计算机与另一台运行Linux操作系统的计算机通过局域网相连。
四、实验步骤1. 安装并配置UDP服务器和客户端软件；2. 在服务器端设置监听端口，并等待客户端的连接请求；3. 在客户端发送UDP数据包到服务器端；4. 服务器端接收并处理客户端发送的数据包；5. 分析实验结果，记录传输速度、丢包率等数据。
五、实验结果与分析通过实验测试，我们得到了以下结果和分析：1. 传输速度：UDP协议具有较高的传输速度，因为它不需要建立连接和维护状态。
在我们的实验中，UDP协议的传输速度明显快于TCP协议，适用于对实时性要求较高的应用场景，如音视频传输。
2. 丢包率：由于UDP协议的无连接特性，它对数据包的丢失不负责任。
在实验中，我们发现UDP协议的丢包率较高，这意味着在传输过程中可能会丢失部分数据包。
因此，在对数据可靠性要求较高的应用场景中，不适合使用UDP协议。
3. 应用场景：UDP协议适用于需要快速传输和实时性较高的应用场景，如音视频传输、在线游戏等。
它可以提供较低的延迟和更好的用户体验。
但是，由于UDP协议的不可靠性，需要在应用层进行数据包的重传和错误校验等处理。
六、实验总结通过本次实验，我们对UDP协议有了更深入的了解。
广工计算机网络课设——基于UDPpingUDP ping是一种用于测试网络连接状况的工具，它使用UDP协议在网络上发送小数据包，以达到测试网络是否畅通的效果。
本文将介绍一种基于UDP ping的计算机网络课设。
首先，我们需要确定本次课设的目标，即实现基于UDP ping的网络连通性测试工具。
这个工具需要实现以下功能：1. 向目标主机发送UDP ping数据包2. 等待目标主机返回响应数据包3. 分析响应数据包，判断网络状况是否正常在实现这个工具之前，我们需要了解UDP ping的原理。
在网络通信过程中，我们知道，TCP协议是一种面向连接的协议，而UDP协议则是一种无连接的协议。
因为UDP协议在发送数据时不需要建立连接，所以它的数据包比TCP协议小，能够较快地被发送出去。
而在网络通信时，我们需要测试网络的响应时间、丢包率等指标，这些指标可以通过发送小数据包并测量回应时间来实现。
因此，UDP ping就应运而生。
接下来是实现步骤：步骤一、编写UDP ping发送程序我们首先需要编写一个UDP ping发送程序，这个程序会向目标主机发送UDP ping数据包，并记录发送时间：```pythonimport socketimport timedef udp_ping(host, port):udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)udp_socket.settimeout(5)start_time = time.time()udp_socket.sendto(b'ping', (host, port))try:data, addr = udp_socket.recvfrom(1024)end_time = time.time()print(f'Reply from {host}: time={round((end_time-start_time)*1000)}ms') except:print(f'Reply from {host}: Destination host unreachable')udp_socket.close()```上述代码中使用了Python内置的`socket`库来创建一个UDP socket，并使用`sendto()`发送UDP数据包。
计算机网络自顶向下方法第七版课程设计概述本篇文档为计算机网络自顶向下方法第七版的课程设计。
该课程设计旨在培养学生的计算机网络技术和实践能力，通过自顶向下的学习方法，将学生从应用层开始逐步深入理解计算机网络的各个层次的原理和技术。
课程设置本课程分为理论学习和实践环节两部分。
理论学习主要涉及计算机网络的基本概念、协议、技术等内容，包括以下章节：•第一章：计算机网络和因特网•第二章：应用层•第三章：运输层•第四章：网络层•第五章：链路层•第六章：无线和移动网络实践环节则是基于实验平台进行的，包括以下实验：1.基于Wireshark的网络流量捕获与分析；2.基于Socket、HTTP协议和PyQt5的Web服务器搭建；3.套接字（Socket）编程；4.基于TCP协议的文件传输；5.基于UDP协议的即时通讯软件开发；6.网络配置和管理；课程设计要求本课程设计旨在帮助学生深入理解计算机网络理论，同时通过实践实现技术应用。
具体要求如下：1.学生需要在每个章节的学习结束后完成相应题目的作业。
2.学生需要按照要求完成实践部分的实验。
3.学生需要在课堂上积极参与讨论，并提问解决问题。
4.学生需要在规定的时间内提交课程设计的报告。
实验示例实验一：基于Wireshark的网络流量捕获与分析实验目的通过实验，学习基本的网络流量捕获、过滤和分析技术；实验要求1.下载安装Wireshark；2.仿照PPT中的案例，自行捕获一段网络流量数据；3.使用Wireshark对网路流量进行分析，了解网络的基本信息；4.提交实验报告：•捕获网络流量数据•分析文档•实验感悟实验过程1.下载Wireshark安装包，进行安装；2.打开Wireshark，并在“捕捉界面”选择相应的网卡进行捕获；3.通过选择不同的过滤器，对流量数据进行过滤和分析；4.捕获完网络流量数据后，将该文件保存，用于后续的分析；5.结合自己的分析和感悟，撰写报告。
实验感悟通过本次实验，我对计算机网络的流量分析技术有了更深入的了解。
写一个基于UDP的Ping客户机与服务器程序这是一个《计算机网络自顶向下方法》中的编程实验。
在本实验中，你将实现一个简单的基于UDP的Ping客户机和服务器。
由这些程序提供的功能类似于现代操作系统中使用的标准 Ping程序。
标准的Ping工作时发送因特网控制报文协议（ICMP）ECHO报文，远程机器对发送方返回响应。
该发送方则能够决定它自己和被探测的计算机之间的往返时延。
Java不提供发送和接收ICMP报文的任何功能，所以本实验需要在应用层用标准的UDP套接字和报文实现Ping。
在编译并部署后，客户机的一个运行结果如下：F:\EclipseWorkspace\UDPPinger\bin>java PingClient 192.168.173.240 7890 FROM SERVER: PING 0 2010-06-20 20:29:07FROM SERVER: No reply.FROM SERVER: PING 2 2010-06-20 20:29:09FROM SERVER: No reply.FROM SERVER: PING 4 2010-06-20 20:29:10FROM SERVER: No reply.FROM SERVER: PING 6 2010-06-20 20:29:11FROM SERVER: PING 7 2010-06-20 20:29:11FROM SERVER: PING 8 2010-06-20 20:29:11FROM SERVER: PING 9 2010-06-20 20:29:11可见第1个、第3个与第5个PING报文没有得到响应。
以下是服务器端对应的运行结果：D:\jie.tian\Java\UDP Pinger>java PingServer 7890Received from + 192.168.172.9: PING 0 2010-06-20 20:29:07Reply sent.Received from + 192.168.172.9: PING 1 2010-06-20 20:29:08Reply not send.Received from + 192.168.172.9: PING 2 2010-06-20 20:29:09Reply sent.Received from + 192.168.172.9: PING 4 2010-06-20 20:29:10Reply sent.Received from + 192.168.172.9: PING 6 2010-06-20 20:29:11Reply sent.Received from + 192.168.172.9: PING 7 2010-06-20 20:29:11Reply sent.Received from + 192.168.172.9: PING 8 2010-06-20 20:29:11Reply sent.Received from + 192.168.172.9: PING 9 2010-06-20 20:29:11Reply sent.Received from + 192.168.172.9: PING 3 2010-06-20 20:29:09Reply sent.Received from + 192.168.172.9: PING 5 2010-06-20 20:29:10Reply sent.以下分别是服务器程序和客户机程序的Java 源代码：01 import java.io.*;02 import .*;03 importjava.util.*;0405 /**06 * Server to process ping requests over UDP.07 * @author 涂鸦08 *09 */10 public class PingServer {11 private static final double LOSS_RATE = 0.3;12 private static final int AVERAGE_DELAY = 100; // milliseconds 1314 public static void main(String[] args) throws Exception {15 // Get command line argument.16 if (args.length != 1) {17 System.out.println("Required arguments: port");18 return;19 }2021 int port = Integer.parseInt(args[0]);2223 // Create random number generator for use in simulating packet loss and network delay.24 Random random = new Random();2526 // Create a datagram socket for receiving and sending UDP packets through the port specified27 // on the command line.28 DatagramSocket socket = new DatagramSocket(port);2930 // Processing loop.31 while (true) {32 // Create a datagram packet to hold incoming UDP packet.33 DatagramPacket request= new DatagramPacket(new byte[1024], 1024);3435 // Block until the host receives a UDP packet.36 socket.receive(request);3738 // Print the received data.39 printData(request);4041 // Decide whether to reply, or simulate packet loss.42 if (random.nextDouble() < LOSS_RATE) {43 System.out.println(" Reply not send.");44 continue;45 }4647 // Simulate network delay.48 Thread.sleep((int) (random.nextDouble() * 2 * AVERAGE_DELAY)); 4950 // Send reply.51 InetAddressclientHost = request.getAddress();52 intclientPort = request.getPort();53 byte[] buf = request.getData();54 DatagramPacket reply = new DatagramPacket(buf, buf.length, clientHost, clientPort);55 socket.send(reply);5657 System.out.println(" Reply sent.");58 }59 }6061 /**62 * Print ping data to the standard output stream.63 */64 private static void printData(DatagramPacket request) throws Exception {65 // Obtain references to the packet's array of bytes.66 byte[] buf = request.getData();6768 // Wrap the bytes in a byte array input stream, so that you can read the data as a stream69 // of bytes.70 ByteArrayInputStreambais = new ByteArrayInputStream(buf); 7172 // Wrap the byte array output stream in an input stream reader, 73 // so you can read the data as a stream of characters.74 InputStreamReaderisr = new InputStreamReader(bais);7576 // Wrap the input stream reader in a buffered reader,77 // so you can read the character data a line at a time.78 // (A line is a sequence of chars terminated by any combination of \r and \n.)79 BufferedReaderbr = new BufferedReader(isr);8081 // The message data is contained in a single line, so read this line. 82 String line = br.readLine();8384 // Print host address and data received from it.85 System.out.println("Received from + " + request.getAddress().getHostAddress() + ": " + new String(line));86 }87 }01 import java.io.*;import .DatagramPacket;import .DatagramSocket;06 import java.util.Date;07 import java.util.Random;0809 public class PingClient {10 private static final double LOSS_RATE = 0.3;11 private static final int AVERAGE_DELAY = 100; // milliseconds 1213 public static void main(String[] args) throws Exception {14 // Get command line argument.15 if (args.length == 0) {16 System.out.println("Required arguments: host port");17 return;18 }1920 if(args.length == 1) {21 System.out.println("Required arguments: port");22 return;23 }2425 String host = args[0].toString();26 int port = Integer.parseInt(args[1]);2728 // 发起向服务器的连接29 DatagramSocketclientSocket = new DatagramSocket();30 // 等待1秒钟31 clientSocket.setSoTimeout(1000);3233 InetAddressIPAddress = InetAddress.getByName(host);3435 for(inti = 0; i < 10; i++) {36 // 发送报文37 byte[] sendData = new byte[1024];38 byte[] receiveData = new byte[1024];39 Date currentTime = new Date();40 SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-ddHH:mm:ss");41 String timeStamp = formatter.format(currentTime);42 String pingMessage = "PING " + i + " " + timeStamp + " " + "\r\n"; 43 sendData = pingMessage.getBytes();44 DatagramPacketsendPacket = new DatagramPacket(sendData,sendData.length, IPAddress, port);45 try{46 clientSocket.send(sendPacket);4748 DatagramPacketreceivePacket = new DatagramPacket(receiveData, receiveData.length);49 clientSocket.receive(receivePacket);50 String reply = new String(receivePacket.getData());51 System.out.println("FROM SERVER: " + reply);52 } catch (.SocketTimeoutException ex) {53 String reply = "No reply.";54 System.out.println("FROM SERVER: " + reply);55 }56 }57 // 关闭与服务器的UDP 连接58 clientSocket.close();59 }60 }最后是《计算机网络自顶向下方法》教材附带的关于本实验的网络教辅资料：Programming Assignment 3: UDP Pinger Lab Server CodeThe following code fully implements a ping server. You need to compile and run this code. You should study this code carefully, as it will help you write your Ping client.import java.io.*;import .*;import java.util.*;/** Server to process ping requests over UDP.*/public class PingServer{private static final double LOSS_RATE = 0.3;private static final int AVERAGE_DELAY = 100; // milliseconds public static void main(String[] args) throws Exception{// Get command line argument.if (args.length != 1) {System.out.println("Required arguments: port");return;}int port = Integer.parseInt(args[0]);// Create random number generator for use in simulating// packet loss and network delay.Random random = new Random();// Create a datagram socket for receiving and sending UDP packets// through the port specified on the command line.DatagramSocket socket = new DatagramSocket(port);// Processing loop.while (true) {// Create a datagram packet to hold incomming UDP packet.DatagramPacket request = new DatagramPacket(new byte[1024], 1024);// Block until the host receives a UDP packet.socket.receive(request);// Print the recieved data.printData(request);// Decide whether to reply, or simulate packet loss.if (random.nextDouble() < LOSS_RATE) {System.out.println(" Reply not sent.");continue;}// Simulate network delay.Thread.sleep((int) (random.nextDouble() * 2 * AVERAGE_DELAY));// Send reply.InetAddressclientHost = request.getAddress();intclientPort = request.getPort();byte[] buf = request.getData();DatagramPacket reply = new DatagramPacket(buf, buf.length, clientHost, clientPort);socket.send(reply);System.out.println(" Reply sent.");}}/** Print ping data to the standard output stream.*/private static void printData(DatagramPacket request) throws Exception {// Obtain references to the packet's array of bytes.byte[] buf = request.getData();// Wrap the bytes in a byte array input stream,// so that you can read the data as a stream of bytes.ByteArrayInputStreambais = new ByteArrayInputStream(buf);// Wrap the byte array output stream in an input stream reader,// so you can read the data as a stream of characters.InputStreamReaderisr = new InputStreamReader(bais);// Wrap the input stream reader in a bufferred reader,// so you can read the character data a line at a time.// (A line is a sequence of chars terminated by any combination of \r and \n.)BufferedReaderbr = new BufferedReader(isr);// The message data is contained in a single line, so read this line.String line = br.readLine();// Print host address and data received from it.System.out.println("Received from " +request.getAddress().getHostAddress() +": " +new String(line) );}}The server sits in an infinite loop listening for incoming UDP packets. When a packet comes in, the server simply sends the encapsulated data back to the client.Packet LossUDP provides applications with an unreliable transport service, because messages may get lost in the network due to router queue overflows or other reasons. In contrast, TCP provides applications with a reliable transport service and takes care of any lost packets by retransmitting them until they are successfully received. Applications using UDP for communication must therefore implement any reliability they need separately in the application level (each application can implement a different policy, according to its specific needs).Because packet loss is rare or even non-existent in typical campus networks, the server in this lab injects artificial loss to simulate the effects of network packet loss. The server has a parameter LOSS_RATE that determines which percentage of packets should be lost.The server also has another parameter AVERAGE_DELAY that is used to simulate transmission delay from sending a packet across the Internet. You should set AVERAGE_DELAY to a positive value when testing your clientand server on the same machine, or when machines are close by on the network. You can set AVERAGE_DELAY to 0 to find out the true round trip times of your packets.Compiling and Running ServerTo compile the server, do the following:javac PingServer.javaTo run the server, do the following:javaPingServer portwhere port is the port number the server listens on. Remember that you have to pick a port number greater than 1024, because only processes running with root (administrator) privilege can bind to ports less than 1024. Note: if you get a class not found error when running the above command, then you may need to tell Java to look in the current directory in order to resolve class references. In this case, the commands will be as follows:java -classpath . PingServer portYour Job: The ClientYou should write the client so that it sends 10 ping requests to the server, separated by approximately one second. Each message contains a payload of data that includes the keyword PING, a sequence number, and a timestamp. After sending each packet, the client waits up to one second to receive a reply. If one seconds goes by without a reply from the server, then the client assumes that its packet or the server's reply packet has been lost in the network.Hint: Cut and paste PingServer, rename the code PingClient, and then modify the code.You should write the client so that it starts with the following command: javaPingClient host portwhere host is the name of the computer the server is running on and port is the port number it is listening to. Note that you can run the client and server either on different machines or on the same machine.The client should send 10 pings to the server. Because UDP is an unreliable protocol, some of the packets sent to the server may be lost, or some of the packets sent from server to client may be lost. For this reason, the client cannot wait indefinitely for a reply to a ping message. You should have the client wait up to one second for a reply; if no reply is received, then the client should assume that the packet was lost during transmission across the network. You will need to research the API for DatagramSocket to find out how to set the timeout value on a datagram socket.When developing your code, you should run the ping server on your machine, and test your client by sending packets to localhost (or, 127.0.0.1). After you have fully debugged your code, you should see how your application communicates across the network with a ping server run by another member of the class.Message FormatThe ping messages in this lab are formatted in a simple way. Each message contains a sequence of characters terminated by a carriage return character (r) and a line feed character (n). The message contains the following string: PING sequence_number time CRLFwheresequence_number starts at 0 and progresses to 9 for each successive ping message sent by the client, time is the time when the client sent the message, and CRLF represent the carriage return and line feed characters that terminate the line.Optional ExercisesWhen you are finished writing the client, you may wish to try one of the following exercises.1) Currently the program calculates the round-trip time for each packet and prints them out individually. Modify this to correspond to the way the standard ping program works. You will need to report the minimum, maximum, and average RTTs. (easy)2) The basic program sends a new ping immediately when it receives a reply. Modify the program so that it sends exactly 1 ping per second, similar to how the standard ping program works. Hint: Use the Timer and TimerTask classes in java.util. (difficult)3) Develop two new classes ReliableUdpSender and ReliableUdpReceiver, which are used to send and receive data reliably over UDP. To do this, you will need to devise a protocol (such as TCP) in which the recipient of data sends acknowledgements back to the sender to indicate that the data hasarrived. You can simplify the problem by only providing one-way transport of application data from sender to recipient. Because your experiments may be in a network environment with little or no loss of IP packets, you should simulate packet loss. (difficult)import java.io.*;import .*;import java.util.*;/*** Server to process ping requests over UDP.* @author涂鸦**/publicclass PingServer {privatestaticfinaldouble LOSS_RATE = 0.3;privatestaticfinalint AVERAGE_DELAY = 100; // millisecondspublicstaticvoid main(String[] args) throws Exception {// Get command line argument.if (args.length != 1) {System.out.println("Required arguments: port");return;}int port = Integer.parseInt(args[0]);// Create random number generator for use in simulating packet loss and network delay.Random random = new Random();// Create a datagram socket for receiving and sending UDP packets through the port specified// on the command line.DatagramSocket socket = new DatagramSocket(port);// Processing loop.while (true) {// Create a datagram packet to hold incoming UDP packet.DatagramPacket request= new DatagramPacket(newbyte[1024], 1024);// Block until the host receives a UDP packet.socket.receive(request);// Print the received data.printData(request);// Decide whether to reply, or simulate packet loss.if (random.nextDouble() <LOSS_RATE) {System.out.println(" Reply not send.");continue;}// Simulate network delay.Thread.sleep((int) (random.nextDouble() * 2 * AVERAGE_DELAY));// Send reply.InetAddressclientHost = request.getAddress();int clientPort = request.getPort();byte[] buf = request.getData();DatagramPacket reply = new DatagramPacket(buf, buf.length, clientHost, clientPort);socket.send(reply);System.out.println(" Reply sent.");}}/*** Print ping data to the standard output stream.*/privatestaticvoid printData(DatagramPacket request) throws Exception {// Obtain references to the packet's array of bytes.byte[] buf = request.getData();// Wrap the bytes in a byte array input stream, so that you can read the data as a stream// of bytes.ByteArrayInputStreambais = new ByteArrayInputStream(buf);// Wrap the byte array output stream in an input stream reader,// so you can read the data as a stream of characters.InputStreamReaderisr = new InputStreamReader(bais);// Wrap the input stream reader in a buffered reader,// so you can read the character data a line at a time.// (A line is a sequence of chars terminated by any combination of \r and \n.)BufferedReaderbr = new BufferedReader(isr);// The message data is contained in a single line, so read this line.String line = br.readLine();// Print host address and data received from it.System.out.println("Received from + " +request.getAddress().getHostAddress() + ": " + new String(line));}}---------------------------------------------------------------------------------------------------------------------------------import java.io.*;import .DatagramPacket;import .DatagramSocket;import .InetAddress;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Random;publicclass PingClient {privatestaticfinaldouble LOSS_RATE = 0.3;privatestaticfinalint AVERAGE_DELAY = 100; // millisecondspublicstaticvoid main(String[] args) throws Exception {// Get command line argument.if (args.length == 0) {System.out.println("Required arguments: host port");return;}if(args.length == 1) {System.out.println("Required arguments: port");return;}String host = args[0].toString();int port = Integer.parseInt(args[1]);// 发起向服务器的连接DatagramSocketclientSocket = new DatagramSocket();// 等待1秒钟clientSocket.setSoTimeout(1000);InetAddressIPAddress = InetAddress.getByName(host);for(int i = 0; i< 10; i++) {// 发送报文byte[] sendData = newbyte[1024];byte[] receiveData = newbyte[1024];Date currentTime = new Date();SimpleDateFormat formatter =new SimpleDateFormat("yyyy-MM-ddHH:mm:ss");String timeStamp = formatter.format(currentTime);String pingMessage = "PING " + i + " " + timeStamp + " " + "\r\n";sendData = pingMessage.getBytes();DatagramPacketsendPacket = new DatagramPacket(sendData,sendData.length, IPAddress, port);try{clientSocket.send(sendPacket);DatagramPacketreceivePacket = new DatagramPacket(receiveData, receiveData.length);clientSocket.receive(receivePacket);String reply = new String(receivePacket.getData());System.out.println("FROM SERVER: " + reply);} catch (.SocketTimeoutException ex) {String reply = "No reply.";System.out.println("FROM SERVER: " + reply);}}// 关闭与服务器的UDP连接clientSocket.close();}}。
