使用socket实现TCP和UDP传输

转载自：https://blog.csdn.net/timmiy/article/details/51946093

             https://blog.csdn.net/timmiy/article/details/52016946

socket由IP地址和端口号组成，可以通过TCP，UDP，IP协议实现不同虚拟机或不同计算机之间的通信，效率较高。

（一）运用TCP协议进行socket通信

TCP是面向连接的，它在进行通信之前，需要双方先进行沟通，然后才能进行通信。而且TCP是以数据流的方式进行数据传递，会自动的进行拆包和组包的过程。所以TCP的连接是比较可靠的，但是它的传输速度也因此相对较慢。接下来分别介绍服务端和客户端，看下如何在windows系统中用C++语言实现TCP通信。

在windows中，要想进行socket网络操作，必须包含一个名叫做WinSock2.h(或者WinSock.h)，如果包含的是WinSock2.h则必须在windows.h之前，否则会产生一些重定义的编译错误。包含完头文件之后，还要链接一个库文件ws2_32.lib，完成之后，我们就可以开始进行TCP服务端和客户端的编写了。（如果使用Visual Studio编译器运行，VS会自动生成.h文件，不需要自己手动包含和链接库文件。）

1.1  服务端

首先给出服务端的实现思路：

1.初始化socket环境 -> 2.创建服务器socket -> 3.初始化端口和ip地址调用bind进行绑定 -> 4.调用listen进行监听 -> 5.调用accept接收客户端的请求 -> 6.调用recv和send与客户端进行通信 -> 7.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现示例程序：

#include <stdio.h>    
#include <winsock2.h> // 必须包含windwos.h之前  
#include <Windows.h>  

#pragma comment(lib,"ws2_32.lib")   

#define  PORT 6000  
DWORD WINAPI clientProc(LPARAM lparam)  //通信接收和发送数据过程函数(recv、send)
{
	SOCKET sockClient = (SOCKET)lparam;
	char buf[1024];
	while (TRUE)
	{
		memset(buf, 0, sizeof(buf));
		
		// 接收客户端的一条数据   
		int ret = recv(sockClient, buf, sizeof(buf), 0);
		//检查是否接收失败  
		if (SOCKET_ERROR == ret)
		{
			printf("socket recv failed\n");
			closesocket(sockClient);
			return -1;
		}
		else
		{
			printf("%s\r\n", buf);
		}
		// 0 代表客户端主动断开连接  
		if (ret == 0)
		{
			printf("client close connection\n");
			closesocket(sockClient);
			return -1;
		}
		
		// 发送数据  
		char *p = "hello client";
		ret = send(sockClient, p, strlen(p), 0);
		//检查是否发送失败  
		if (SOCKET_ERROR == ret)
		{
			printf("socket send failed\n");
			closesocket(sockClient);
			return -1;
		}
	}
	closesocket(sockClient);
	return 0;
}
bool InitNetEnv()    //网络环境初始化函数
{
	// 进行网络环境的初始化操作  
	WSADATA wsa;
	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
	{
		printf("WSAStartup failed\n");
		return false;
	}
	return true;
}

