Socket编程利用TCP协议的实验报告
网络编程实验报告
网络编程实验报告实验一TCP Socket API程序设计一、预备知识1.网络编程基本概念网络上的计算机间的通讯,实质上是网络中不同主机上的程序之间的通讯。
在互联网中使用IP地址来标识不同的主机,在网络协议中使用端口号来标识主机上不同进程,即使用(IP地址,端口号)二元组。
套接字(Socket)用于描述IP地址和端口,是一个通信链的句柄,通信时一个网络程序将要传输的一段信息写入它所在主机的Socket中,该Socket通过与网络接口卡相连的传输介质将这段信息发送到另一台主机的Socket中,以供其他程序使用。
图1-1 TCP通信流程2.TCP通信流程TCP程序是面向连接的,程序运行后,服务器一直处于监听状态,客户端与服务器通信之前必须首先发起连接请求,由服务器接收请求并在双方之间建立连接后才可以互相通信。
二、实验目的1.了解Winsock API编程原理;2.掌握TCP Socket程序的编写;3.了解C/S模式的特点;4.学会解决实验中遇到的问题。
三、实验任务使用Winsock API相关类实现TCP Socket通信程序,并能成功运行。
四、实验环境及工具1. Windows2000/XP/72. Visual C++开发平台3. Visual Studio2010五、实验内容和步骤参照《Visual C++网络编程教程》书中81页,TCP Socket API 程序设计。
连接:void CChatClientDlg::OnConnect(){WSADATA wsd; //WSADATA结构WSAStartup(MAKEWORD(2,2),&wsd); //加载协议,使用Winsock 2.2版m_client = socket(AF_INET,SOCK_STREAM,0); //创建流式套接字//服务器地址sockaddr_in serveraddr;UpdateData();if(ServerIP.IsBlank()){AfxMessageBox("请指定服务器IP!");return;}if(sPort.IsEmpty()){AfxMessageBox("请指定端口!");return;}//获取服务器进程的IP和端口BYTE nFild[4];CString sIP;ServerIP.GetAddress(nFild[0],nFild[1],nFild[2],nFild[3]);sIP.Format("%d.%d.%d.%d",nFild[0],nFild[1],nFild[2],nFild[3]);//设置服务器地址结构的内容serveraddr.sin_family = AF_INET;serveraddr.sin_addr.S_un.S_addr = inet_addr(sIP);serveraddr.sin_port = htons(atoi(sPort));//发起连接须指明要访问的服务器进程地址,这个地址存储在serveraddr中if(connect(m_client,(sockaddr*)&serveraddr,sizeof(serveraddr)) ! = 0){MessageBox("连接失败");return;}else{m_ListWords.AddString("连接服务器成功!");m_ListWords.SetT opIndex(m_ListWords.GetCount() - 1);}WSAAsyncSelect(m_client,m_hWnd,10000,FD_READ|FD_CLO SE); //①//界面完善ServerIP.EnableWindow(false);ServerPort.EnableWindow(false);m_ButtonConnect.EnableWindow(false);m_ButtonDisconnect.EnableWindow();m_EditWords.EnableWindow();m_ButtonSend.EnableWindow();m_ButtonExit.EnableWindow(false);m_ButtonClear.EnableWindow();}“断开”按钮的事件过程代码如下:void CChatClientDlg::OnDisconnect(){//断开与服务器的连接closesocket(m_client);m_ListWords.AddString("从服务器断开");m_ListWords.SetT opIndex(m_ListWords.GetCount() - 1);ServerIP.EnableWindow();ServerPort.EnableWindow();m_ButtonConnect.EnableWindow();m_ButtonDisconnect.EnableWindow(false);m_EditWords.EnableWindow(false);m_ButtonSend.EnableWindow(false);m_ButtonExit.EnableWindow();}“发送”按钮事件过程代码如下:void CChatClientDlg::OnSend(){//向服务器发送信息UpdateData();if(m_sWords.IsEmpty()){AfxMessageBox("发送的消息不能为空!");return;}//开始发送数据int i = send(m_client,m_sWords.GetBuffer(0),m_sWords.GetLength(),0);m_ListWords.AddString("发送:" + m_sWords);m_ListWords.SetT opIndex(m_ListWords.GetCount() - 1);}BOOL CChatClientDlg::PreTranslateMessage(MSG* pMsg){if(pMsg->message == 10000) //识别应用程序中定义的消息号{switch(pMsg->lParam) //判断网络事件类型{case FD_READ:this->ReceiveData(); //若为FD_READ则接收数据break;case FD_CLOSE:this->CloseSock(); //如果服务端断开,客户端也断开break;}}elsereturn CDialog::PreTranslateMessage(pMsg);}下面来实现ReceiveData()和CloseSock()方法。
socket编程实验报告
socket编程实验报告《Socket编程实验报告》在计算机网络通信中,Socket编程是一种常见的通信方式,它允许不同的计算机之间进行数据交换和通信。
通过实验,我们可以更深入地了解Socket编程的原理和应用。
实验目的:1. 了解Socket编程的基本原理和概念2. 掌握Socket编程的基本操作和使用方法3. 实现简单的客户端和服务器端通信实验环境:1. 操作系统:Windows或Linux2. 编程语言:C/C++或Python实验步骤:1. 理解Socket编程的基本原理和概念,包括TCP和UDP协议2. 编写客户端程序,建立与服务器端的连接3. 编写服务器端程序,接受客户端的连接并进行数据交换4. 测试客户端和服务器端的通信功能,包括发送和接收数据实验结果:通过实验,我们成功实现了简单的客户端和服务器端通信。
我们能够在客户端发送数据,服务器端接收并处理数据,然后再将处理结果返回给客户端。
这证明了Socket编程的可行性和实用性。
实验总结:Socket编程是一种强大而灵活的通信方式,它可以实现不同计算机之间的数据交换和通信。
通过本次实验,我们更加深入地了解了Socket编程的原理和应用,掌握了基本的操作和使用方法。
我们相信在今后的学习和工作中,Socket编程将会发挥重要的作用,为我们的网络通信提供更多的可能性和便利性。
通过这次实验,我们对Socket编程有了更深刻的理解,也提升了我们的编程能力和实践能力。
我们相信,在今后的学习和工作中,Socket编程将会发挥重要的作用,为我们的网络通信提供更多的可能性和便利性。
计算机网络实验报告 winsock编程
计算机网络实验一:socket文件传输一、实验目地1、了解网络通信原理。
掌握客户端/服务器程序设计。
2、理解Socket通信原理,掌握使用ServerSocket类和Socket类进行TCPSocket通信的程序设计方法二、实验原理Socket可以看成在两个程序进行通讯连接中的一个端点,是连接应用程序和网络驱动程序的桥梁,Socket在应用程序中创建,通过绑定与网络驱动建立关系。
此后,应用程序送给Socket的数据,由Socket交网络驱动程序向网络上发送出去。
计算机从网络上收到与该Socket绑定IP地址和端口号相关的数据后,由网络驱动程序交给Socket,应用程序便可从该Socket中提取接收到得数据,网络应用程序就是这样通过Socket进行数据的发送与接收的。
详细如图:我们来分析一下图,Host A上的程序A将一段信息写入Socket中,Socket 的内容被Host A的网络管理软件访问,并将这段信息通过Host A的网络接口卡发送到Host B,Host B的网络接口卡接收到这段信息后,传送给Host B 的网络管理软件,网络管理软件将这段信息保存在Host B的Socket中,然后程序B才能在Socket中阅读这段信息。
Socket套接口有3种类型。
1.SOCK_STREAM流式套接口,面向连接的,可靠地,TCP。
2.SOCK_DRAM数据报套接口,面向无连接,不可靠,UDP。
3.原始套接口,主要用于新的网络协议实现的测试三、实验分析1、实验要求、按需求编写服务器端和客户端程序代码。
实现:(1)服务器端向客户端提供文件目录。
(2)客户端向服务器端发出请求下载文件。
(3)客户端向服务器端上传文件。
2、Socket通信工作过程如下(1)、建立连接服务器(ServerSocket)监听指定端口,看是否有客户端的连接请求;客户端(ClientServer)创建套接字并通过指定端口请求与服务器建立连接。
通信网络实验 三tcpsocket编程
通信网络实验报告实验三socket(tcp)编程通信网络实验一、实验背景Socket API是实现进程间通信的一种编程设施,也是一种为进程间提供底层抽象的机制。
尽管应用开发人员很少需要在该层编写代码,但是理解socket API还是非常重要的。
(1)高层设施是构建于socket API之上的,它们是利用socket API提供的操作来实现。
(2)对于响应时间要求较高或运行于有限资源平台上的应用,甚至socket API是唯一可用的进程间通信设施。
二、服务器端程序int _tmain(intargc, _TCHAR* argv[]){printf("此窗口为服务器,正在监听端口:8888\n");SOCKET sockserv=socket(AF_INET, SOCK_STREAM,0);SOCKADDR_IN m_addr;m_addr.sin_family = AF_INET;m_addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);m_addr.sin_port = htons(8888);bind(sockserv, (SOCKADDR*)&(m_addr), sizeof(m_addr));listen(sockserv, 2);SOCKADDR_IN addrclient;intlen = sizeof(SOCKADDR);while(1){SOCKET sockConn=accept(sockserv, (SOCKADDR*)&addrclient, &len);charrecvbuf[100];charsendbuf[100];memset(recvbuf,0,100);sprintf(sendbuf,"我是服务器,通网实验做了吗");send(sockConn,sendbuf,strlen(sendbuf)+1,0);recv(sockConn,recvbuf,100,0);printf("%s\n",recvbuf);closesocket(sockConn);}WSACleanup();return 0;}三、客户端程序printf("此窗口为客户端程序\n");SOCKET sockclient=socket(AF_INET, SOCK_STREAM,0);SOCKADDR_IN addrsrv;addrsrv.sin_family = AF_INET;addrsrv.sin_addr.S_un.S_addr= inet_addr("127.0.0.1");addrsrv.sin_port = htons(8888);connect(sockclient, (SOCKADDR*)&(addrsrv), sizeof(addrsrv));charrecvbuf[100];memset(recvbuf,0,100);charsendbuf[100];recv(sockclient,recvbuf,100,0);printf("%s\n",recvbuf);sprintf(sendbuf,"我是小强我的通网实验做了。
网络编程_实验报告
一、实验目的1. 理解网络编程的基本原理和概念。
2. 掌握TCP/IP协议的基本工作原理。
3. 学会使用Socket编程实现网络通信。
4. 增强实际操作能力,提高网络编程水平。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.83. 开发工具:PyCharm4. 网络环境:校园局域网三、实验内容本次实验主要实现一个基于TCP协议的简单网络通信程序,包括客户端和服务器端。
1. 服务器端服务器端负责监听客户端的连接请求,接收客户端发送的数据,并回显给客户端。
```pythonimport socket# 创建socket对象server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 获取本地主机名host = socket.gethostname()port = 12345# 绑定端口server_socket.bind((host, port))# 设置最大连接数,超过后排队server_socket.listen(5)print("等待客户端连接...")while True:# 建立客户端连接client_socket, addr = server_socket.accept()print("连接地址:", addr)while True:# 接收客户端数据data = client_socket.recv(1024)if not data:break# 发送数据回客户端client_socket.send(data)# 关闭连接client_socket.close()```2. 客户端客户端负责向服务器端发送数据,并接收服务器端回显的数据。
```pythonimport socket# 创建socket对象client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# 获取本地主机名host = socket.gethostname()port = 12345# 连接服务器client_socket.connect((host, port))# 发送数据client_socket.send("Hello, Server!")# 接收数据data = client_socket.recv(1024)print("从服务器接收到的数据:", data)# 关闭连接client_socket.close()```四、实验步骤1. 编写服务器端代码,并运行程序。
tcp实验报告
tcp实验报告TCP实验报告一、实验目的TCP(Transmission Control Protocol)是一种面向连接的、可靠的传输协议,它在互联网通信中扮演着重要的角色。
本实验旨在通过实际操作和观察,深入理解TCP协议的工作原理和特点。
二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.93. 实验工具:Wireshark三、实验步骤与结果1. 建立TCP连接通过Python的socket库,我们可以轻松地创建TCP连接。
在本实验中,我们编写了一个简单的服务器端和客户端程序,通过本地主机进行通信。
2. 数据传输与流量控制在TCP连接建立后,我们进行了数据的传输实验。
首先,我们发送了一个较小的数据包,观察到数据包的传输过程中,TCP协议会自动进行流量控制,确保数据的可靠传输。
接着,我们发送了一个较大的数据包,发现TCP会将大数据包拆分成多个小数据包进行传输,并在接收端进行重组。
3. 拥塞控制为了模拟网络拥塞的情况,我们在实验中人为地降低了网络带宽。
通过Wireshark抓包分析,我们观察到TCP协议在发现网络拥塞时,会自动减少发送速率,以避免网络的过载。
同时,我们还注意到TCP协议会根据网络的状况动态调整拥塞窗口的大小,以提高网络的利用率。
4. 可靠性与重传机制为了测试TCP协议的可靠性,我们在实验中故意模拟了数据包丢失的情况。
通过Wireshark的分析,我们发现当发送端未收到确认消息时,会自动触发重传机制,确保数据的可靠传输。
同时,TCP还会根据超时时间的动态调整,以适应不同网络环境下的传输速度。
五、实验总结通过本次实验,我们深入了解了TCP协议的工作原理和特点。
TCP作为一种可靠的传输协议,在互联网通信中发挥着重要的作用。
它通过流量控制、拥塞控制和重传机制等手段,确保了数据的可靠传输,并适应了不同网络环境的变化。
在今后的学习和实践中,我们将进一步深入研究TCP协议的细节,并结合实际应用场景,优化网络通信的性能和可靠性。
tcp协议实验报告
竭诚为您提供优质文档/双击可除tcp协议实验报告篇一:Tcp实验报告Tcp实验报告一、实验目的1.深入理解Tcp原理,掌握连接状态控制、可靠传输等重要机制;2.为应用层提供网络编程接口,即socket接口。
二、实验要求1.理解Tcp的主要原理,针对客户端角色的、“停-等”模式的Tcp,设计接收和发送流程。
2.编程实现Tcp段的接收流程,重点是段接收的有限状态机3.编程实现Tcp段的发送流程,完成Tcp段的封装处理。
4.编程实现客户端socket接口函数三、编程实现1.停-等协议的实现停-等协议主要体现在stud_tcp_send()函数和stud_tcp_recv()和函数中。
实现的主要思路是:a)调用stud_tcp_send()发送一个数据包时,直到收到ack包并把ack交给stud_tcp_input()处理才退出b)调用stud_tcp_recv()接收一个数据包成功后,紧接着发送一个相应的ack包才退出上述两个设计保证了发送和接收窗口大小为12.接收流程的有限状态机首先检查校验和与序号是否正确,只有当这两者都无误之后才进入状态机部分。
状态机基于switch结构实现,根据当前Tcb的状态分情形讨论状态的变化。
处理流程如下3.发送时的封装和有限状态机a)查看当前的Tcb是否为空,为空则创建当前的Tcbb)封装数据i.ii.iii.iv.v.vi.拷贝数据设置源端口和目的端口设置包序列和ack 序号设置包头长度设置flag设置windowsize和urgentpointerc)改变状态d)变换字节序将字节序从本地序变成网络序4.各接口函数的实现a)stud_tcp_socket()b)stud_tcp_connect()c)stud_tcp_send()d)stud_tcp_recv()e)stud_tcp_close()5.校验和的计算与Ip包的校验类似,但是要求对伪首部进行校验伪首部由以下部分组成:a)32位Ip源地址b)32位Ip目的地址篇二:Tcp协议实验网络课第四次上机实验报告实验内容实验内容主要包括:?设计保存Tcp连接相关信息的数据结构(Tcb);?Tcp协议的接收处理和封装发送;?Tcp协议提供的socket函数接口。
实验三 基于TCP和UDP的Socket 编程
实验三基于TCP和UDP的SOCKET 编程实验时间:第12、13、14周(6课时)第一部分(2课时):基于TCP的SOCKET 编程一、预习要求:(1)TCP服务(2)UDP服务(3)SOCKET套接字二、实验目的:(1)掌握TCP传输中服务端和客户端程序的设计(2)掌握TCP传输中服务端和客户端程序的设计(3)掌握SOCKET套接字的应用三、实验环境:VC++6.0四、实验内容:预备知识:1、套接字(socket)1)为了能方便的开发网络应用软件,由美国伯克利大学在UNIX上推出了一种应用程序访问通信协议的操作系统调用套接字(socket)。
2)Socket的出现,使程序员可以很方便的访问TCP/IP,从而开发了各种网络应用程序。
3)随着UNIX的应用推广,套接字在编写网络软件中得到了普及,后来套接字又被引进了WINDOWS等操作系统,成为开发网络应用程序的非常有效快捷的工具。
2、套接字类型1)流式套接字(SOCK_STREAM),提供面向连接、可靠的数据传输服务,数据无差错、无重复发送,且按发送顺序接收(TCP服务)。
2)数据报式套接字(SOCK_DGRAM)提供无连接服务。
数据包以独立包形式发送,不提供无错保证,数据可能丢失或重复,并且接受顺序混乱(UDP服务)。
3)原始套接字(SOCK_RAW)3、主要相关函数int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);MAKEWORD();int bind( SOCKET s, const struct sockaddr FAR *name, int namelen);int listen( SOCKET s, int backlog );SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen);int send( SOCKET s, const char FAR *buf, int len, int flags );int recv( SOCKET s, char FAR *buf, int len, int flags );int connect( SOCKET s, const struct sockaddr FAR *name, int namelen );int closesocket( SOCKET s );int WSACleanup (void);任务一:创建TCP服务的服务端实验步骤:1)创建一个Win32 Console Application工程(Project),创建一个源文件(C++ Source File),命名为TcpSrv。
计算机网络一TCPIP协议与Socket编程认识实验
东南大学自动化学院实验报告课程名称:计算机网络实验第 1 次实验实验名称:TCP/IP协议与Socket编程认识实验院(系):自动化专业:自动化姓名:学号:实验室:实验组别:同组人员:实验时间:2012年5月9日评定成绩:审阅教师:一、实验目的和要求:1. 熟悉TCP/IP协议的功能和网络操作;2. 了解MS-DOS环境下基于SOCKET的编程原理;3. 编写一个小型的Socket实用程序,初步了解Windows环境下使用Socket的编程。
二、实验原理:1.Windows Sockets规范:Windows Sockets规范以U.C. Berkeley大学BSD UNIX中流行的Socket接口为范例定义了一套Micosoft Windows下网络编程接口。
它不仅包含了人们所熟悉的Berkeley Socket风格的库函数;也包含了一组针对Windows的扩展库函数,以使程序员能充分地利用Windows消息驱动机制进行编程。
Windows Sockets规范本意在于提供给应用程序开发者一套简单的API,并让各家网络软件供应商共同遵守。
此外,在一个特定版本Windows的基础上,Windows Sockets也定义了一个二进制接口(ABI),以此来保证应用Windows Sockets API的应用程序能够在任何网络软件供应商的符合Windows Sockets协议的实现上工作。
因此这份规范定义了应用程序开发者能够使用,并且网络软件供应商能够实现的一套库函数调用和相关语义。
遵守这套Windows Sockets规范的网络软件,我们称之为Windows Sockets兼容的,而Windows Sockets 兼容实现的提供者,我们称之为Windows Sockets提供者。
一个网络软件供应商必须百分之百地实现Windows Sockets规范才能做到现Windows Sockets兼容。
任何能够与Windows Sockets兼容实现协同工作的应用程序就被认为是具有Windows Sockets接口。
SOCKET实验报告
实验报告实验一 socket编程一、实验目的通过socket程序的编写、调试,掌握socket编程的基本方法,了解客户端与服务器端的特点,掌握并熟悉运用socket类与serversocket类。
二、实验内容①学习socket编程使用的类和接口,着重掌握基于tcp协议的socket。
②编写服务器端的应用程序③编写客户端的应用程序④实现服务器端与客户端的交互三、实验代码1.服务器端程序过程:在端口5000上创建一个等待连接的serversocket对象server:server=newserversocket(5000);接着调用server对象的accept()方法等待某客户程序发出连接请求。
该方法一直阻塞直到有客户连接到带端口。
一旦有客户发送正确请求,则连接成功,accept()方法返回一个socket对象,于是得到了一个新的用于通信的socket对象,通信链路建立成功。
然后利用socket类提供的方法创建socket对象的输入流和输出流。
此后即于客户端进行通信,直到客户端断开连接即关闭各个流结束通信。
代码如下:import .*;import java.io.*;class aa{static public void main (string args[]) throws ioexception {serversocket server=null;socket socket=null;inputstream is=null;outputstream os=null;datainputstream in=null;printstream out=null;try{ //在端口5000注册服务server=new serversocket(5000); socket =server.accept();//侦听连接请求,等待连接system.out.println(**********************服务器端界面*************************);system.out.println(与客户端连接成功!); system.out.println();system.out.println(对话内容为:); system.out.println();system.out.println(等待客户发送信息.....); //获取对应的socket的输入/输出流is=socket.getinputstream();os=socket.getoutputstream(); //建立数据流in= new datainputstream(is); out =new printstream(os);//表示向对方输出string str=in.readline();//逐行读取do{system.out.println(客户端说:+ str); str=in.readline();}while(str.trim().equals(bye)) //如果是“bye”就退出system.out.println(客户想要离开); }catch(exception e) //捕获程序异常{system.out.println(error:+e); }finally{is.close();//关闭输入流os.close();//关闭输出流in.close();//关闭数据输入流socket.close();//关闭socket }}}2.客户端程序过程:首先创建一个指向服务器的指定端口号(5000)的socket对象socket:socket=newsocket(localhost,5000);此时服务器指定为本地计算机,若要在网络中指定服务器,只需要将参数localhost改成相应的服务器名或者ip地址即可。
计算机网络实验报告(路由算法、Socket编程)[修改版]
第一篇:计算机网络实验报告(路由算法、Socket编程)计算机网络实验报告班级:姓名:学号:实验一一.实验目的及要求编写程序,模拟距离矢量路由算法的路由表交换过程,演示交换后的路由表的变化。
二.实验原理距离矢量路由算法是这样工作的:每个路由器维护一张路由表(即一个矢量),它以网络中的每个路由器为索引,表中列出了当前已知的路由器到每个目标路由器的最佳距离,以及所使用的线路。
通过在邻居之间相互交换信息,路由器不断地更新他们的内部路由表。
举例来说,假定使用延迟作为“距离”的度量标准,并且该路由器发送一个列表,其中包含了他到每一个目标路由器的延时估计值;同时,他也从每个邻居路由器接收到一个类似的列表。
假设一个路由器接收到来自邻居x的一个列表,其中x(i)表示x估计的到达路由器i所需要的时间。
如果该路由器知道他到x的延时为m毫秒,那么他也知道在x(i)+m毫秒之间内经过x可以到达路由器i。
一个路由器针对每个邻居都执行这样的计算,就可以发现最佳的估计值,然后在新的路由器表中使用这个最佳的估计值以及对应的输出路线。
三.源程序:#include "stdio.h" #include "stdlib.h" #include "malloc.h" #include "graphics.h" #include "dos.h" #define VERNUM 7typedef struct {int dis;int flag;int flag2; }RoutNode;char tmp[10]; RoutNode data[VERNUM][VERNUM];void welcome();void InitRoutData(FILE* pfile);void PrintRoutData();void SendInf(int recv, int send);void Exchange();int main() {int start, end, i, j, m, n;FILE *pfile;welcome();pfile = fopen("1.txt", "r");if (pfile == NULL){printf("the file wrong,press any key to come back.\n"); getch();return;}elseInitRoutData(pfile);fclose(pfile);printf("\nthe original route table:\n");for (i = 0; i{printf("%c||", i + 65);for (j = 0; j < VERNUM; j++)if (data[i][j].dis > 0)printf("<%c %d> ", j + 65, data[i][j].dis);}PrintRoutData();getch();for (i = 0; i < VERNUM; i++){for (m = 0; m < VERNUM; m++)for (n = 0; n < VERNUM; n++)data[m][n].flag = 0;Exchange();PrintRoutData();getch();}printf("\nexchange the route table:\n"); return 0; }void welcome() {int gdriver=DETECT,gmode; registerbgidriver(EGAVGA_driver); initgraph( &gdriver, &gmode,"C:\Win-TC"); cleardevice();setbkcolor(CYAN);setviewport(0,0,639,479,1); clearviewport();setbkcolor(BLUE);rectangle(200,200,440,280);setfillstyle(1,5);floodfill(300,240,14);settextstyle(0,0,2);outtextxy(50,30,"Distance Vector Routing Algorithm"); setcolor(15);settextstyle(1,0,4);outtextxy(260,214,"Welcome to use!");line(0,80,640,80);getch();delay(300);cleardevice(); } void InitRoutData(FILE* pfile) {char num[10];int i = 0;char c;int m, n;fseek(pfile, 0, 0);for (m = 0; !feof(pfile) && m < 7; m++){for (n = 0; !feof(pfile) && n < 7; n++){while (!feof(pfile)){c = fgetc(pfile);if (c == ','){num[i] = '\0';data[m][n].dis = atoi(num); data[m][n].flag = 0;data[m][n].flag = 0;i = 0;break;} /*end of if*/else if ((c >= '0' && c{num[i++] = c;} /*end of else if*/} /*end of while*/} /*end of for (n = 0*/} /*end of for (m = 0*/ } void PrintRoutData() {int i, j;for (i = 0; i < VERNUM; i++) {settextstyle(1,0,3);sprintf(tmp," %c",i + 65); outtextxy(i*80+50,130,tmp);outtextxy(10,160+i*40,tmp);}for (j = 0; j< VERNUM; j++){for (i = 0; i < VERNUM; i++){if (data[i][j].dis{if(data[i][j].flag2 ==1){setfillstyle(SOLID_FILL,5);bar(80*i+50,40*j+155,80*i+120,40*j+185); delay(50000);data[i][j].flag2 =0;}setfillstyle(SOLID_FILL,3);bar(80*i+50,40*j+155,80*i+120,40*j+185); settextstyle(1,0,2);sprintf(tmp,"-");outtextxy(80*i+65,40*j+165,tmp);}elseif(data[i][j].dis >=0){{setfillstyle(SOLID_FILL,5);bar(80*i+50,40*j+155,80*i+120,40*j+185);delay(50000);data[i][j].flag2 =0;}setfillstyle(SOLID_FILL,3);bar(80*i+50,40*j+155,80*i+120,40*j+185); settextstyle(1,0,2);sprintf(tmp,"%d",data[i][j].dis);outtextxy(80*i+65,40*j+165,tmp);}} /*end of for (j = 0*/} /*end of for (i = 0*/ }void SendInf(int recv, int send) {int i;for (i = 0; i < VERNUM; i++){if (data[send][i].dis > 0&& data[send][i].flag!=1){if (data[recv][i].dis{data[recv][i].dis = data[send][i].dis + data[recv][send].dis;data[recv][i].flag2 =1;}else if (data[recv][i].dis > data[send][i].dis + data[recv][send].dis) {data[recv][i].dis = data[send][i].dis + data[recv][send].dis;data[recv][i].flag =1;data[recv][i].flag2 =1;}} /*end of if*/} /*end of for*/ }void Exchange() {int i, j;for (i = 0; i < VERNUM; i++){for (j = 0; j < VERNUM; j++){if (data[i][j].dis > 0&& data[i][j].flag!=1){SendInf(i, j);} /*end of if*/} /*end of for (j = 0*/} /*end of for (i = 0*/ }四、实验心得体会通过本次实验训练,我了解了距离矢量路由算法的基本原理,复习了C语言编程的内容,通过对路由算法的实现,加深了对路由表交换的理解。
实验5:基于TCP的Sockets编程(解答)
实验五基于TCP的Sockets编程一、实验目的1.熟悉TCP编程的基本过程2.学习Java套接字类的应用3.理解TCP协议相关的基本概念4.掌握TCP协议与I/O流的结合方式5.掌握TCP协议与线程的结合方式二、实验内容1.利用TCP协议实现一个可以从服务器读取时间的网络程序。
2.将该程序的客户端改为一个可以显示服务器时间的图形时钟界面,它每隔一秒从服务器读取服务器当前时间。
3.编写一个网络程序,当注释flush语句后,程序就会挂起。
4.编写一个网络程序,当客户端输入一组坐标值后,服务器就会在指定的位置上绘制点或者折线。
(有兴趣的同学可以考虑将这个程序更改为一个网络绘图程序)三、实验步骤2.根据该数据格式,可编写服务器代码为:package b4;import java.io.*;import .*;import java.util.*;public class DaytimeServer {public static void main(String[] args) {try {ServerSocket ss=new ServerSocket(2007);while(true){Socket s=ss.accept();DataOutputStream out=new DataOutputStream(s.getOutputStream());writeTime(out);out.close();s.close();}} catch (IOException e) {e.printStackTrace();}}public static void writeTime(DataOutputStream out) throws IOException{Calendar current=Calendar.getInstance();out.writeInt(current.get(Calendar.YEAR));out.writeByte(current.get(Calendar.MONTH));out.writeByte(current.get(Calendar.DAY_OF_MONTH));out.writeByte(current.get(Calendar.HOUR_OF_DAY));out.writeByte(current.get(Calendar.MINUTE));out.writeByte(current.get(Calendar.SECOND));}}3.客户端代码为:package b4;import java.io.*;import .*;public class DaytimeClient {public static void main(String[] args) {try {Socket s=new Socket("localhost",2007);DataInputStream in=new DataInputStream(s.getInputStream());printTime(in);} catch (IOException e) {e.printStackTrace();}}static void printTime(DataInputStream in) throws IOException{System.out.println("服务器当前时间是:");System.out.print(in.readInt()+"年");System.out.print(in.readByte()+"月");System.out.print(in.readByte()+"日");System.out.print(in.readByte()+"时");System.out.print(in.readByte()+"分");System.out.print(in.readByte()+"秒");}}4.为了使服务器能够响应多个客户端,必须增加一个线程类,该类的run方法代码如下,请将该类补充完整:public class DaytimeThread extends Thread{Socket s;public DaytimeThread(Socket s){this.s=s;}public void run() {try{DataOutputStream out=new DataOutputStream(s.getOutputStream());Calendar current=Calendar.getInstance();out.writeInt(current.get(Calendar.YEAR));out.writeByte(current.get(Calendar.MONTH));out.writeByte(current.get(Calendar.DAY_OF_MONTH));out.writeByte(current.get(Calendar.HOUR_OF_DAY));out.writeByte(current.get(Calendar.MINUTE));out.writeByte(current.get(Calendar.SECOND));out.close();}catch (IOException e){e.printStackTrace();}}}5.修改服务端程序,使其利用上面的线程类支持多线程;package b4;import java.io.*;import .*;import java.util.*;public class DaytimeServer {public static void main(String[] args) {try {ServerSocket ss=new ServerSocket(2007);while(true){Socket s=ss.accept();new DaytimeThread(s).start();}} catch (IOException e) {e.printStackTrace();}}public static void writeTime(Socket s) throws IOException{DataOutputStream out=new DataOutputStream(s.getOutputStream());Calendar current=Calendar.getInstance();out.writeInt(current.get(Calendar.YEAR));out.writeByte(current.get(Calendar.MONTH));out.writeByte(current.get(Calendar.DAY_OF_MONTH));out.writeByte(current.get(Calendar.HOUR_OF_DAY));out.writeByte(current.get(Calendar.MINUTE));out.writeByte(current.get(Calendar.SECOND));out.close();}}6.基于图形界面的时钟客户端的部分代码如下,请将其补充完整:package b4;import java.applet.*;import java.awt.*;import java.awt.event.*;import java.io.*;import .*;public class DayTimeGUIClient extends Applet {private Graphics gBuf;private Image imgBuf;static int year,month,day,hour,minute,second;public static void main(String[] args) {Frame app = new Frame("时钟客户端");app.setSize(800, 600);app.setLocationByPlatform(true);DayTimeGUIClient applet = new DayTimeGUIClient();app.add(applet);app.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent event) {event.getWindow().dispose();System.exit(0);}});app.show();applet.start();while(true){try {Socket s=new Socket("localhost",2007);DataInputStream in=new DataInputStream(s.getInputStream());readTime(in);s.close();} catch (IOException e) {e.printStackTrace();}applet.repaint();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}static void readTime(DataInputStream in) throws IOException{year=in.readInt();month=in.readByte();day=in.readByte();hour=in.readByte();minute=in.readByte();second=in.readByte();}public void init() {}public void paint(Graphics g) {final double PI=3.1415926;int x0,y0,x1,y1,x2,y2,t;int graphWidth = bounds().width;int graphHeight = bounds().height;imgBuf = createImage(graphWidth, graphHeight);gBuf = imgBuf.getGraphics();gBuf.clearRect(0, 0, graphWidth, graphHeight);//用字符方式显示当前时间gBuf.drawString(year+"年"+month+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒",graphWidth/20,graphHeight/20);//获取直径,圆心坐标int r=(graphWidth<graphHeight)?graphWidth:graphHeight;r=r*6/7;x0=graphWidth/2;y0=graphHeight/2;//绘制时钟刻度gBuf.drawOval((graphWidth-r)/2,(graphHeight-r)/2,r,r);r=r/2;for (t=0;t<60;t++){x1=x0+(int)(r*Math.cos(t*PI/30));y1=y0+(int)(r*Math.sin(t*PI/30));//System.out.println("x1,y1:"+x1+","+y1);if(t%5==0){x2=x0+(int)(r*Math.cos(t*PI/30)*17/20);y2=y0+(int)(r*Math.sin(t*PI/30)*17/20);}else{x2=x0+(int)(r*Math.cos(t*PI/30)*19/20);y2=y0+(int)(r*Math.sin(t*PI/30)*19/20);}//System.out.println("x2,y2:"+x2+","+y2);gBuf.drawLine(x1,y1,x2,y2);}//绘制时针t=60*((hour<12)?hour:hour%12)+minute;x1=x0+(int)(r*Math.cos(t*PI/360-PI/2)*4/10);y1=y0+(int)(r*Math.sin(t*PI/360-PI/2)*4/10);x2=x0+(int)(r*Math.cos(t*PI/360+PI/2)*1/10);y2=y0+(int)(r*Math.sin(t*PI/360+PI/2)*1/10);gBuf.drawLine(x1,y1,x2,y2);//绘制分针t=60*minute+second;x1=x0+(int)(r*Math.cos(t*PI/1800-PI/2)*6/10);y1=y0+(int)(r*Math.sin(t*PI/1800-PI/2)*6/10);x2=x0+(int)(r*Math.cos(t*PI/1800+PI/2)*1/10);y2=y0+(int)(r*Math.sin(t*PI/1800+PI/2)*1/10);gBuf.drawLine(x1,y1,x2,y2);//绘制秒针t=second;x1=x0+(int)(r*Math.cos(t*PI/30-PI/2)*8/10);y1=y0+(int)(r*Math.sin(t*PI/30-PI/2)*8/10);x2=x0+(int)(r*Math.cos(t*PI/30+PI/2)*1/10);y2=y0+(int)(r*Math.sin(t*PI/30+PI/2)*1/10);gBuf.drawLine(x1,y1,x2,y2);g.drawImage(imgBuf, 0, 0, this);}public void update(Graphics g) {paint(g);}}7.编写一个登录的应用来观察flush语句的作用。
TCP和UDP的Socket编程实验
TCP和UDP的Socket编程实验 Linux Socket 函数库是从 Berkeley ⼤学开发的 BSD UNIX 系统中移植过来的。
BSD Socket 接⼝是在众多 Unix 系统中被⼴泛⽀持的 TCP/IP 通信接⼝,Linux 下的 Socket 程序设计,除了微⼩的差别之外,也适⽤于⼤多数其它 Unix 系统。
Socket 的使⽤,和⽂件操作⽐较类似。
如同⽂件的读、写、打开、关闭等操作⼀样,TCP/IP ⽹络通信同样也有这些操作,不过它使⽤的接⼝不是⽂件描述符或者 FILE*,⽽是⼀个称做 Socket 的描述符。
类似于⽂件操作,对于 Socket,也通过读、写、打开、关闭操作来进⾏⽹络数据传送。
同时,还有⼀些辅助的函数,如域名/IP 地址查询、Socket 功能设置等。
这星期的实验是Socket编程实验,我将⾃⼰的套在框架下写的代码分享出来。
⼀份是TCP代码,sender向receiver发送"hello",receiver将"hello"原封不动发回去,sender接收到"hello"后断开连接,两个服务同时down。
第⼆份是UDP代码,receiver监听⾃⼰的端⼝,sender向receiver发送0-8的整数,receiver不会对收到了的信息作确认。
发送完毕后sender down,receiver会继续监听。
阅读接下来的代码需要对Socket中的函数,Socket标志符等概念⼗分清楚,其中⼀份TCP代码经过了详细的注释。
bind(),listen(),send()......这些Socket库中的函数都需要读者提前了解他们的功能。
放出⼀份TCP Receiver的代码,其余的代码在⽂末可以下载。
1 #include <stdio.h>2 #include <string.h>3//数据格式转换4 #include "net_exp.h"5 #include <netinet/in.h>67 main(){8//TCP/IP中专⽤的⽤于监听连接请求的本地地址9struct sockaddr_in client, server;10int s,ns,namelen,pktlen;11char buf[256];12//定义套接字,返回值是Socket描述符13 s = socket(AF_INET, SOCK_STREAM, 0);14//将指针当前位置后⾯的sizeof(server)个字节清015 memset((char*)&server, 0, sizeof(server));16//Address family17 server.sin_family = AF_INET;18//Port number,转换成unsigned short int19 server.sin_port = htons(TCP_SERVER_PORT);20 server.sin_addr.s_addr = INADDR_ANY;21//给已经打开的socket指定本地地址,注意看,传参数的时候有类型转换22 bind(s, (struct sockaddr*)&server, sizeof(server));23//s-Socket描述符,backlog-连接请求暂存队列长度,24//调⽤listen系统将给此Socket配备⼀个连接请求的队列,暂存系统接收到的、申请向此Socket建⽴连接的请求。
实验07-TCP_IP+Socket编程
《计算机网络》实验报告实验序号:07 实验项目名称:TCP_IP Socket编程学号姓名专业、班实验地点实1-514 指导教师实验时间2013-11-26一、实验目的及要求1、通过对路由器安装与配置实验,加深对相关网络设备工作原理理解,掌握其常见产品的安装与配置方法,为将来从事网络工程建设打下基础。
2、通过实验,掌握路由器的基本参数配置、网络接口配置和路由协议配置,掌握静态路由的配置方法。
二、实验设备(环境)及要求计算机;学生不许把食物带到机房吃;不许上网做与实验无关的内容;不许同学之间聊天;保持实验室安静卫生。
下课把键盘,座椅放回原处。
三、实验内容与步骤1.分别编写基于TCP的socket程序服务端和客户端,要求客户端能发送消息到服务端,服务端再把此消息返回给客户端。
服务端:(1)打开vc++6.0,File-》new-》Projects-》Win32 Console Application,输入Project name,例如SimpleTCP_s,选择location后单击OK,选择simple application,单击ok。
(2)打开SimpleTCP_s.cpp,输入如下内容:#include "stdafx.h"#include <stdio.h>#include <winsock2.h> //WINSOCK.H(这个是WINSOCK API的头文件,WIN2K以上支持WINSOCK2,所以//可以用WINSOCK2.H);#pragma comment(lib, "WS2_32.lib")//Ws2_32.lib(WINSOCK API连接库文件).#define BUF_SIZE 1024int main(int argc, char* argv[]){WSADA TA wsaData;SOCKET socketL; // socket for listeningSOCKET socketC; // socket for CommunicationSOCKADDR_IN serverAddr;int nRet = -1;char recvbuf[BUF_SIZE];if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0){printf("WSAStartup failed!\n");return 1;}socketL = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(5678);serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);bind(socketL, (SOCKADDR*)&serverAddr, sizeof(serverAddr));listen(socketL, 5);socketC = accept(socketL, NULL, NULL);if (socketC != INV ALID_SOCKET){nRet = recv(socketC, recvbuf, sizeof(recvbuf), 0);if (nRet > 0)printf("%s ", recvbuf);}closesocket(socketC);closesocket(socketL);WSACleanup();printf("请按回车键关闭");getchar();return 0;}(3)编译工程客户端:(1)和服务端一样操作,建立SimpleTCP_c工程。
python-socket-网络编程实验报告
网络编程实验报告python_socket 网络编程一、TCP编程〔一〕、建立一个TCP服务器连接需要6个步骤:1. 创建socket对象。
调用socket构造函数:socket=socket.socket(familly,type)family的值可以是AF_UNIX(Unix域,用于同一台机器上的进程间通讯),也可以是AF_INET〔对于IPV4协议的TCP和UDP〕,至于type参数,SOCK_STREAM 〔流套接字〕或者SOCK_DGRAM〔数据报文套接字〕,SOCK_RAW〔raw套接字〕。
2. 将socket绑定〔指派〕到指定地址上,socket.bind(address)address必须是一个双元素元组,((host,port)),主机名或者ip地址+端口号。
如果端口号正在被使用或者保留,或者主机名或ip地址错误,则引发socke.error异常。
3. 绑定后,必须准备好套接字,以便接受连接请求。
socket.listen(backlog)backlog指定了最多连接数,至少为1,接到连接请求后,这些请求必须排队,如果队列已满,则拒绝请求。
4. 服务器套接字通过socket的accept方法等待客户请求一个连接:connection,address=socket.accept()调用accept方法时,socket会进入'waiting'〔或阻塞〕状态。
客户请求连接时,方法建立连接并返回服务器。
accept方法返回一个含有俩个元素的元组,形如(connection,address)。
第一个元素〔connection〕是新的socket对象,服务器通过它与客户通信;第二个元素〔address〕是客户的internet地址。
5. 处理阶段,服务器和客户通过send和recv方法通信〔传输数据〕。
服务器调用send,并采用字符串形式向客户发送信息。
send方法返回已发送的字符个数。
计算机网络原理实验报告 基于TCPUDP的Socket编程
实验报告学院(系)名称:计算机科学与工程学院Tcpsever:package uppercase;import java.io.*;import .*;class TCPServer{public static void main(String argv[]) throws Exception{String clientSentence;String capitalizedSentence;ServerSocket welcomeSocket = new ServerSocket(1234);while(true) {Socket connectionSocket = welcomeSocket.accept();BufferedReader infromClient = new BufferedReader(new InputStreamReader(connectionSocket. getInputStream()));DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());clientSentence = infromClient. readLine();capitalizedSentence = clientSentence.toUpperCase() + '\n';outToClient.writeBytes(capitalizedSentence);}}}用udp完成字符串大写Udpsever:package uppercase;import java.io.*;import .*;class UDPServer {clientSocket.send(sendPacket);DatagramPacket receivePacket =new DatagramPacket(receiveData, receiveData.length);clientSocket.receive(receivePacket);String modifiedSentence =new String(receivePacket.getData());System.out.println("FROM SERVER:" + modifiedSentence);clientSocket.close();}}用tcp传输文件package uppercase;import java.io.*;import .Socket;class TCPFileClient {public static void main(String argv[]) throws Exception{String HOST = "0.0.0.0";String filePath = "D:/bn/";BufferedReader infromUser = new BufferedReader(new InputStreamReader(System.in));String fileName = infromUser.readLine();BufferedWriter bWriter = new BufferedWriter(new FileWriter(filePath + fileName));Socket clientSocket = new Socket(HOST, 8810);DataOutputStream outToServer = new DataOutputStream(clientSocket.getOutputStream());Socket connectionSocket = welcomeSocket.accept();BufferedReader infromClient = new BufferedReader(new InputStreamReader(connectionSocket. getInputStream()));DataOutputStream outToClient = new DataOutputStream(connectionSocket.getOutputStream());fileName = infromClient.readLine();BufferedReader bReader = new BufferedReader(new FileReader(filePath + fileName));String strLine = null;outToClient.writeBytes("PREPARE\n");while((strLine = bReader.readLine()) != null) {System.out.println(strLine);if (infromClient.readLine().contains("OK")){outToClient.writeBytes(strLine + '\n');}}outToClient.writeBytes("DONE\n");break;}}}5.实验结论与分析:通过此次实验使我熟悉和掌握socket编程的基本理论和方法。
实验四 基于TCP协议的Socket编程
计算机科学与技术系
提 示:
Client端程序设计的基本步骤:
① ②
创建指向一个服务器固定端口的Socket对象,建立与 服务器的连接。
构造数据输入输出流对象,发送请求消息,接收响应消 息。
③
关闭输入输出流及Socket。
计算机科学与技术系
Java编程注意事项:
1. 2. 3. 4. 5. 6. 程序编写尽量规范化。 Java语言对大小写完全敏感。 文件名与公共类名完全一致(包括大小写)。 类名必须是合法的标识符,且最好能“见名知意”。 Java源程序文件名字的后缀是“.java” 。 用javac编译Java源程序时,源程序文件名应是全名 (包括后缀);而在用java命令执行编译生成的字节码 文件时,则文件名不加后缀。 7. 注意Java语言与C和C++的不同。
计算机科学与技术系
写实验报告注意事项:
1. 必须写“实验名称”和“实验目的”。 2. 还应写出源程序的编译命令行和执行命令行,如果结果 是数字时还应写出执行结果。 3. 写英文字母时注意写清楚大小写。 4. 尽量少写或不写简化字。
计算机科学与技术系
Hale Waihona Puke 实验四基于TCP协议的Socket编程
计算机科学与技术系
实验目的
1. 掌握Java中有关网络编程的基本相关类 2. 练习使用这些类进行基于TCP协议的Socket网络编程
计算机科学与技术系
实验内容
1. 分别编写一个服务端程序和一个客户端程序,两个程序 进行通信
要求: 在两台计算机上测试程序
计算机科学与技术系
作业
提 示:
Server端程序设计的基本步骤:
① ② ③ ④
Socket实现的UDPTCP通信试验
计算机通信网络实验通信实验UDP/TCP一、实验目的熟练掌握UDP、TCP Client/Server模式的通信原理二、实验内容传输控制协议(Transport Control Protocol)是一种面向连接的,可靠的传输层协议。
面向连接是指一次正常的TCP传输需要通过在TCP客户端和TCP服务端建立特定的虚电路连接来完成,该过程通常被称为“三次握手”。
可靠性可以通过很多种方法来提供保证,在这里我们关心的是数据序列和确认。
TCP通过数据分段(Segment)中的序列号保证所有传输的数据可以在远端按照正常的次序进行重组,而且通过确认保证数据传输的完整性。
要通过TCP传输数据,必须在两端主机之间建立连接。
举例说明,TCP客户端需要和TCP服务端建立连接,过程如图所示:客户端告诉服务标志置位。
客户端向服务端提出连接请求。
这时TCP SYN第一步中,。
报头的序列号区中插入自己的ISN端序列号区域合法,需要检查。
客户端在TCP,同时确认收)(SYN标志置位服务端收到该TCP分段后,在第二步以自己的ISN回应)。
TCP分段(ACK标志置位到客户端的第一个TCP。
到此为止建立完整的ISN(ACK标志置位)在第三步中,客户端确认收到服务端的连接,开始全双工模式的数据传输过程。
模式的通信程序。
根据以上内容编写一个TCP Client/Server 事实上网络程序是由两个部分组成:客户端、服务器端它们的建立步骤如下:服务器端socket-->bind-->listen-->accept客户端socket-->connect实验步骤三、TCP Client/Server模式的通信程序;UDP1.编写、调试并运行自己编写的实现程序;2.模式的工作原理,比较二者的不同,如出现异常情况,在TCP Client/Server3.了解实验报告中写出原因分析;4.保留编写的实现程序。
四、实验过程1.TCP Client/Server模式的通信程序服务器端操作socket(套接字):1.在初始化阶段调用WSAStartup()2、建立Socket3、绑定端口4、监听5、服务器端接受客户端的连接请求6、发送及接收信息7、结束socket 连接相应的程序:Server:import java.io.BufferedReader;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.InputStreamReader;import .ServerSocket;import .Socket;public class Server {public static final int PORT = 12345;//监听的端口号public static void main(String[] args) {祓瑳浥漮瑵瀮楲瑮湬尨服务器启动...\n);Server server = new Server();server.init();}public void init() {try {ServerSocket serverSocket = new ServerSocket(PORT);while (true) {// 一旦有堵塞, 则表示服务器与客户端获得了连接Socket client = serverSocket.accept();// 处理这次连接new HandlerThread(client);}} catch (Exception e) {祓瑳浥漮瑵瀮楲瑮湬尨服务器异常: + e.getMessage());}}private class HandlerThread implements Runnable {private Socket socket;public HandlerThread(Socket client) {socket = client;new Thread(this).start();}public void run() {try {// 读取客户端数据DataInputStream input = newDataInputStream(socket.getInputStream());String clientInputStr = input.readUTF();//这里要注意和客户端输出流的写方法对应,否则会抛EOFException// 处理客户端数据祓瑳浥漮瑵瀮楲瑮湬尨客户端发过来的内容: + clientInputStr);// 向客户端回复信息DataOutputStream out = newDataOutputStream(socket.getOutputStream());祓瑳浥漮瑵瀮楲瑮尨请输入:\t);// 发送键盘输入的一行String s = new BufferedReader(newInputStreamReader(System.in)).readLine();out.writeUTF(s);out.close();input.close();} catch (Exception e) {祓瑳浥漮瑵瀮楲瑮湬尨服务器run 异常: + e.getMessage());} finally {if (socket != null) {try {socket.close();} catch (Exception e) {socket = null;祓瑳浥漮瑵瀮楲瑮湬尨服务端finally 异常: +e.getMessage());}}}}}}Client//package com.defonds.socket.begin;import java.io.BufferedReader;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import .Socket;public class Client {public static final String IP_ADDR = 汜捯污潨瑳;//服务器地址public static final int PORT = 12345;//服务器端口号public static void main(String[] args) {System.out.println(客户端启动?尮);System.out.println(当接收到服务器端字符为 \OK\ 的时候, 客户端将终止屜屮);while (true) {Socket socket = null;try {//创建一个流套接字并将其连接到指定主机上的指定端口号socket = new Socket(IP_ADDR, PORT);//读取服务器端数据DataInputStream input = newDataInputStream(socket.getInputStream());//向服务器端发送数据DataOutputStream out = newDataOutputStream(socket.getOutputStream());System.out.print(请输入?屜屴);String str = new BufferedReader(newInputStreamReader(System.in)).readLine();out.writeUTF(str);String ret = input.readUTF();System.out.println(服务器端返回过来的是? + ret);则断开连接 OK 如接收到//if (作屋.equals(ret)) {System.out.println(客户端将关闭连接);Thread.sleep(500);break;}out.close();input.close();} catch (Exception e) {System.out.println(客户端异常尺 + e.getMessage());} finally {if (socket != null) {try {socket.close();} catch (IOException e) {socket = null;System.out.println(客户端 finally 异常尺 +e.getMessage());}}}}}}运行截图:Server::Client心得体会五、在实际的编程UDP/TCP通信实验中,我不仅进一步在本次的编程命令,而且socket熟练掌握模式的通信原理有了更深的了解,知道了它们之间的差异,Client/ServerUDP中对、TCP模式的通信需要“三次握手”建立连接,然后才能进行通信,而且服务器不TCPClient/Server 模式的通信却可以。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Socket编程报告(TCP/IP协议)一.实验目的通过C++来实现TCP/IP协议下的Socket编程,掌握TCP协议的算法实现。
二.实验原理客户端建立Socket,通过端口号和地址确定目标服务器,使用Connect连接到服务器,send发送消息,等待处理,通信完成后调用CloseSocket关闭Socket服务端建立Socket,声明自身的端口号和地址并绑定到Socket,使用Listen打开监听,然后不断用Accept去查看是否有连接,如果有,捕获Socket,并通过Recv获取消息的内容,通信完成后调用CloseSocket关闭这个对应Accept到的Socket,如果不再需要等待任何客户端连接,那么用CloseSocket关闭掉自身的Socket三.实验代码(C++实现)服务器端代码如下:#pragma once#include <stdio.h>#include <winsock.h>#pragma comment (lib,"ws2_32.lib")class CServerNet{public://初始化服务器,返回0表示成功int Init(const char* address,int port);//更新数据void Run();private:SOCKET m_sock;};int CServerNet::Init( const char* address,int port ){int rlt = 0;//用于记录错误信息,并输出int iErrorMsg;//初始化WinSockWSAData wsaData;iErrorMsg = WSAStartup(MAKEWORD(1,1),&wsaData);if (iErrorMsg != NO_ERROR){//初始化WinSock失败printf("wsastartup failed with error : %d\n",iErrorMsg);rlt = 1;return rlt;}//创建服务端Socketm_sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);if (m_sock == INVALID_SOCKET){//创建Socket异常printf("socket failed with error : %d\n",WSAGetLastError()); rlt = 2;return rlt;}//声明信息sockaddr_in serverAddr;serverAddr.sin_family = AF_INET;serverAddr.sin_port = port;serverAddr.sin_addr.s_addr = inet_addr(address);//绑定iErrorMsg = bind(m_sock,(sockaddr*)&serverAddr,sizeof(serverAddr));if (iErrorMsg < 0){//绑定失败printf("bind failed with error : %d\n",iErrorMsg);rlt = 3;return rlt;}return rlt;}void CServerNet::Run(){//公开连接listen(m_sock,5);sockaddr_in tcpAddr;int len = sizeof(sockaddr);SOCKET newSocket;char buf[1024];int rval;do{//接收信息newSocket = accept(m_sock,(sockaddr*)&tcpAddr,&len);if (newSocket == INVALID_SOCKET){//非可用socket}else{//新socket连接printf("new socket connect : %d\n",newSocket);//消息处理do{printf("process\n");//接收数据memset(buf,0,sizeof(buf));rval = recv(newSocket,buf,1024,0);if (rval == SOCKET_ERROR)//这应该是个异常,当客户端没有调用closeSocket就直接退出游戏的时候,将会进入这里printf("recv socket error\n");if (rval == 0)//recv返回0表示正常退出printf("ending connection");else//显示接收到的数据printf("recv %s\n",buf);}while(rval != 0);//关闭对应Accept的socketclosesocket(newSocket);}} while (1);//关闭自身的Socketclosesocket(m_sock);}int main(int argc, char **argv){CServerNet serverNet;int iRlt = serverNet.Init("127.0.0.1",8888);if (iRlt == 0){printf("init ok...\n");serverNet.Run();}elseprintf("serverNet init failed with error : %d\n",iRlt);system("pause");}客户端代码如下:#pragma once#include <stdio.h>#include<windows.h>#pragma comment(lib, "Ws2_32.lib")class CClientNet{public://连接上指定服务器int Connect(int port,const char* address);//发送信息int SendMsg(const char* msg,int len);//关闭void Close();private:SOCKET m_sock;};int CClientNet::Connect( int port,const char* address ){int rlt = 0;//用于记录错误信息并输出int iErrMsg;//启动WinSockWSAData wsaData;iErrMsg = WSAStartup(MAKEWORD(1,1),&wsaData);if (iErrMsg != NO_ERROR)//有错误{printf("failed with wsaStartup error : %d\n",iErrMsg);rlt = 1;return rlt;}//创建Socketm_sock = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);if (m_sock == INVALID_SOCKET)//创建Socket失败{printf("socket failed with error : %d\n",WSAGetLastError());rlt = 2;return rlt;}//目标服务器数据sockaddr_in sockaddrServer;sockaddrServer.sin_family = AF_INET;sockaddrServer.sin_port = port;sockaddrServer.sin_addr.s_addr = inet_addr(address);//连接,sock与目标服务器连接iErrMsg = connect(m_sock,(sockaddr*)&sockaddrServer,sizeof(sockaddrServer));if (iErrMsg < 0){printf("connect failed with error : %d\n",iErrMsg);rlt = 3;return rlt;}return rlt;}int CClientNet::SendMsg(const char* msg,int len){int rlt = 0;int iErrMsg = 0;//发送消息,指定sock发送消息iErrMsg = send(m_sock,msg,len,0);if (iErrMsg < 0)//发送失败{printf("send msg failed with error : %d\n",iErrMsg);rlt = 1;return rlt;}return rlt;}void CClientNet::Close(){closesocket(m_sock);}int main(){CClientNet client;//连接到127.0.0.1(即本地),端口号为8888的服务端printf("Connect\n");client.Connect(8888,"127.0.0.1");//发送消息printf("send msg\n");client.SendMsg("hello\0",sizeof("hello\0"));//关闭socketprintf("close\n");client.Close();system("pause");}四.实验结果五.心得体会通过本次实验,我了解了TCP/IP协议与UDP协议的异同之处,理解了Socket在通信中的地位和作用。
在调试程序过程中的查错纠错也让我对程序有了深刻的理解,虽然程序是借鉴他人的,但我通过调试之后的进一步解析阅读也掌握了其中的原理,收获颇丰。