使用流式字套接字来发送和接收数据代码
使用DatagramSocket发送、接收数据(Socket之UDP套接字)
使用DatagramSocket发送、接收数据(Socket之UDP套接字)用DatagramSocket发送、接收数据(1)Java使用DatagramSocket代表UDP协议的Socket,DatagramSocket本身只是码头,不维护状态,不能产生IO 流,它的唯一作用就是接收和发送数据报,Java使用DatagramPacket来代表数据报,DatagramSocket接收和发送的数据都是通过DatagramPacket对象完成的。
先看一下DatagramSocket的构造器。
DatagramSocket():创建一个DatagramSocket实例,并将该对象绑定到本机默认IP地址、本机所有可用端口中随机选择的某个端口。
DatagramSocket(int prot):创建一个DatagramSocket实例,并将该对象绑定到本机默认IP地址、指定端口。
DatagramSocket(int port, InetAddress laddr):创建一个DatagramSocket实例,并将该对象绑定到指定IP地址、指定端口。
通过上面三个构造器中的任意一个构造器即可创建一个DatagramSocket实例,通常在创建服务器时,创建指定端口的DatagramSocket实例--这样保证其他客户端可以将数据发送到该服务器。
一旦得到了DatagramSocket实例之后,就可以通过如下两个方法来接收和发送数据。
receive(DatagramPacket p):从该DatagramSocket中接收数据报。
send(DatagramPacket p):以该DatagramSocket对象向外发送数据报。
从上面两个方法可以看出,使用DatagramSocket发送数据报时,DatagramSocket并不知道将该数据报发送到哪里,而是由DatagramPacket自身决定数据报的目的地。
就像码头并不知道每个集装箱的目的地,码头只是将这些集装箱发送出去,而集装箱本身包含了该集装箱的目的地。
利用流式套接字实现文件的传输
利用流式套接字实现文件的传输buff=(char *)malloc(nFileLen);iResult=fread(buff,1,nFileLen,f);if(iResult!=nFileLen){printf("读入文件错误!\");return 0;}memset(sendline,0,MAXLINE);memset(recvline,0,MAXLINE);while(i!=nFileLen){recvline[i]=*buff;i++;buff++;}//文件名传输结束sprintf(sendline,"%s#%d%s",file,nFileLen,recvline);iResult=send(s,sendline,sizeof(sendline),0);if(iResult==SOCKET_ERROR){printf("send函数调用错误,错误号:%d",WSAGetLastError()); return -1;}fclose(fp);printf("文件发送完成!\");return iResult;}服务器:int tcp_server_fun_echo(SOCKET s){FILE *fp;int i=0;char flong[4];int iResult = 0;uint32_t nFileLen=1;char recvline[MAXLINE];char file[10];memset(file,0,sizeof(file));memset(recvline,0,sizeof(recvline));for(;;){iResult=recv(s,&file[i],1,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError()); return -1;}if(file[i]=='#')break;elsei++;}file[i]='\\0';fp=fopen(file,"w+");if(fp==NULL)printf("文件打开失败!");//接收文件长度iResult=recv(s,flong,4,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError()); return -1;}sscanf(flong,"%d",&nFileLen);iResult=recv(s,recvline,nFileLen,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError()); return -1;}fputs(recvline,fp);fclose(fp);printf("文件接收成功!\");return iResult;}头文件(上次的实验报告中已经写过):#ifndef p_h//预处理指令,防止重复包含头文件#include#include#include#include#include#pragma coment(lib,"ws2_32.lib")using namespace std;class CSocketFrame{public:int start_up();int clean_up();int set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol);int quit(SOCKET s);SOCKET tcp_server(ULONG uIP,USHORT uPort);SOCKET tcp_server(char *hname,char *sname);SOCKET tcp_client(char *hname,char *sname);SOCKET tcp_client(ULONG uIP,USHORT uPort);};int CSocketFrame::start_up(void){WORD wVersionRequested;WSADATA wsaData;int iResult;wVersionRequested=MAKEWORD(2,2);iResult=WSAStartup(wVersionRequested,&wsaData);if(iResult!=0){printf("WSAStartup 调用错误,错误号:%d\",WSAGetLastError());return -1;}/*if(LOBYTE(wsaData.wVersion!=2||HIBYTE(wsaData.wVersion)! =2)){printf("无法找到可用的WSD版本\");WSACleanup();return -1;//告诉用户无法找到可用的WSD}else{printf("WS2.2初始化成功!\");} */return 0;}int CSocketFrame::clean_up(void){int iResult;iResult=WSACleanup();if(iResult==SOCKET_ERROR){//WSACleanup()调用失败printf("WSACleanup 调用错误,错误号:%d\",WSAGetLastError());return -1;}elseprintf("Winsocket dll释放成功!\") ;return 0;}int CSocketFrame::set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol) {struct servent *sp;struct hostent *hp;char *endptr;unsigned short port;unsigned long ulAddr=INADDR_NONE;//将地址结构socketsddr_in初始化为0,并将地址族设为AF_INETmemset(sap,0,sizeof(*sap));sap->sin_family=AF_INET;if(hname!=NULL){//如果hname不为空,转化地址格式ulAddr=inet_addr(hname);if(ulAddr==INADDR_NONE||ulAddr==INADDR_ANY){//调用错误,调用gethostbyname获得主机地址hp=gethostbyname(hname);if(hp==NULL){printf("未知的主机名,错误号:%d\",WSAGetLastError());return -1;}sap->sin_addr=*(struct in_addr *)hp->h_addr;}elsesap->sin_addr.S_un.S_addr=ulAddr;}else//如果调用者没有指明一个主机名或地址,则设为通配地址sap->sin_addr.s_addr=htonl(INADDR_ANY);//尝试转换sname为一个整数port=(unsigned short)strtol(sname,&endptr,0);if(*endptr=='\\0'){//如果成功转化为网络字节序sap->sin_port=htons(port);}else{//如果失败,则假定是一个服务名称,通过getservbyname()函数获得端口号sp=getservbyname(sname,protocol);if(sp==NULL){printf("未知服务,错误号:%d\",WSAGetLastError());return -1;}sap->sin_port=sp->s_port;}return 0;}int CSocketFrame::quit(SOCKET s){int iResult=0;iResult=closesocket(s);if(iResult==SOCKET_ERROR){printf("closesocket 调用错误,错误号:%d\",WSAGetLastError());return -1;}iResult=clean_up();return iResult;}SOCKET CSocketFrame::tcp_server(char *hname,char *sname) {SOCKET ListenSocket;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号if(set_address(hname,sname,&local,(char*)"tcp")!=0)return -1;//创建套接字ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\",WSAGetLastError());WSACleanup();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==-1){printf("bind函数调用错误!错误号:%d\",WSAGetLastError());closesocket(ListenSocket);WSACleanup();return -1;}//设置函数为监听状态,监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误!错误号:%d\",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_server(ULONG uIP,USHORT uPort){SOCKET ListenSocket=INVALID_SOCKET;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号memset(&local,0,sizeof(local));local.sin_family=AF_INET;local.sin_addr.S_un.S_addr=htonl(uIP);local.sin_port=htons(uPort);ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\",WSAGetLastError());clean_up();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==SOCKET_ERROR){printf("bind函数调用错误!错误号:%d\",WSAGetLastError());quit(ListenSocket);return -1;}//设置函数为监听状态,监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误!错误号:%d\",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_client(char *hname,char *sname) {int iResult=0;struct sockaddr_in peer;SOCKET ClientSocket;//为服务器的地址peer设置用户输入的地址以及端口号if(set_address(hname,sname,&peer,(char *)"tcp")!=0)return -1;//创建套接字ClientSocket=socket(AF_INET,SOCK_STREAM,0);if(ClientSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\",WSAGetLastError());clean_up();return -1;}//请求建立连接iResult=connect(ClientSocket,(struct sockaddr *) & peer,sizeof(peer));if(iResult==SOCKET_ERROR){printf("connect函数调用错误!错误号:%d\",WSAGetLastError());quit(ClientSocket);return -1;}return ClientSocket;}SOCKET CSocketFrame::tcp_client(ULONG uIP,USHORT uPort) {int iResult=0;struct sockaddr_in peer;。
socket函数的三个参数
socket函数的三个参数标题:socket函数的使用方法导语:在计算机网络中,socket函数是一种用于实现网络通信的编程接口。
它是网络应用程序与网络之间的通信端点,通过socket函数可以实现进程间的通信和数据传输。
本文将详细介绍socket函数的三个参数的使用方法,帮助读者理解并能够灵活应用socket函数。
一、参数一:domain(套接字的协议域)在socket函数中,参数domain指定了套接字的协议域。
协议域是一组协议的集合,它定义了套接字可以用于通信的协议类型。
常用的协议域包括AF_INET(IPv4协议)、AF_INET6(IPv6协议)、AF_UNIX(本地通信协议)等。
1. AF_INET(IPv4协议)在使用IPv4协议进行通信时,可以使用AF_INET作为套接字的协议域。
IPv4协议是当前广泛应用的网络协议,它使用32位地址来标识网络中的主机。
2. AF_INET6(IPv6协议)当需要使用IPv6协议进行通信时,可以选择AF_INET6作为套接字的协议域。
IPv6协议是IPv4协议的升级版,它使用128位地址来标识网络中的主机,解决了IPv4地址不足的问题。
3. AF_UNIX(本地通信协议)如果需要在同一台主机上的进程之间进行通信,可以选择AF_UNIX 作为套接字的协议域。
AF_UNIX提供了一种本地通信的方式,不需要通过网络传输数据。
二、参数二:type(套接字的类型)在socket函数中,参数type指定了套接字的类型。
套接字的类型决定了套接字的工作方式和特性。
常用的套接字类型包括SOCK_STREAM(流式套接字)和SOCK_DGRAM(数据报套接字)。
1. SOCK_STREAM(流式套接字)当需要建立可靠的、面向连接的通信时,可以选择SOCK_STREAM作为套接字的类型。
流式套接字提供了一种面向连接的、可靠的通信方式,数据按照顺序传输,不会丢失和重复。
2. SOCK_DGRAM(数据报套接字)如果需要进行无连接的、不可靠的通信,可以选择SOCK_DGRAM作为套接字的类型。
c语言socket函数
c语言socket函数Socket函数是在网络编程中非常重要的一部分,它提供了一种能够在网络上进行通信的机制。
在C语言中,Socket函数库提供了一组函数,用于创建、绑定、连接、接受和发送套接字等操作。
1.创建套接字:- socket(函数用于创建一个套接字,它接收三个参数:协议族(如AF_INET表示IPv4协议族)、套接字类型(如SOCK_STREAM表示面向连接的流式套接字)和协议(通常为0)。
- 示例:int sockfd = socket(AF_INET, SOCK_STREAM, 0);2.绑定套接字:- bind(函数用于将创建的套接字与指定的地址和端口绑定,以便在网络上监听和接收数据。
- 示例:struct sockaddr_in addr;addr.sin_family = AF_INET;addr.sin_port = htons(8080);addr.sin_addr.s_addr = htonl(INADDR_ANY);bind(sockfd, (struct sockaddr *)&addr, sizeof(addr));3.监听套接字:- listen(函数用于将套接字设置为监听模式,用于接收来自网络的连接请求。
- 示例:listen(sockfd, 5);4.接受连接:- accept(函数用于接受客户端的连接请求,并返回一个新的套接字用于与客户端进行通信。
- 示例:int newsockfd = accept(sockfd, (struct sockaddr *)&addr, sizeof(addr));5.连接服务器:- connect(函数用于向服务器发送连接请求,并与服务器建立通信。
- 示例:struct sockaddr_in serv_addr;serv_addr.sin_family = AF_INET;serv_addr.sin_port = htons(8080);serv_addr.sin_addr.s_addr = inet_addr("127.0.0.1");connect(sockfd, (struct sockaddr *)&serv_addr,sizeof(serv_addr));6.发送和接收数据:- send(函数用于发送数据到已连接的套接字。
linux socket编程基础(必读)
(2) void bcopy(const void * src,void * dest,int n):从参数 src 指定 的内存区域拷贝指定数目的字节内容到参数 dest 指定的内存区域。
在调用函数 connect 之前,客户机需要指定服务器进程的套接字地址。客户 机一般不需要指定自己的套接字地址(IP 地址和端口号),系统会自动从1024 至5000的端口号范围内为它选择一个未用的端口号,然后以这个端口号和本机 的 IP 地址填充这个套接字地址。
客户机调用函数 connect 来主动建立连接。这个函数将启动 TCP 协议的3次 握手过程。在建立连接之后或发生错误时函数返回。连接过程可能出现的错误情 况有:
(2) 如果远程 TCP 协议返回一个 RST 数据段,函数立即以错误返回,错 误类型为 ECONNREFUSED。当远程机器在 SYN 数据段指定的目的端口号处
没有服务进程在等待连接时,远程机器的 TCP 协议将发送一个 RST 数据段,向 客户机报告这个错误。客户机的 TCP 协议在接收到 RST 数据段后不再继续发送 SYN 数据段,函数立即以错误返回。
(3) int bcmp(const void * s1,const void * s2,int n):比较参数 s1指 定的内存区域和参数 s2指定的内存区域的前 n 个字节内容,如果相同则返回0, 否则返回非0。
注:以上函数的原型定义在 strings.h 中。 以 mem 开头的函数有: (1) void * memset(void * s,int c,size_t n):将参数 s 指定的内存区 域的前 n 个字节设置为参数 c 的内容。 (2) void * memcpy(void * dest,const void * src,size_t n):功能同 bcopy (),区别:函数 bcopy()能处理参数 src 和参数 dest 所指定的区域有重叠的 情况,memcpy()则不能。 (4) int memcmp(const void * s1,const void * s2,size_t n):比较参 数 s1和参数 s2指定区域的前 n 个字节内容,如果相同则返回0,否则返回非0。 注:以上函数的原型定义在 string.h 中。 9、 基本套接字函数 (1) socket() #include<sys/types.h> #include<sys/socket.h>
网络编程CAsyncSocket类
• Connect()成员函数的两种格式:
BOOL Connect( LPCTSTR lpszHostAddress, UINT nHostPort ); – lpszHostAddress指定服务器地址的字符串,可以使用域名 ()或IP地址(128.56.22.8); – lpSockAddrLen给出lpSockAddr结构变量中地址的长度, 以字节为单位。 BOOL Connect( const SOCKADDR* lpSockAddr, int nSockAddrLen );
二、CAsyncSocket类接受处理的消息事件(3)
(4) FD_CONNECT事件通知:通知请求连接的套接字,连接
的要求已被处理。
• 当客户端的连接请求已经被处理时产生该事件。 • 该事件仅对流式套接口有效,发生在客户端。 • 有两种情况: – 服务器已经接收了连接请求,双方的连接已经建立,通 知客户端套接口,可以用来传输数据了; – 连接情况被拒绝,通知客户套接口,它所请求的连接失 败。
– (2)CSocket类更容易使用。CSocket管理了通信的许多方面,如 字节顺序问题和字符串转换问题。这些在使用原始API或 CAsyncSocket类时,都必须用户自己做。 – (3)CSocket类为Windows消息的后台处理提供了阻塞的工作模 式,这是CArchive同步操作所必须的。
MFC的两种编程模式- CSocket类
• CSocket类从CAsyncSocket类派生,是对Windows Sockets API的高级封装。 • CSocket类继承了CAsyncSocket类的许多成员函数,用法 一致。 • CSocket类的高级表现在三个方面:
– (1)CSocket结合archive类来使用套接字。
packetsender发送tcp用法
packetsender发送tcp用法摘要:1.介绍TCP 协议和packetsender 库2.阐述使用packetsender 发送TCP 数据的方法3.实例演示如何使用packetsender 发送TCP 数据4.总结正文:TCP(Transmission Control Protocol)即传输控制协议,是一种面向连接的、可靠的、基于字节流的传输层通信协议。
在网络编程中,我们常常需要使用TCP 协议来发送和接收数据。
在Python 中,可以使用packetsender 库来方便地实现TCP 数据的发送。
packetsender 是一个Python 库,它提供了低层次的网络编程接口,可以方便地实现TCP/UDP 数据的发送和接收。
使用packetsender 发送TCP 数据的方法如下:首先,需要导入packetsender 库,并创建一个TCP 套接字。
然后,通过套接字对象的send() 方法发送数据。
最后,通过套接字对象的close() 方法关闭套接字。
下面是一个使用packetsender 发送TCP 数据的实例:```pythonimport packetsender# 创建一个TCP 套接字tcp_socket = packetsender.TCPSocket("127.0.0.1", 12345)# 发送数据tcp_socket.send("Hello, TCP!")# 关闭套接字tcp_socket.close()```在这个实例中,我们首先导入了packetsender 库,然后创建了一个TCP 套接字,该套接字连接到本地地址127.0.0.1 和端口12345。
接下来,我们通过send() 方法发送了一个字符串"Hello, TCP!"。
最后,我们通过close() 方法关闭了套接字。
通过以上步骤,我们就可以使用packetsender 库方便地发送TCP 数据了。
实验1基于流式套接字的网络程序设计(计算机网络Ⅱ)
实验1基于流式套接字的⽹络程序设计(计算机⽹络Ⅱ)实验1 基于流式套接字的⽹络程序设计⼀、实验环境操作系统:Win10开发⼯具:VS2017使⽤语⾔:C⼆、实验内容1.设计思路(1)流式套接字编程模型①通信过程服务器通信过程如下:1.socket初始化;2.创建套接字,指定使⽤TCP进⾏通信;3.指定本地地址和通信端⼝;4.等待客户端的连接请求;5.进⾏数据传输;6.关闭套接字;7.结束对Windows socket dll的使⽤。
客户端通信过程如下:1.socket初始化;2.创建套接字,指定使⽤TCP进⾏通信;3.指定服务器地址和通信端⼝;4.向服务器发送连接请求;5.进⾏数据传输;6.关闭套接字;7.结束对Windows socket dll的使⽤。
②客户-服务器交互模型在通常情况下,⾸先服务器处于监听状态,它随时等待客户连接请求的到来,⽽客户的连接请求则由客户根据需要随时发出;连接建⽴后,双⽅在连接通道上进⾏数据交互;在会话结束后,双⽅关闭连接。
由于服务器端的服务对象通常不限于单个,因此在服务器的函数设置上考虑了多个客户同时连接服务器的情形,基于流式套接字的客户-服务器交互模型如图1-1所⽰。
图1-1 基于流式套接字的客户-服务器交互模型服务器进程要先于客户进程启动,每个步骤中调⽤的套接字函数如下:1.调⽤WSAStartup()函数加载Windows Sockets DLL,然后调⽤socket()函数创建流式套接字,返回套接字s;2.调⽤bind()函数将套接字s绑定到⼀个本地的端点地址上;3.调⽤listen()将套接字s设置为监听模式,准备好接受来⾃各个客户的连接请求;4.调⽤accept()函数等待接受客户的连接请求;5.如果接受到客户的连接请求,则accept()函数返回,得到新的套接字ns;6.调⽤recv()函数在套接字ns上接收来⾃客户的数据;7.处理客户的服务器请求;8.调⽤send()函数在套接字ns上向客户发送数据;9.与客户结束通信后,由客户进程断开连接。
C++套接字编程示例
sockets(套接字)编程有三种,流式套接字(SOCK_STREAM),数据报套接字(SOCK_DGRAM),原始套接字(SOCK_RAW);基于TCP的socket编程是采用的流式套接字。
服务器端编程的步骤:1:加载套接字库,创建套接字(WSAStartup()/socket());2:绑定套接字到一个IP地址和一个端口上(bind());3:将套接字设置为监听模式等待连接请求(listen());4:请求到来后,接受连接请求,返回一个新的对应于此次连接的套接字(accept());5:用返回的套接字和客户端进行通信(send()/recv());6:返回,等待另一连接请求;7:关闭套接字,关闭加载的套接字库(closesocket()/WSACleanup())。
客户端编程的步骤:1:加载套接字库,创建套接字(WSAStartup()/socket());2:向服务器发出连接请求(connect());3:和服务器端进行通信(send()/recv());4:关闭套接字,关闭加载的套接字库(closesocket()/WSACleanup())。
第一式: 加载/释放Winsock库:1.加载方法:WSADATA wsa;/*初始化socket资源*/if (WSAStartup(MAKEWORD(1,1),&wsa) != 0){return; //代表失败}2.释放方法:WSACleanup();第二式: 构造SOCKET:1.服务端:构造监听SOCKET,流式SOCKET.SOCKET Listen_Sock = socket(AF_INET, SOCK_STREAM, 0)2.客户端:构造通讯SOCKET,流式SOCKET.SOCKET Client_Sock = socket(AF_INET, SOCK_STREAM, 0)第三式:配置监听地址和端口:1.服务端: SOCKADDR_IN serverAddrZeroMemory((char *)&serverAddr,sizeof(serverAddr));serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(1234); /*本地监听端口:1234*/serverAddr.sin_addr.s_addr = htonl(INADDR_ANY); /*有IP*/第四式: 绑定SOCKET:1.服务端:绑定监听SOCKET.bind(Listen_Sock,(struct sockaddr *)&serverAddr,sizeof(serverAddr)) 第五式: 服务端/客户端连接:1.服务端:等待客户端接入.SOCKET Command_Sock = accept(Listen_Sock, ...)2.客户端:请求与服务端连接.int ret = connect(Client_Sock, ...)第六式: 收/发数据:1.服务端:等待客户端接入.char buf[1024].接收数据:recv(Command_Sock,buf, ...)或发送数据:send(Command_Sock,buf, ...)2.客户端:请求与服务端连接.char buf[1024].发送数据:send(Client_Sock,buf, ...)或接收数据:recv(Client_Sock,buf, ...)第七式: 关闭SOCKET:1.服务端:关闭SOCKET.closesocket(Listen_Sock)closesocket(Command_Sock)2.客户端:关闭SOCKET.closesocket(Client_Sock)客户机端#include <stdio.h>#include <Winsock2.h>void main(){//加载winsocket库WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) {return;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup( );return;}//创建socketSOCKET sockClient=socket(AF_INET,SOCK_STREAM,0);//创建socket要连接的(地址:端口)SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1"); addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);//请求与服务器建立连接connect(sockClient,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR)); //发送数据send(sockClient,"hello",strlen("hello")+1,0);char recvBuf[50];//接受数据recv(sockClient,recvBuf,50,0);printf("%s\n",recvBuf);//关闭套接字closesocket(sockClient);//释放Socket库WSACleanup();}服务器端#include <stdio.h>#include <Winsock2.h>void main(){//加载Winsock库WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) {return;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) { WSACleanup( );return;}//建立流式SocketSOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//配置监听端口号SOCKADDR_IN addrSrv;addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY); addrSrv.sin_family=AF_INET;addrSrv.sin_port=htons(6000);//绑定监听socket(socket和端口绑定在一起)bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR)); //在Socket上监听listen(sockSrv,5);//定义一个变量,将存储客户端地址SOCKADDR_IN addrClient;int len=sizeof(SOCKADDR);while(1){//等待客户端接入SOCKETsockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len); char sendBuf[50];sprintf(sendBuf,"Welcome %s tohere!",inet_ntoa(addrClient.sin_addr));//发送数据send(sockConn,sendBuf,strlen(sendBuf)+1,0);char recvBuf[50];//接受数据recv(sockConn,recvBuf,50,0);printf("%s\n",recvBuf);//关闭套接字closesocket(sockConn);}}面向无连接的套接字编程(数据报套接字)客户端:#include "Winsock2.h"#include "stdio.h"int main(){//加载socket库函数WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) {return 0;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup( );return 0;}//创建套接字SOCKET sockClient = socket(AF_INET,SOCK_DGRAM,0);SOCKADDR_IN sockSrv; //创建地址+端口sockSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");sockSrv.sin_family = AF_INET ;sockSrv.sin_port = htons(6000);//直接发送sendto(sockClient,"hello",strlen("hello")+1,0,(SOCKADDR*)&sockSrv,sizeof(S OCKADDR));closesocket(sockClient);WSACleanup();return 0;}服务器:#include "Winsock2.h"#include "stdio.h"int main(){//加载socket库函数WORD wVersionRequested;WSADATA wsaData;int err;wVersionRequested = MAKEWORD( 1, 1 );err = WSAStartup( wVersionRequested, &wsaData );if ( err != 0 ) {return 0;}if ( LOBYTE( wsaData.wVersion ) != 1 ||HIBYTE( wsaData.wVersion ) != 1 ) {WSACleanup( );return 0;}//创建套接字SOCKET sockSrv = socket(AF_INET,SOCK_DGRAM,0); SOCKADDR_IN addSrv;addSrv.sin_addr.S_un.S_addr=inet_addr("127.0.0.1");addSrv.sin_family = AF_INET ;addSrv.sin_port = htons(6000);bind(sockSrv,(SOCKADDR*)&addSrv,sizeof(SOCKADDR));while(1){SOCKADDR_IN addrClient;int len = sizeof(SOCKADDR);char recvBuf[100];recvfrom(sockSrv,recvBuf,100,0,(SOCKADDR*)&addrClient,&len); printf("%sn",recvBuf);}closesocket(sockSrv);WSACleanup();return 0;}。
CONNECT函数
作者:曾宏安,华清远见嵌入式学院讲师。
在网络编程中,connect函数经常用来在套接字上初始化连接。
无论是流式套接字还是数据报套接字都可以使用connect函数,但含义却不一样。
下面我们分别来讨论一下:一、流式套接字流式套接字通常使用的是面向连接的协议,如TCP协议。
该类型套接字在双方通信之前要先建立连接。
具体说就是服务器端创建监听套接字并绑定地址,客户端调用connect函数建立连接。
该函数原型如下:int connect(int sockfd,const struct sockaddr&serv_addr,socklen_t addr_len);sockfd是客户端创建的流式套接字;serv_addr指向存放服务器地址信息的结构体;addr_len 是该结构体的长度。
实际上,我们通过抓包分析可以得知:客户端和服务器端通过如下三次握手后即建立好了连接。
SYN客户端----------------->服务器端ACK,SYN服务器端----------------->客户端ACK客户端----------------->服务器端一旦建立好连接,客户端就可以通过该套接字和服务器端通信了。
需要注意的是:因为是建立好了连接,所以使用send/recv发送/接收数据,无需指定对方的地址。
但一个套接字只能connect一次。
如果客户端要和其他的服务器通信的话,必须再创建一个流式套接字,重新连接。
二、数据报套接字数据报套接字通常使用的是无连接的协议。
该类套接字在双方通信之前不用先建立连接,可以直接使用sendto/recvfrom收发数据。
但在发送数据时必须指定对方的地址;在接收数据时通常也需要保存对方的地址。
看到这里大家应该发现了流式套接字和数据报套接字的一个区别:前者只能和一方通信;后者可以和多方通信。
数据报套接字同样可以使用connect函数,但含义并不是建立连接而是限定该套接字只和指定的一方通信。
利用流式套接字实现文件的传输
buff=(char *)malloc(nFileLen);iResult=fread(buff,1,nFileLen,f);if(iResult!=nFileLen){printf("读入文件错误!\n");return 0;}memset(sendline,0,MAXLINE);memset(recvline,0,MAXLINE);while(i!=nFileLen){recvline[i]=*buff;i++;buff++;}//文件名传输结束sprintf(sendline,"%s#%d%s",file,nFileLen,recvline);iResult=send(s,sendline,sizeof(sendline),0);if(iResult==SOCKET_ERROR){printf("send函数调用错误,错误号:%d",WSAGetLastError());return -1;}fclose(fp);printf("文件发送完成!\n");return iResult;}服务器:int tcp_server_fun_echo(SOCKET s){FILE *fp;int i=0;char flong[4];int iResult = 0;uint32_t nFileLen=1;char recvline[MAXLINE];char file[10];memset(file,0,sizeof(file));memset(recvline,0,sizeof(recvline));for(;;){iResult=recv(s,&file[i],1,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError());return -1;}if(file[i]=='#')break;elsei++;}file[i]='\0';fp=fopen(file,"w+");if(fp==NULL)printf("文件打开失败!");//接收文件长度iResult=recv(s,flong,4,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError());return -1;}sscanf(flong,"%d",&nFileLen);iResult=recv(s,recvline,nFileLen,0);if(iResult==SOCKET_ERROR){printf("recv函数调用错误,错误号:%d",WSAGetLastError());return -1;}fputs(recvline,fp);fclose(fp);printf("文件接收成功!\n");return iResult;}头文件(上次的实验报告中已经写过):#ifndef p_h//预处理指令,防止重复包含头文件#include<stdio.h>#include<time.h>#include<ws2tcpip.h>#include<winsock2.h>#include<windows.h>#pragma coment(lib,"ws2_32.lib")using namespace std;class CSocketFrame{public:int start_up();int clean_up();int set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol);int quit(SOCKET s);SOCKET tcp_server(ULONG uIP,USHORT uPort);SOCKET tcp_server(char *hname,char *sname);SOCKET tcp_client(char *hname,char *sname);SOCKET tcp_client(ULONG uIP,USHORT uPort);};int CSocketFrame::start_up(void){WORD wVersionRequested;WSADATA wsaData;int iResult;wVersionRequested=MAKEWORD(2,2);iResult=WSAStartup(wVersionRequested,&wsaData);if(iResult!=0){printf("WSAStartup 调用错误,错误号:%d\n",WSAGetLastError());return -1;}/*if(LOBYTE(wsaData.wVersion!=2||HIBYTE(wsaData.wVersion)!=2)){printf("无法找到可用的WSD版本\n");WSACleanup();return -1;//告诉用户无法找到可用的WSD}else{printf("WS2.2初始化成功!\n");} */return 0;}int CSocketFrame::clean_up(void){int iResult;iResult=WSACleanup();if(iResult==SOCKET_ERROR){//WSACleanup()调用失败printf("WSACleanup 调用错误,错误号:%d\n",WSAGetLastError());return -1;}elseprintf("Winsocket dll释放成功!\n") ;return 0;}int CSocketFrame::set_address(char *hname,char *sname,struct sockaddr_in *sap,char *protocol){struct servent *sp;struct hostent *hp;char *endptr;unsigned short port;unsigned long ulAddr=INADDR_NONE;//将地址结构socketsddr_in初始化为0,并将地址族设为AF_INETmemset(sap,0,sizeof(*sap));sap->sin_family=AF_INET;if(hname!=NULL){//如果hname不为空,转化地址格式ulAddr=inet_addr(hname);if(ulAddr==INADDR_NONE||ulAddr==INADDR_ANY){//调用错误,调用gethostbyname获得主机地址hp=gethostbyname(hname);if(hp==NULL){printf("未知的主机名,错误号:%d\n",WSAGetLastError());return -1;}sap->sin_addr=*(struct in_addr *)hp->h_addr;}elsesap->sin_addr.S_un.S_addr=ulAddr;}else//如果调用者没有指明一个主机名或地址,则设为通配地址sap->sin_addr.s_addr=htonl(INADDR_ANY);//尝试转换sname为一个整数port=(unsigned short)strtol(sname,&endptr,0);if(*endptr=='\0'){//如果成功转化为网络字节序sap->sin_port=htons(port);}else{//如果失败,则假定是一个服务名称,通过getservbyname()函数获得端口号sp=getservbyname(sname,protocol);if(sp==NULL){printf("未知服务,错误号:%d\n",WSAGetLastError());return -1;}sap->sin_port=sp->s_port;}return 0;}int CSocketFrame::quit(SOCKET s){int iResult=0;iResult=closesocket(s);if(iResult==SOCKET_ERROR){printf("closesocket 调用错误,错误号:%d\n",WSAGetLastError());return -1;}iResult=clean_up();return iResult;}SOCKET CSocketFrame::tcp_server(char *hname,char *sname){SOCKET ListenSocket;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号if(set_address(hname,sname,&local,(char*)"tcp")!=0)return -1;//创建套接字ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\n",WSAGetLastError());WSACleanup();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==-1){printf("bind函数调用错误!错误号:%d\n",WSAGetLastError());closesocket(ListenSocket);WSACleanup();return -1;}//设置函数为监听状态,监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误!错误号:%d\n",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_server(ULONG uIP,USHORT uPort){SOCKET ListenSocket=INVALID_SOCKET;int iResult=0;sockaddr_in local;const int on=1;//为服务器的本机地址设置用户输入的地址以及端口号memset(&local,0,sizeof(local));local.sin_family=AF_INET;local.sin_addr.S_un.S_addr=htonl(uIP);local.sin_port=htons(uPort);ListenSocket=socket(AF_INET,SOCK_STREAM,0);if(ListenSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\n",WSAGetLastError());clean_up();return -1;}//绑定服务器地址iResult=bind(ListenSocket,(struct sockaddr *) & local,sizeof(local));if(iResult==SOCKET_ERROR){printf("bind函数调用错误!错误号:%d\n",WSAGetLastError());quit(ListenSocket);return -1;}//设置函数为监听状态,监听队列长度为NLISTENiResult=listen(ListenSocket,SOMAXCONN);if(iResult==SOCKET_ERROR){printf("Listen函数调用错误!错误号:%d\n",WSAGetLastError());quit(ListenSocket);return -1;}return ListenSocket;}SOCKET CSocketFrame::tcp_client(char *hname,char *sname){int iResult=0;struct sockaddr_in peer;SOCKET ClientSocket;//为服务器的地址peer设置用户输入的地址以及端口号if(set_address(hname,sname,&peer,(char *)"tcp")!=0)return -1;//创建套接字ClientSocket=socket(AF_INET,SOCK_STREAM,0);if(ClientSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\n",WSAGetLastError());clean_up();return -1;}//请求建立连接iResult=connect(ClientSocket,(struct sockaddr *) & peer,sizeof(peer));if(iResult==SOCKET_ERROR){printf("connect函数调用错误!错误号:%d\n",WSAGetLastError());quit(ClientSocket);return -1;}return ClientSocket;}SOCKET CSocketFrame::tcp_client(ULONG uIP,USHORT uPort){int iResult=0;struct sockaddr_in peer;SOCKET ClientSocket;//为服务器的地址peer设置用户输入的地址以及端口号memset(&peer,0,sizeof(peer));peer.sin_family=AF_INET;peer.sin_addr.S_un.S_addr=htonl(uIP);peer.sin_port=htons(uPort);//创建套接字ClientSocket=socket(AF_INET,SOCK_STREAM,0);if(ClientSocket==INVALID_SOCKET){printf("socket函数调用错误,错误号:%d\n",WSAGetLastError());clean_up();return -1;}//请求建立连接iResult=connect(ClientSocket,(struct sockaddr *) & peer,sizeof(peer));if(iResult==SOCKET_ERROR){printf("connect函数调用错误!错误号:%d\n",WSAGetLastError());quit(ClientSocket);return -1;}return ClientSocket;}#endif【实验中出现问题及解决方法】问题1:如何获取文件长度解决:运用fseek(),ftell(),rewind()进行文件长度的获取。
流式套接字编程
流式套接字编程是一种网络编程技术,用于在TCP/IP网络上进行数据传输。
它使用流式套接字(socket)作为通信的端点,通过建立连接、发送和接收数据来实现网络通信。
在流式套接字编程中,通常需要遵循以下步骤:1. 创建套接字:使用系统调用socket()创建一个套接字对象,指定通信协议(如TCP或UDP)和地址族(如IPv4或IPv6)。
2. 绑定地址:使用系统调用bind()将套接字绑定到一个本地地址和端口号,以便接收来自该地址和端口的连接或数据。
3. 监听连接:对于服务器端,使用系统调用listen()开始监听来自客户端的连接请求。
对于客户端,不需要调用listen()函数。
4. 接受连接:对于服务器端,使用系统调用accept()接受来自客户端的连接请求,并返回一个新的套接字用于与客户端进行通信。
对于客户端,不需要调用accept()函数。
5. 发送和接收数据:使用系统调用send()和recv()函数发送和接收数据。
这些函数可以用于在已建立的连接上进行数据传输。
6. 关闭套接字:使用系统调用close()或shutdown()函数关闭套接字,释放资源。
在流式套接字编程中,需要注意以下几点:1. 阻塞和非阻塞:流式套接字可以是阻塞的或非阻塞的。
阻塞套接字在发送或接收数据时会导致调用线程阻塞,而非阻塞套接字则不会阻塞调用线程。
2. 错误处理:在进行网络编程时,需要处理各种可能的错误情况,如连接失败、发送或接收数据失败等。
3. 多线程或多进程:为了提高性能和并发性,可以使用多线程或多进程来处理多个连接或数据传输任务。
4. 流量控制和拥塞控制:在网络通信中,需要考虑流量控制和拥塞控制的问题,以避免网络拥塞和数据丢失。
5. 安全性:在进行网络编程时,需要考虑安全性问题,如防止恶意攻击、保护数据隐私等。
利用Java套接字实现应用程序间的数据通信
当客 户程序 需要与服务器程序通讯 的时候 , 】 客广 程序在客
号整数, 围是 0 6 5 5 以区别 主机 上的每一个程序 ( 口号 范 -53 , 端
就像 房屋 中的房间号 ) 。每一个套接 字都组 合进 了 I 地 址、 P 端 口、 口号 , 样形成的整体就可 以区别每一个套接字。 端 这
ห้องสมุดไป่ตู้
点, 一个程序将 一段信 息写入 S c e o k t中 , S c e 将 这段 信 该 okt 息发送到另外一个 S c e ,使这段信息能传送 到其他程序 o k t中 中。如下 图所示 。
状态 , 这种 监听依然是通 过套接字和 端 口来进 行 的; 如果 服务 器程序处于监听状态 , 那么服务器端 网络管 理软件 就向客户机 网络管理软件发 出一个积极 的响应信 号 ,接收到响应信 号后,
入 S c e ,o k t的内容被 H s o k t中 S c e o tA的网络管理 软件 访 问,
一
的I P地址 ( 一个 3 的无 符号整数 ) 这个 I 2位 , P地址就唯一
地 标 识 了 这 台主 机 。
假设第二个程序被加入 图示的网络的 H s o t B中,那么 由 H s o tA传来 的信息如何 能被正确的传给 程序 B而不是传 给新 加入 的程序呢?这 是因为每 一个基于 T P I C / P网络 通讯的程序
角色, 客户机程序 ( 需要访 问某些服务 的网络应用程序 ) 创建 一
个扮 演服务器程序 的主机的 I 地址和服务器程序 ( P 为客户端应
用程序提供服务的网络应用程序 ) 的端 口号的流套接字对象 。
IPSec与网络编程:实现安全通信的代码示例(三)
IPSec与网络编程:实现安全通信的代码示例近年来,随着互联网的飞速发展,网络安全问题日益凸显,私密数据的泄露和黑客攻击屡见不鲜。
为了保护数据的安全性和隐私,网络编程领域引入了IPSec协议。
本文将探讨如何使用IPSec实现安全通信,并提供一些示例代码。
1. 了解IPSecIPSec(Internet Protocol Security)是一种网络层安全协议,用于在网络通信中保护数据的完整性、机密性和身份认证。
它通过加密和认证机制,确保数据在传输过程中不会被窃取、篡改或冒充。
2. 实现IPSec安全通信要实现IPSec安全通信,首先需要在系统中配置IPSec隧道。
在Linux系统中,可以使用Strongswan这样的开源软件包来进行配置。
以下是一些示例配置代码:```conn myipseckeyexchange=ikev2left=%defaultrouteleftsubnet=/24leftid=@myipsecserverright=%anyrightsourceip=/24rightid=@myclientauto=addike=aes256-sha256-modp1024esp=aes256-sha256fragmentation=yes```上述配置文件中,定义了一个名为myipsec的IPSec隧道。
其中,left代表服务器端,right代表客户端。
leftsubnet和rightsourceip指定了服务器端和客户端的IP地址范围。
ike和esp分别指定了IKE和ESP的加密算法和哈希算法。
通过加载这个配置文件,系统即可建立IPSec隧道。
3. 编写安全通信的代码示例一旦IPSec隧道建立成功,接下来就可以开始编写网络编程的代码,进行安全通信。
以下是使用Python编写的一个简单示例:```pythonimport socketimport sysimport os# 创建套接字def create_socket():try:s = (_INET, _STREAM)except as err:print('Failed to create socket. Error code: ' + str(err[0]) + ', Error message: ' + err[1])()print('Socket created successfully.')return s# 加密数据def encrypt_data(data):# TODO: 使用IPSec提供的加密算法对数据进行加密return data# 解密数据def decrypt_data(data):# TODO: 使用IPSec提供的解密算法对数据进行解密return data# 发送数据def send_data(s, data):encrypted_data = encrypt_data(data)try:(encrypted_data)except as err:print('Failed to send data. Error code: ' +str(err[0]) + ', Error message: ' + err[1])()print('Data sent successfully.')# 接收数据def receive_data(s):try:data = (1024)except as err:print('Failed to receive data. Error code: ' + str(err[0]) + ', Error message: ' + err[1])()decrypted_data = decrypt_data(data)print('Received data: ' + decrypted_data)# 主函数def main():# 建立套接字s = create_socket()# 连接服务器server_address = ('localhost', 8888)try:(server_address)except as err:print('Failed to connect to server. Error code: ' + str(err[0]) + ', Error message: ' + err[1])()print('Connected to server successfully.')# 发送和接收数据send_data(s, 'Hello, server!')receive_data(s)# 关闭套接字()if __name__ == '__main__':main()```以上代码中,我们首先创建了一个套接字,并定义了加密和解密数据的函数。
c语言send函数用法
c语言send函数用法C语言中,send函数是用于向套接字发送数据的函数。
在网络编程中,当我们需要将数据发送给另一个主机时,就可以使用send函数来实现。
send函数的具体用法和功能非常重要,因此在本文中,我们将详细介绍send函数的使用方法,并以一步一步的方式进行回答。
一、send函数基本概念在开始讲解send函数的用法之前,我们先来了解一下send函数的基本概念。
send函数是一个系统调用函数,用于向指定的套接字发送数据。
在C语言中,send函数的声明如下:cint send(int sockfd, const void *buf, size_t len, int flags);其中,各个参数的含义如下:- sockfd:套接字描述符,即需要发送数据的套接字。
- buf:指向要发送数据的缓冲区。
- len:需要发送数据的字节数。
- flags:标志参数,用于指定发送数据的一些选项,一般可以设置为0。
二、send函数的返回值send函数的返回值也非常重要,可以帮助我们判断数据是否成功发送。
send函数的返回值含义如下:- 若返回值大于等于0,则表示成功发送的数据字节数。
- 若返回值为-1,则表示发送出错。
在实际使用send函数时,我们通常会对其返回值进行判断,以确保数据发送的准确性。
三、send函数的使用步骤接下来,我们将一步一步来回答如何使用send函数来发送数据。
步骤1:创建套接字在使用send函数发送数据之前,首先需要创建一个套接字。
套接字是网络编程中的一种通信机制,用于在主机之间进行数据传输。
我们可以使用socket函数来创建一个套接字,并获取其描述符。
套接字的创建代码可以如下所示:cint sockfd = socket(domain, type, protocol);其中,domain参数指定套接字的协议域,例如AF_INET表示IPv4协议,AF_INET6表示IPv6协议;type参数指定套接字的类型,例如SOCK_STREAM表示字节流套接字,SOCK_DGRAM表示数据报套接字;protocol参数指定传输协议的类型,例如IPPROTO_TCP表示TCP 协议。
java测试试卷(七)
JAVA语言基础内部测试题一.单项选择题(请选择最符合题目要求的答案)(每题2分)1.当线程因异常而退出run()后,其所处状态为()A.阻塞状态 B。
运行状态 C、就绪状态D、结束状态2.wait()方法首先是哪个类的方法?()A. ObjectB. Thread.C. RunnableD. File3.如果在关闭socket时发生一个I/O错误,会抛出()。
A.IOExceptionB.UnknownHostExceptionC.SocketExceptionD.MalformedURLExceptin4.用read()方法读取文件内容时,判断文件结束的标记为()A. 0B. 1 C -1 D. 无标记5.以下哪个方法只对使用了缓冲的流类起作用?()A. read()B. write() C skip() D. flush()6.Java提供的那个类来进行有关Internet地址的操作.( )A. SocketB.ServerSocketC. DatagramSocket D InetAddress7.InetAddress类中哪个方法可实现正向名称解析?()A. isReachable()B. getHostAddress()C. getHosstName()D.getByName()8.为了获取远程主机的文件内容,当创建URL对象后,需要使用哪个方法获取信息()A.getPort()B.getHostC.openStream()D.openConnection()9.java程序中,使用TCP套接字编写服务端程序的套接字类是()A. SocketB. ServerSocketC. DatagramSocketD.DatagramPacket10.ServerSocket的监听方法accept()的返回值类型是()A. voidB. ObjectC. SocketD. DatagramSocket11.ServerSocket的getInetAddress()的返回值类型是()A. Socket B ServerSocket C.InetAddress D,.URL12.当使用客户端套接字Socket创建对象时,需要指定()A.服务器主机名称和端口 B、服务器端口和文件C、服务器名称和文件D.服务器地址和文件13.使用流式套接字编程时,为了向对方发送数据,则需要使用哪个方法()A.getInetAddress() B. getLocalPort()C.getOutputStream()D.getInputStream()14.使用UDP套接字通信时,常用哪个类把要发送的信息打包?()A. StringB. DatagramSocketC. MulticastSocketD.DatagramPacket15.使用UDP套接字通信时,哪个方法用于接收数据()A. read()B. receive()C. accept()D. Listen()16.若要取得数据包的中源地址,可使用下列哪个语句()?A. getAddress() B. getPort() C. getName() D.getData()17.要使用java程序访问数据库,则必须首先与数据库建立连接,在建立连接前,应加载数据库驱动程序,该语句为()A Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”)B. DriverManage.getConnection(“”,””,””)C.Result rs= DriverManage.getConnection(“”,””,””).createStatement()D. Statement st= DriverManage.getConnection(“”,””,””).createStaement()18.要使用java程序访问数据库,则必须首先与数据库建立连接,该语句为()A Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”)B. DriverManage.getConnection(“”,””,””)C.Result rs= DriverManage.getConnection(“”,””,””).createStatement()D. Statement st= DriverManage.getConnection(“”,””,””).createStaement()19.java程序与数据库连接后,需要查看某个表中的数据,使用下列哪个语句?()A. executeQuery()B.executeUpdate() C executeEdit() D.executeSelect()20.java程序与数据库连接后,需要更新某个表中的数据,使用下列哪个语句?()A. executeQuery()B.executeUpdate() C executeEdit() D.executeSelect()二.多项选择题(所有答案都选对,则该题得分,所选答案错误或不能选出所有答案,则该题不得分)(每题2分)1.用Statement对象执行一条新增数据到数据表的语句,可以用以下那些函数完成()A.executeQuery()B.executeUpdate()C.execute()D.close()2.以下那些类创建的对象可以用来执行SQL语句,完成对数据库的新增,修改,删除和查询数据等操作( )A.ConnectionB.ResultSetC.StatementD.PreparedStatement3.以下关于TCP(Transfer Control Protocol) 传输控制协议说法正确的是()A.基于连接的高可靠性传输协议 B. 可以保证数据准确的按顺序到达目的地C. 以流的方式传输数据D. 数据包的大小限制在64K以下4. 以下关于UDP(User Datagram Protocol)用户数据报协议说法正确的是()A. 基于连接的高可靠性传输协议B. 基于无连接的协议C.不会在发送数据之前建立连接,不管传输正确与否,也不保证数据包的正确次序D. 可以广播的方式发送数据,数据包的大小限制在64K以下5. 下列说法错误的有()A、Java面向对象语言容许单独的过程与函数存在B、Java面向对象语言容许单独的方法存在C、Java语言中的方法属于类中的成员(member)D、Java语言中的方法必定隶属于某一类(对象),调用方法与过程或函数相同6. createStatement(int type ,int concurrency)的参数说明:type 参数设置ResultSet 对象中的指针是否能够上下自由移动;可选值为()A. TYPE_FORWARD_ONLY: 只能使用next方法向下移动指针B. TYPE_SCROLL_SENSITIVE: 能够上下移动,且能得到临时修改后的数据库值C. TYPE_SCROLL_INSENSITIVE:能可上下移动,只能得到当前查询的值D.CONCUR_READ_ONLY: ResultSet对象对结果集只能读7.以下关于connection对象提供的方法描述正确的是()A.setAutoCommit(boolean autoCommit) 设置操作是否自动提交到数据库B. commit( ) 提交对数据库的更改,使更改生效C. rollback( ) 回滚当前执行的操作D. isclose( ) 判断连接是否关闭8.PreparedStatement对象可以执行已经预编译过的sql语句,其sql执行效率比Statement对象的执行效率更高,以下描述正确的是()A.可以在执行过程中向该对象中的sql语句传递参数B.对于sql中每个输入参数都保留一个问号“?”作为占位符C.每个?占位符的值必须在该语句执行前被赋值D. 每个?占位符的值可以在该语句执行后被赋值9. 下列说法错误的有()A.在类方法中可用this来调用本类的类方法B.在类方法中调用本类的类方法时可直接调用C.在类方法中只能调用本类中的类方法D.在类方法中绝对不能调用实例方法10.关于逻辑操作(&,|,^)与条件操作(&&,||)的说法正确的是()A.条件操作只能操作布尔型的B.逻辑操作不仅可以操作布尔型,而且可以操作数值型C.逻辑操作不会产生短路D.条件操作不会产生短路三.填空题(每空一分,10分)1.网络连接中合法端口的范围是 0 到 65535 ,其中 0~1023 范围的端口为给系统的网络服务与应用预留的2.取得当前线程的语句是: Thread.currrentThread() ;3.可以调用 Thread 类的方法 getPriority()和 setPriority() 来存取线程的优先级,线程的优先级界于1(MIN_PRIORITY)和10(MAX_PRIORITY)之间,缺省是 NORM_PRIORITY4. InetAddress 是用于封装IP地址和DNS的一个类。
c tcp client 代码 -回复
c tcp client 代码-回复TCP(Transmission Control Protocol)是一种可靠的传输协议,主要用于互联网中的数据通信。
在这篇文章中,我们将从头开始介绍TCP客户端的实现。
首先,让我们了解一下TCP客户端的定义和作用。
TCP客户端是指通过TCP协议与服务器进行通信的网络应用程序。
它可以发送请求到服务器,并接收服务器的响应。
使用TCP客户端,我们可以建立稳定的连接以进行数据传输。
接下来,我们将开始编写TCP客户端的代码。
假设我们使用的是Python 编程语言。
首先,我们需要导入所需的模块。
pythonimport socket然后,我们可以创建一个TCP套接字对象,该套接字将用于与服务器建立连接。
pythonclient_socket = socket.socket(socket.AF_INET,socket.SOCK_STREAM)在上述代码中,`AF_INET`表示使用IPv4地址族,`SOCK_STREAM`表示使用流式套接字。
现在,我们需要指定服务器的主机名和端口号。
pythonserver_host = 'example'server_port = 12345替换`example`和`12345`为实际的服务器主机名和端口号。
接下来,我们将尝试与服务器建立连接。
pythonclient_socket.connect((server_host, server_port))如果成功建立连接,我们可以发送数据到服务器。
pythonmessage = 'Hello, server!'client_socket.send(message.encode())在上述代码中,我们发送了一个字符串消息给服务器,并通过`encode()`方法将其转换为字节形式。
然后,我们等待服务器的回复。
pythonresponse = client_socket.recv(1024).decode()在上述代码中,`recv(1024)`表示最多接收1024字节的数据,`decode()`方法将接收到的字节转换为字符串形式。
cyclonetcp socket 例子
CycloneTCP是一个轻量级的TCP/IP协议栈,它适用于嵌入式系统和RTOS。
它是开源的,具有可移植性和可扩展性,适用于各种不同的硬件评台和操作系统。
CycloneTCP提供了一套完整的TCP/IP协议栈,包括TCP、UDP、IP、ICMP和DHCP等常用的网络协议。
本文将介绍如何在CycloneTCP中使用socket编程的例子。
1. 创建socket在CycloneTCP中,可以使用`socket()`函数来创建一个新的套接字。
套接字是一个端点,用于建立网络通信。
在创建套接字时,需要指定协议族、套接字类型和协议类型。
可以使用以下代码创建一个TCP套接字:```cint sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);```上面的代码创建了一个TCP套接字,并返回了一个整数值作为套接字的文件描述符。
通过这个文件描述符,可以对套接字进行读写操作。
2. 绑定位置区域和端口在使用套接字进行通信之前,需要将套接字和本地位置区域以及端口进行绑定。
可以使用`bind()`函数来绑定套接字。
可以使用以下代码将套接字绑定到本地位置区域和端口:```cstruct sockaddr_in addr;memset(addr, 0, sizeof(addr));addr.sin_family = AF_INET;addr.sin_addr.s_addr = htonl(INADDR_ANY);addr.sin_port = htons(8080);bind(sock, (struct sockaddr *)addr, sizeof(addr));```上面的代码将套接字绑定到本地任意位置区域的8080端口上。
3. 监听连接如果需要在套接字上接受连接,可以使用`listen()`函数来监听连接。
可以使用以下代码监听连接:```clisten(sock, 5);```上面的代码将套接字设置为监听状态,最多可以同时处理5个连接请求。
socket套接字的创建、发送、接收、关闭的方法名称及代码
socket套接字的创建、发送、接收、关闭的⽅法名称及代码函数 socket.socket创建⼀个socket,该函数带有两个参数:Address Family:可以选择 AF_INET(⽤于 Internet 进程间通信)或者 AF_UNIX(⽤于同⼀台机器进程间通信),实际⼯作中常⽤AF_INETType:套接字类型,可以是 SOCK_STREAM(流式套接字,主要⽤于 TCP 协议)或者 SOCK_DGRAM(数据报套接字,主要⽤于 UDP 协议).创建⼀个udp socket(udp套接字)import socket# 创建udp的套接字s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# ...这⾥是使⽤套接字的功能(省略)...# 不⽤的时候,关闭套接字s.close().创建⼀个tcp socket(tcp套接字)import socket# 创建tcp的套接字s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)# ...这⾥是使⽤套接字的功能(省略)...# 不⽤的时候,关闭套接字s.close()1.发送sendto()1.socket基本使⽤import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)udp_socket.sendto(b"hello world", ("192.168.57.65", 8080))# 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.发送任意数据import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# 从键盘获取数据send_data = input("请输⼊要发送的数据:")# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)# udp_socket.sendto(b"hahahah------1----", ("192.168.57.65", 8080))udp_socket.sendto(send_data.encode("utf-8"), ("192.168.57.65", 8080))# 关闭套接字udp_socket.close()if __name__ == "__main__":main()3.循环发送数据import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) while True:# 从键盘获取数据send_data = input("请输⼊要发送的数据:")# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)# udp_socket.sendto(b"hahahah------1----", ("192.168.57.65", 8080))udp_socket.sendto(send_data.encode("utf-8"), ("192.168.57.65", 8080)) # 关闭套接字udp_socket.close()if __name__ == "__main__":main()4.带有退出循环功能的发送import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) while True:# 从键盘获取数据send_data = input("请输⼊要发送的数据:")# 如果输⼊的数据是exit,那么就退出程序if send_data == "exit":break# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)# udp_socket.sendto(b"hahahah------1----", ("192.168.33.53", 8080))udp_socket.sendto(send_data.encode("utf-8"), ("192.168.33.53", 8080)) # 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.接收bind():绑定地址信息recvfrom:接收数据2.1 绑定端⼝⽤来接收数据import socketdef main():# 1. 创建套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 2. 绑定⼀个本地信息localaddr = ("", 7788)udp_socket.bind(localaddr)# 3. 接收数据recv_data = udp_socket.recvfrom(1024)# 4. 打印接收到的数据print(recv_data)# 5. 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.2 解析接收到的数据import socketdef main():# 1. 创建套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# 2. 绑定⼀个本地信息localaddr = ("", 7788)udp_socket.bind(localaddr) # 必须绑定⾃⼰电脑的ip以及port,其他的不⾏ # 3. 接收数据recv_data = udp_socket.recvfrom(1024)# recv_data这个变量中存储的是⼀个元组(接收到的数据,(发送⽅的ip, port))recv_msg = recv_data[0] # 存储接收的数据send_addr = recv_data[1] # 存储发送⽅的地址信息# 4. 打印接收到的数据# print(recv_data)# print("%s:%s" % (str(send_addr), recv_msg.decode("utf-8")))print("%s:%s" % (str(send_addr), recv_msg.decode("gbk")))# 5. 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.3 循环接收并显⽰数据import socketdef main():# 1. 创建套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# 2. 绑定⼀个本地信息localaddr = ("", 7788)udp_socket.bind(localaddr) # 必须绑定⾃⼰电脑的ip以及port,其他的不⾏ # 3. 接收数据while True:recv_data = udp_socket.recvfrom(1024)# recv_data这个变量中存储的是⼀个元组(接收到的数据,(发送⽅的ip, port))recv_msg = recv_data[0] # 存储接收的数据send_addr = recv_data[1] # 存储发送⽅的地址信息# 4. 打印接收到的数据# print(recv_data)# print("%s:%s" % (str(send_addr), recv_msg.decode("utf-8")))print("%s:%s" % (str(send_addr), recv_msg.decode("gbk")))# 5. 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.4 绑定端⼝发送数据import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)# 绑定本地信息udp_socket.bind(("", 7890))while True:# 从键盘获取数据send_data = input("请输⼊要发送的数据:")# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)# udp_socket.sendto(b"hahahah------1----", ("192.168.33.53", 8080))udp_socket.sendto(send_data.encode("utf-8"), ("192.168.33.53", 8080))# 关闭套接字udp_socket.close()if __name__ == "__main__":main()3.总结创建socket套接字# 导包import socket# 创建udp套接字udp_socket = socket.socket(socket.AF_INET, sock.SOCK_DGRAM)发送数据# 注意:对⽅地址为ip+port,是⼀个元组类型数据udp_socket.sendto(内容.encode("utf-8"), 对⽅地址)接收数据# 1.⾸先要绑定 bind(地址) # 地址为元组类型(ip, port)# ⼀次接收多少字节# 注意:recv_data变量接收到的是⼀个元组数据类型# (内容, 发送⽅地址) 发送⽅地址信息也是⼀个元组recv_data = udp.socket.recvfrom(1024)# 拿到数据需要解析# 如果是linux系统,需要解析编码recv.data[0].decode("utf-8")# 如果是windows系统,需要解析编码recv.data[0].decode("gbk")1.使⽤udp完成⼀个能够收发消息的套接字import socketdef main():# 创建⼀个udp套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 获取对⽅的ip/portdest_ip = input("请输⼊对⽅的ip:")dest_port = int(input("请输⼊对⽅的port:"))# 从键盘获取数据send_data = input("请输⼊要发送的数据:")# 可以使⽤套接字收发数据# udp_socket.sendto("hahahah", 对⽅的ip以及port)# udp_socket.sendto(b"hahahah------1----", ("192.168.57.65", 8080))# udp_socket.sendto(send_data.encode("utf-8"), ("192.168.57.65", 8080)) udp_socket.sendto(send_data.encode("utf-8"), (dest_ip, dest_port))# 接收回送过来的数据recv_data = udp_socket.recvfrom(1024)# 套接字是⼀个可以同时收发数据print(recv_data)# 关闭套接字udp_socket.close()if __name__ == "__main__":main()2.udp聊天import socketdef send_msg(udp_socket):"""发送消息"""# 获取要发送的内容dest_ip = input("请输⼊对⽅的ip:")dest_port = int(input("请输⼊对⽅的port:"))send_data = input("请输⼊要发送的消息:")udp_socket.sendto(send_data.encode("utf-8"), (dest_ip, dest_port))def recv_msg(udp_socket):"""接收数据"""recv_data = udp_socket.recvfrom(1024)print("%s:%s" % (str(recv_data[1]), recv_data[0].decode("gbk")))def main():# 创建套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定信息udp_socket.bind(("", 7788))# 循环循环来进⾏处理事情while True:# 发送send_msg(udp_socket)# 接收并显⽰recv_msg(udp_socket)if __name__ == "__main__":main()3.udp聊天升级import socketdef send_msg(udp_socket):"""发送消息"""# 获取要发送的内容dest_ip = input("请输⼊对⽅的ip:")dest_port = int(input("请输⼊对⽅的port:"))send_data = input("请输⼊要发送的消息:")udp_socket.sendto(send_data.encode("utf-8"), (dest_ip, dest_port)) def recv_msg(udp_socket):"""接收数据"""recv_data = udp_socket.recvfrom(1024)print("%s:%s" % (str(recv_data[1]), recv_data[0].decode("utf-8")))def main():# 创建套接字udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定信息udp_socket.bind(("", 7788))# 循环循环来进⾏处理事情while True:print("-----xxx聊天器-----")print("1:发送消息")print("2:接收消息")print("0:退出系统")op = input("请输⼊功能:")if op == "1":# 发送send_msg(udp_socket)elif op == "2":# 接收并显⽰recv_msg(udp_socket)elif op == "0":breakelse:print("输⼊有误请重新输⼊...")if __name__ == "__main__":main()。
套接字编程实验报告
Programing 实验物联2班201208080228 赵智慧一、实验题目:利用套接字编程,编写出TCP和UDP的客户机、服务器程序进行交互二、实验代码:1.TCP服务器:package TCP;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import .ServerSocket;import .Socket;public class TCPServer {public static void main(String[] args) throws IOException{ServerSocket server=new ServerSocket(7999);System.out.println("server ok");Socket socket=server.accept();BufferedReader bf=new BufferedReader(new InputStreamReader(socket.getInputStream()));String str=bf.readLine();while(str!=null){System.out.println(str);str=bf.readLine();}}}2.TCP客户机:package TCP;import java.io.BufferedReader;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.PrintWriter;import .Socket;import .UnknownHostException;public class TCPClient {public static void main(String[] args) throws UnknownHostException, IOException{String sentence;InputStreamReader isr = new InputStreamReader(System.in);BufferedReader inFromUser = new BufferedReader(isr);Socket clientSocket = new Socket("127.0.0.1",7999);sentence = inFromUser.readLine();OutputStream os = clientSocket.getOutputStream();PrintWriter oos=new PrintWriter(os);os.write(sentence.getBytes());clientSocket.close();}}3.UDP服务器:package UDP;import .DatagramPacket;import .DatagramSocket;import .InetAddress;import .SocketException;public class UDPServer {public static void main(String[] args) throws Exception{DatagramSocket serverSocket = new DatagramSocket(9876); //所有发送和接收的数据都将通过该套接字//因为UDP无连接,所以无需创建一个新的套接字监听新的请求byte[] receive1 = new byte[1024];byte[] receive2 = new byte[1024];byte[] send1 = new byte[1024];byte[] send2 = new byte[1024];byte[] send3 = new byte[1024];while(true){DatagramPacket receivePacket = new DatagramPacket(receive1, receive1.length);serverSocket.receive(receivePacket);String str = new String(receivePacket.getData()); //从分组中提取出数据,并存入str中InetAddress ip = receivePacket.getAddress(); //提取IP地址int port = receivePacket.getPort(); //提取客户机端口号String ask = "请选择:1.将其转化为大写 2.将a字符替换为c字符";send1 = ask.getBytes();DatagramPacket sendPacket1 = new DatagramPacket(send1, send1.length, ip,port);serverSocket.send(sendPacket1);DatagramPacket receivePacket2 = new DatagramPacket(receive2, receive2.length);serverSocket.receive(receivePacket2);String str2 = new String(receivePacket2.getData());if(str2.toCharArray()[0]=='1'){String capitalizedSentence = str.toUpperCase();send3 = capitalizedSentence.getBytes();DatagramPacket sendPacket3 = new DatagramPacket(send3, send3.length, ip,port);serverSocket.send(sendPacket3);}else{String change = str.replace('a', 'c');send2 = change.getBytes();DatagramPacket sendPacket2 = newDatagramPacket(send2, send2.length, ip,port);serverSocket.send(sendPacket2);}}}}4.UDP客户机:package UDP;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import .DatagramPacket;import .DatagramSocket;import .InetAddress;import .SocketException;import .UnknownHostException;public class UDPClient {public static void main(String[] args) throws IOException{InputStreamReader isr = new InputStreamReader(System.in);BufferedReader inFromUser = new BufferedReader(isr);DatagramSocket clientSocket = new DatagramSocket(); //客户机套接字InetAddress IPAddress = InetAddress.getByName("127.0.0.1");byte[] sendData1 = new byte[1024];byte[] sendData2 = new byte[1024];byte[] receiveData1 = new byte[1024];byte[] receiveData2 = new byte[1024];String sentence = inFromUser.readLine();sendData1 = sentence.getBytes();DatagramPacket sendPacket = new DatagramPacket(sendData1, sendData1.length,IPAddress,9876);clientSocket.send(sendPacket);DatagramPacket receivePacket1 = new DatagramPacket(receiveData1, receiveData1.length);clientSocket.receive(receivePacket1);String modifiedData1 = new String(receivePacket1.getData());System.out.println("Server:"+modifiedData1);String sentence2 = inFromUser.readLine();sendData2 = sentence2.getBytes();DatagramPacket sendPacket2 = new DatagramPacket(sendData2, sendData2.length,IPAddress,9876);clientSocket.send(sendPacket2);DatagramPacket receivePacket2 = new DatagramPacket(receiveData2, receiveData2.length);clientSocket.receive(receivePacket2);String modifiedData2 = new String(receivePacket2.getData());System.out.println("Server:"+modifiedData2);clientSocket.close();}}三、实验分析:TCP提供可靠的数据传输,而UDP提供不可靠的运输服务,在套接字编程方面,UDP 客户机使用的是DatagramSocket,而TCP客户机使用的是Socket。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
使用流式字套接字来发送和接收数据代码
2009-12-30 15:11
服务器端:
#pragma comment(lib,"ws2_32.lib")
#include<winsock.h>
#include<iostream>
using namespace std;
int init();
int main()
{
init();
SOCKET s,s2;
s=socket(AF_INET,SOCK_STREAM,0);
if (s==0)
{
cout<<"socket error:"<<WSAGetLastError()<<endl;
return -1;
}
sockaddr_in addr,addrfrom;
addr.sin_family=AF_INET;
addr.sin_port=htons(2345);
addr.sin_addr.S_un.S_addr=htons(0);
if (bind(s,(LPSOCKADDR) &addr,sizeof(addr))==SOCKET_ERROR)
{
cout<<"bind error:"<<WSAGetLastError()<<endl;
return -1;
}
if(listen(s,2)==SOCKET_ERROR)
{
cout<<"listen error:"<<WSAGetLastError()<<endl;
return -1;
}
cout<<"waiting for connecting..."<<endl;
int len=sizeof(addrfrom);
if ((s2=accept(s,(LPSOCKADDR) &addrfrom,&len))==INVALID_SOCKET)
{
cout<<"accept error:"<<WSAGetLastError()<<endl;
return -1;
}
cout<<"already connected"<<endl<<"waiting for receiving data..."<<endl; char data[256];
if(recv(s2,data,sizeof(data),0)==SOCKET_ERROR) {
cout<<"recv error"<<WSAGetLastError()<<endl;
return -1;
}
cout<<"received data is:"<<data<<endl;
}
int init()//成功则返回0
{
WSADATA wsadata;
int nRc=WSAStartup(0x0101,&wsadata);
if (nRc) return -1;
if (wsadata.wVersion!=0x0101)
{
WSACleanup();
return -1;
}
return 0;
}
客户端:
#pragma comment(lib,"ws2_32.lib")
#define IP "127.0.0.1"//这里设置服务器ip地址。
#include<winsock.h>
#include<iostream>
#include<conio.h>
using namespace std;
int init();
int main()
{
init();
SOCKET s;
s=socket(AF_INET,SOCK_STREAM,0);
if (s==0)
{
cout<<"socket error:"<<WSAGetLastError()<<endl; return -1;
}
sockaddr_in addr,addrto;
addrto.sin_addr.S_un.S_addr=inet_addr(IP);
addrto.sin_family=AF_INET;
addrto.sin_port=htons(2345);
addr.sin_family=AF_INET;
addr.sin_port=htons(2346);
addr.sin_addr.S_un.S_addr=htons(0);
if (bind(s,(LPSOCKADDR) &addr,sizeof(addr))==SOCKET_ERROR)
{
cout<<"bind error:"<<WSAGetLastError()<<endl;
return -1;
}
cout<<"press any key to connecting"<<endl;
_getch();
if (connect(s,(LPSOCKADDR)&addrto,sizeof(addrto))==SOCKET_ERROR) {
cout<<"connect error:"<<WSAGetLastError()<<endl;
return -1;
}
char data[256];
cout<<"input message you want to send:"<<endl;
gets(data);
if(send(s,data,sizeof(data),0)==SOCKET_ERROR)
{
cout<<"send error:"<<WSAGetLastError()<<endl;
return -1;
}
cout<<"message sended"<<endl;
}
int init()//成功则返回0
{
WSADATA wsadata;
int nRc=WSAStartup(0x0101,&wsadata);
if (nRc) return -1;
if (wsadata.wVersion!=0x0101)
{
WSACleanup();
return -1;
}
return 0;
}。