int main(int argc, char * argv[])
{
	if (!InitNetEnv())  //Step1：初始化网络环境
	{
		return -1;
	}

	// Step2：初始化完成，创建一个TCP的socket
	                 //socket(协议域，指定socket类型，指定协议)
	SOCKET sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	//检查是否创建失败  
	if (sServer == INVALID_SOCKET)
	{
		printf("socket failed\n");
		return -1;
	}
	printf("Create socket OK\n");

	//Step3：进行绑定操作(bind)  
	SOCKADDR_IN addrServ;
	addrServ.sin_family = AF_INET; // 协议簇为IPV4的  
	addrServ.sin_port = htons(PORT); // 端口  因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序  
	addrServ.sin_addr.S_un.S_addr = INADDR_ANY; // ip地址，INADDR_ANY表示绑定电脑上所有网卡IP  
	//完成绑定操作 
	        //bind(socket描述字， 绑定给listenfd的协议地址，地址长度)
	int ret = bind(sServer, (sockaddr *)&addrServ, sizeof(sockaddr));
	//检查绑定是否成功  
	if (SOCKET_ERROR == ret)
	{
		printf("socket bind failed\n");
		WSACleanup(); // 释放网络环境  
		closesocket(sServer); // 关闭网络连接  
		return -1;
	}
	printf("socket bind OK\n");
	
	// Stpe4：绑定成功，进行监听(listen)
         //listen(socket描述字, socket可以排队的最大连接个数)
	ret = listen(sServer, 10);  
	//检查是否监听成功  
	if (SOCKET_ERROR == ret)
	{
		printf("socket listen failed\n");
		WSACleanup();
		closesocket(sServer);
		return -1;
	}
	printf("socket listen OK\n");
	
	// 监听成功  
	sockaddr_in addrClient; // 用于保存客户端的网络节点的信息  
	int addrClientLen = sizeof(sockaddr_in);
	while (TRUE)
	{
		//新建一个socket，用于客户端  
		SOCKET *sClient = new SOCKET;
		//Step5：等待客户端的连接(accept)  
		          //accept(服务器的描述字，指向客户端的协议地址， 协议地址的长度)
		*sClient = accept(sServer, (sockaddr*)&addrClient, &addrClientLen);
		if (INVALID_SOCKET == *sClient)
		{
			printf("socket accept failed\n");
			WSACleanup();
			closesocket(sServer);
			delete sClient;
			return -1;
		}
		//Step6：创建线程为客户端做数据收发  
		CreateThread(0, 0, (LPTHREAD_START_ROUTINE)clientProc, (LPVOID)*sClient, 0, 0);
	}

	closesocket(sServer);  //关闭网络环境和socket
	WSACleanup();
	return 0;
}

下面对代码中的实现函数进行说明。

1）首先，要进行网络操作，我们先要进行一下网络环境的初始化。WSAStartup函数就是用来初始化网络环境的。其声明如下：

int WSAStartup(    
  WORD wVersionRequested,       //版本号，一般使用2.2版本  
  LPWSADATA lpWSAData  <span style="white-space:pre">     </span>//WSAData地址  
);

函数的第二个参数，接收一个WSAData结构的指针，该结构里边包含了版本号，我们传递的版本号会对该结构里边的版本号进行初始化。

2）初始化完成之后，我们需要创建一个socket(套接字)，这个套接字相当于管道，用于客户端和服务端的连接。调用socket函数我们可以创建一个套接字，声明如下：

SOCKET socket(    
  int af,         //IP协议簇  
  int type,       //套接字类型，TCP应该用SOCK_STREAM  
  int protocol<span style="white-space:pre">  </span>  //协议  
);  

其实，socket也是一个内核对象，但是它没有内核对象所拥有的明显标志，安全属性。

3）创建好套接字后呢，我们需要告诉操作系统需要在哪个地址和端口上进行网络操作，相当于管道通信中绑定到标准输入输出口上。绑定的时候，需要有一个SOCKADDR_IN这个结构体，声明如下：

struct sockaddr_in{  
    short              sin_family;//协议簇  
    unsigned short     sin_port;//端口  
    struct   in_addr   sin_addr;//ip地址  
    char               sin_zero[8];//为了设置和SOCKADDR结构等长的补充字节  
}; 

还有一个SOCKADDR结构和上面这个的功能完全一样，但是SOCKADDR这个结构里边只有两个成员，一个是协议簇，一个是14个字节的char数组，为了让我们更好的编写代码，于是将char数组拆解成SOCKADDR_IN 中后三个成员。

初始化完端口，地址等信息后，需要调用bind函数，来完成绑定操作，声明如下：

int bind(    
  SOCKET s,                          //我们创建的那个socket  
  const struct sockaddr FAR *name,   //sockaddr结构指针  
  int namelen                        //sockaddr长度  
); 

4）绑定之后，我们还需要调用listen函数来进行监听操作，这个操作呢，就相当于门卫一样了，如果有人来，就告诉你一声，这就是监听。该函数声明如下：

int listen(    
  SOCKET s,      //我们创建的socket  
  int backlog   //最大连接的队列长度  
);  

第二个参数backlog呢，我们一般不要给的太大，这就好比你去交电费，还要进行排队等候，如果排队的人多了，这就会给你留下不好的体验，因此随便给个10，100的就行了。

5）监听完成之后，我们就可以进行接收客户端的连接了，我们需要调用accept这个函数来进行接客。声明如下：

SOCKET accept(    
  SOCKET s,   //我们监听的那个socket  
  struct sockaddr FAR *addr,    //我们需要传递一个sockaddr的地址，用于保存客户端的地址  
  int FAR *addrlen  //sockaddr的长度指针  
);  

6）接完客之后，我们就可以进行通信了，需要调用recv和send两个函数来进行收发数据，它们的声明如下：

int recv(    
  SOCKET s,         //客户端的socket  
  char FAR *buf,    //接收的缓冲区  
  int len,        //缓冲区的大小  
  int flags       //标志位，一般为0  
);  
  
int send(    
  SOCKET s,             //客户端的socket  
  const char FAR *buf,  //发送数据的缓冲区  
  int len,              //缓冲区的大小  
  int flags             //标志位，一般为0  
);  

7）当我们传输完数据后，应该调用WSACleanup和closesocket来进行关闭网络环境和套接字。声明如下：

int  WSACleanup (void);  
  
int closesocket(    
  SOCKET s  //要关闭的套接字  
); 

1.2 客户端

首先给出使用TCP协议在客户端的思路：

1.初始化socket环境 -> 2.创建客户端socket -> 3.调用connect连接指定的服务器 -> 4.调用recv和send与服务端进行通信 -> 5.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现程序：

#include <stdio.h>  
#include <winsock2.h>  
#include <Windows.h>  

#pragma comment(lib,"ws2_32.lib")  
#define  PORT 6000  

int main(int argc, char * argv[])
{
	//Step1：初始化网络环境  
	WSADATA wsa;
	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
	{
		printf("WSAStartup failed\n");
		return -1;
	}
	
	// Step2：初始化完成，创建一个TCP的socket  
	                //socket(协议域，指定socket类型，指定协议)
	SOCKET sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (sServer == INVALID_SOCKET)
	{
		printf("socket failed\n");
		return -1;
	}
	
	//Step3：指定连接的服务端信息(bind)
	SOCKADDR_IN addrServ;
	addrServ.sin_family = AF_INET;
	addrServ.sin_port = htons(PORT);
	//客户端只需要连接指定的服务器地址，127.0.0.1是本机的回环地址  
	addrServ.sin_addr.S_un.S_addr = inet_addr("10.170.54.98");

	// 服务器Bind 客户端是进行连接  
	         //connect(客户端的socket描述字, 服务器的socket地址, 服务器地址长度)
	int ret = connect(sServer, (SOCKADDR*)&addrServ, sizeof(SOCKADDR));//开始连接  
	if (SOCKET_ERROR == ret)
	{
		printf("socket connect failed\n");
		WSACleanup();
		closesocket(sServer);
		return -1;
	}
	
	//Step4：连接成功后，就可以进行通信了(send,recv)
	char szBuf[1024];
	memset(szBuf, 0, sizeof(szBuf));
	sprintf_s(szBuf, sizeof(szBuf), "Hello server");
	//当服务端是recv的时候，客户端就需要send，若两端同时进行收发则会卡在这里，因为recv和send都是阻塞的  
	ret = send(sServer, szBuf, strlen(szBuf), 0);
	if (SOCKET_ERROR == ret)
	{
		printf("socket send failed\n");
		closesocket(sServer);
		return -1;
	}

	ret = recv(sServer, szBuf, sizeof(szBuf), 0);
	if (SOCKET_ERROR == ret)
	{
		printf("socket recv failed\n");
		closesocket(sServer);
		return -1;
	}
	printf("%s\n", szBuf);
	
	closesocket(sServer); //Step5：关闭已连接socket描述字
	WSACleanup();
	system("pause");
	return 0;
}

下面对代码中的函数进行解释。

（1-2）客户端比较简单，前面的部分和服务端都基本相同（初始化、建立socket）

（3）在绑定操作上会有所差别。服务端绑定的IP地址是本机所有网卡的IP，而客户端只需要绑定一个即可，因为对客户端来说，我们只需连接指定的服务器。赋值完SOCKADDR_IN结构之后，服务端会调用bind函数，而客户端呢，需要调用connect函数，其声明如下：

int connect(    
  SOCKET s,                          //要进行连接的socket  
  const struct sockaddr FAR *name,   //SOCKADDR结构地址  
  int namelen                        //SOKADDR大小  
); 

（4）连接成功后，就可以和服务端进行通信了，调用recv和send来进行收发数据。需要注意的是，如果服务端程序先进行recv操作，则我们应该在客户端先进行send操作，若两个同时进行相同的操作的话，则会卡在当前的位置，因为recv和send都是阻塞型的函数。

（5）当通信完之后，就可以关闭连接了。文章开头讲过，当客户端和服务端刚开始连接的时候呢，两者会先进行沟通，这个沟通需要3个步骤来完成，我们称之为3次握手，同样的关闭连接的时候，需要进行4个步骤来完成，我们称之为4次握手。如果你是粗暴型的，直接拔网线呢，它也会完成其中的两次步骤，作为应用层开发，并不需要深究其中的原理，若感兴趣，可自行查找资料。

在两个Visual Studio中依次运行服务端及客户端程序，得到socket通信结果如下：

（二）运用UDP协议进行socket通信

相比TCP来说，UDP相对比较简单，刚开始的时候，和TCP一样都需要先进行网络环境的初始化，即调用WSAStartup函数。然后呢，我们也需要创建一个socket，这个socket和TCP的那个socket不同，上篇提过TCP创建一个socket调用socket函数时，第二个参数为SOCK_STREAM，而UDP则需要给定一个SOCK_DGRAM，然后在第三个参数上给一个IPPROTO_UDP，这样我们就创建好了一个UDP的socket。

接下来，也和TCP一样，指定SOCKADDR_IN的地址信息（端口，ip），指定完之后呢，若是客户端，则可以直接就进行通信了，若是服务端，则还需要增加一步bind操作，当我们调用bind函数，进行绑定后，服务端就可以和客户端进行通信了。而TCP的服务端还有两个步骤，一个是listen，一个是accept，UDP省略了这两个步骤。

2.1  服务端

首先给出使用UDP协议实现socket通信的服务端的实现思路：

1.初始化socket环境 -> 2.创建服务器socket -> 3.初始化端口和ip地址调用bind进行绑定 -> 4.调用recvfrom和sendto与客户端进行通信 -> 5.调用WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现代码：

#include <stdio.h>  
#include <winsock2.h>  
#include <Windows.h>  

#pragma comment(lib,"ws2_32.lib")  
#define  PORT 6000  

int main(int argc, char* argv[])
{
	//Step1：初始化网络环境  
	WSADATA wsa;
	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
	{
		printf("WSAStartup failed\n");
		return -1;
	}

	//Step2：建立一个UDP的socket  
	//建立socket参数：socket(协议域，指定socket类型，指定协议)（和TCP协议后两个参数不同，都为IP协议族）
	SOCKET sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sock == SOCKET_ERROR)
	{
		printf("create socket failed\n");
		return -1;
	}

	//Step3：绑定地址信息  
	sockaddr_in serverAddr;
	serverAddr.sin_family = AF_INET;		// 协议簇为IPV4的  
	serverAddr.sin_port = htons(PORT);		// 端口  因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序  
	serverAddr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);	// ip地址，INADDR_ANY表示绑定电脑上所有网卡IP 

	//bind(socket描述字， 绑定给listenfd的协议地址，地址长度)
	bind(sock, (sockaddr*)&serverAddr, sizeof(sockaddr));
        //Step5：与客户端进行通信
	char buf[512];
	while (TRUE)
	{
		memset(buf, 0, 512);
		// 网络节点的信息，用来保存客户端的网络信息  
		sockaddr_in clientAddr;
		memset(&clientAddr, 0, sizeof(sockaddr_in));

		int clientAddrLen = sizeof(sockaddr);
		//接收客户端发来的数据 
		//recvfrom参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
		//sockaddr地址用来保存从哪里发来，和发送到哪里的地址信息
		int ret = recvfrom(sock, buf, 512, 0, (sockaddr*)&clientAddr, &clientAddrLen);

		//inet_ntoa函数转化为ip，ntohs函数转化为端口号
		printf("Recv msg:%s from IP:[%s] Port:[%d]\n", buf, inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
		
		// 发一个数据包返回给客户  
		//sendto参数：socket名称，发送数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
		sendto(sock, "Hello World!", strlen("Hello World!"), 0, (sockaddr*)&clientAddr, clientAddrLen);
		printf("Send msg back to IP:[%s] Port:[%d]\n", inet_ntoa(clientAddr.sin_addr), ntohs(clientAddr.sin_port));
	}
	return 0;
}

前面提到TCP进行数据的收发是通过recv和send两个API来进行数据的收发的。而UDP也需要两个函数，叫做recvfrom和sendto，这两个和TCP那两个有点不同，其声明如下：

int recvfrom(    
  SOCKET s,                     //socket  
  char FAR* buf, <span style="white-space:pre">       </span>//接收数据的缓冲区               
  int len,                      //缓冲区的大小  
  int flags,                    //标志位，调用操作方式  
  struct sockaddr FAR *from,    //sockaddr结构地址  
  int FAR *fromlen              //sockaddr结构大小地址  
);  
int sendto(    
  SOCKET s,                    //socket        
  const char FAR *buf,         //发送数据的缓冲区     
  int len,                    //缓冲区大小        
  int flags,                       //标志位，调用操作方式  
  const struct sockaddr FAR *to,    //sockaddr结构地址  
  int tolen                        //sockaddr结构大小地址  
);  

注意，这两个函数里边有一个sockaddr结构地址，它是用来保存该数据发送者的信息的。上篇提过，TCP是面向连接的，它在通信之前需要进行三次握手来确定双方是否已经准备好了。因此，双方很清楚数据是从哪里来的。而UDP是面向数据包的，因此就好像寄快递一样，你必须在快递上写一张纸条，上面填好姓名，地址等信息，填好之后，接收者才知道该东西是由谁寄过来的。因此，上面两个函数提供了sockaddr结构的地址，用于保存从哪里发来的和发送到哪里的地址信息。

2.2 客户端

给出使用UDP协议实现socket通信的客户端的示例代码：

1.初始化socket环境 -> 2.创建客户端socket -> 3.调用recvfrom和sendto与服务端进行通信 -> 4.WSACleanup及closesocket关闭网络环境和socket

下面是具体的实现程序：

#include <stdio.h>  
#include <winsock2.h>  
#include <Windows.h>  

#pragma comment(lib,"ws2_32.lib")  
#define  PORT 6000  
int main(int argc, char* argv[])
{
	//Step1：初始化网络环境  
	WSADATA wsa;
	if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0)
	{
		printf("WSAStartup failed\n");
		return -1;
	}

	//Step2：建立一个UDP的socket 
	//建立socket参数：socket(协议域，指定socket类型，指定协议)（和TCP协议后两个参数不同，都为IP协议族）
	SOCKET sockClient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sockClient == INVALID_SOCKET)
	{
		printf("create socket failed\n");
		return -1;
	}

	// 申明一个网络地址信息的结构体，保存服务器的地址信息  
	sockaddr_in addr = { 0 };
	addr.sin_family = AF_INET;		// 协议簇为IPV4的  
	addr.sin_port = htons(PORT);	// 端口  因为本机是小端模式，网络是大端模式，调用htons把本机字节序转为网络字节序  
	addr.sin_addr.S_un.S_addr = inet_addr("10.170.54.98");	// 服务器的ip地址
        //Step3：与服务端进行通信
	char buf[] = "client test!";
	//发送数据  
	//sendto参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
	int dwSent = sendto(sockClient, buf, strlen(buf), 0, (SOCKADDR *)&addr, sizeof(SOCKADDR));
	if (dwSent == 0)
	{
		printf("send %s failed\n", buf);
		return -1;
	}
	printf("send msg:%s\n", buf);

	char recvBuf[512];
	memset(recvBuf, 0, 512);

	sockaddr_in addrSever = { 0 };
	int nServerAddrLen = sizeof(sockaddr_in);
	
	// 接收数据  
	//recvfrom参数：socket名称，接收数据的缓冲区，缓冲区大小，标志位（调用操作方式），sockaddr结构地址，sockaddr结构大小地址
	int dwRecv = recvfrom(sockClient, recvBuf, 512, 0, (SOCKADDR *)&addrSever, &nServerAddrLen);
	printf("Recv msg from server : %s\n", recvBuf);
	
	//Step4：关闭SOCKET连接  
	closesocket(sockClient);
	
	//清理网络环境  
	WSACleanup();
	system("pause");
	return 0;
}

在两个Visual Studio中依次运行服务端及客户端程序，得到socket通信结果如下：