socket编程之Windows 环境下的 基于TCP /UDP的 简单客户端（开发工具vs2013，语言c++）

一、Socket编程的流程图

 

 二、函数介绍

int socket(int domain, int type, int protocol)：（服务端 & 客户端）

函数应用：

         socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

参数说明：

      domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。

    type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等。

       protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议

        当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。

代码示例：

/*基于TCP*/
SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //服务端套接字

SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //客户端套接字


/*基于UDP*/
SOCKET serSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //服务端套接字

SOCKET sclient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //客户端套接字

 

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)：（服务端）

函数应用：

       正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

参数说明：

       sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。

       addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同。

       addrlen：对应的是地址的长度。　　

       通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

int listen(int sockfd, int backlog)：（服务端）

函数应用：

       如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

函数参数：

       listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)：（服务端）

函数应用：

       TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

函数参数：

       accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)：（客户端）

函数参数：

       connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

网络I/O操作

       万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

        read()/write()

        recv()/send()

        readv()/writev()

        recvmsg()/sendmsg()

        recvfrom()/sendto()   （UDP）

三、简单的程序框架

windows版本：

#include <stdio.h>
#include <winsock2.h>//socket头文件
#pragma comment (lib,"ws2_32.lib")//加载socket

int main()
{
    WSADATA wsaData;//生成句柄
    WSAStartup(MAKEWORD(2, 2), &wsaData);//初始化

    /*codding*/

    WSACleanup();//结束调用
    return 0;
}

   这就是windows的大体结构，ws2_32.lib用的是编译时加载，具体的加载方式和显示加载还是隐式加载大家可以自行查阅，这里不做深究，下面对函数进行分析：

   首先看一下WSADATA结构体：

typedef struct WSAData {
  WORD           wVersion;
  WORD           wHighVersion;
  char           szDescription[WSADESCRIPTION_LEN+1];
  char           szSystemStatus[WSASYS_STATUS_LEN+1];
  unsigned short iMaxSockets;
  unsigned short iMaxUdpDg;
  char FAR       *lpVendorInfo;
} WSADATA, *LPWSADATA;

   再看一下WSAStartup()函数，原型：

int WSAStartup(
  _In_  WORD      wVersionRequested,
  _Out_ LPWSADATA lpWSAData
);

    第二个参数lpWSADATA就是WSADATA结构体，第一个WORD参数，用的MAKEWORD()函数，原型如下：

WORD MAKEWORD(
   BYTE bLow,
   BYTE bHigh
);

  这个函数主要就是返回一个WORD参数。

接下来看看WSAClearup()函数：
int WSACleanup(void);
官方解释是：The WSACleanup function terminates use of the Winsock 2 DLL(Ws2_32.dll).意思就是不再使用Ws2_32.dll库了。

参考文档链接：https://www.cnblogs.com/elve960520/articles/8361614.html

四、简单实例

基于TCP的server端和client端：

#include <stdio.h>    
#include <winsock2.h> 
#include<WS2tcpip.h>
#pragma comment(lib,"ws2_32.lib") 

int main(int argc, char* argv[])
{
	//初始化WSA windows自带的socket
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(sockVersion, &wsaData) != 0)
	{
		return 0;
	}

	//创建服务端套接字
	SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (slisten == INVALID_SOCKET)
	{
		printf("socket error !");
		return 0;
	}

	//服务端需要绑定ip和端口
	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(8888);
	sin.sin_addr.S_un.S_addr = INADDR_ANY; //监听任意的地址
	if (bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR) //将服务端套接字与上面的ip和端口绑定 
	{
		printf("bind error !");
	}

	//开始监听
	if (listen(slisten, 5) == SOCKET_ERROR)  //用listen（） 监听前面绑定好的slisten套接字
	{
		printf("listen error !");
		return 0;
	}

	//循环接受数据
	SOCKET sClient;  //创建连接的套接字
	sockaddr_in remoteAddr;
	int nAddrlen = sizeof(remoteAddr); //用于接受客户端地址
	char revData[255]; //存储接受的数据
	while (1)
	{
		printf("等待连接...\n");
		sClient = accept(slisten, (SOCKADDR *)&remoteAddr, &nAddrlen); //和客户端 connect（）对应
		if (sClient == INVALID_SOCKET)
		{
			printf("accept error !");
			continue;
		}
		char sendBuf[20] = { '\0' };
		printf("接受到一个连接：%s \r\n", inet_ntop(AF_INET, (void*)&remoteAddr.sin_addr, sendBuf, 16));

		//数据接收
		int ret = recv(sClient, revData, 255, 0);
		if (ret > 0)
		{
			revData[ret] = 0x00;
			printf(revData);
		}

		//发送数据给客户端
		const char *sendData = "你好，TCP客户端！ \n";
		send(sClient, sendData, strlen(sendData), 0);
		closesocket(sClient);  //关闭已接通的套接字
	}


	closesocket(slisten); //关闭监听的套接字
	WSACleanup();//结束调用
	return 0;
}

//Server_demo_TCP

#include<WINSOCK2.H> //socket头文件 
#include<STDIO.H>  
#include<iostream>  
#include<cstring>  
#include <string>
#include<WS2tcpip.h>
using namespace std;
#pragma comment(lib, "ws2_32.lib")//加载socket 
int main()
{
	//初始化WSA windows自带的socket
	WORD sockVersion = MAKEWORD(2, 2);
	WSADATA data;
	if (WSAStartup(sockVersion, &data) != 0)
	{
		return 0;
	}

	//创建客户端套接字
	while (true)
	{
		SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //客户端套接字
		if (sclient == INVALID_SOCKET)
		{
			printf("invalid socket!");
			return 0;
		}

		sockaddr_in serAddr;
		serAddr.sin_family = AF_INET;
		serAddr.sin_port = htons(8888);
		inet_pton(AF_INET, "127.0.0.1", (void*)&serAddr.sin_addr.S_un.S_addr);
		if (connect(sclient, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR) //与指定IP地址和端口的服务端连接
		{
			printf("connect error !");
			closesocket(sclient);
			return 0;
		}

		printf("输入你想传输的数据： \n");
		string data;
		cin >> data;
		const char * sendData2;
		sendData2 = data.c_str(); //string转const char*
		send(sclient, sendData2, strlen(sendData2), 0);


		char recData[255];
		int ret = recv(sclient, recData, 255, 0);
		if (ret > 0){
			recData[ret] = 0x00;
			printf(recData);
		}
		closesocket(sclient);

	}
	
	WSACleanup();//结束调用
	return 0;

}

//Client_demo_TCP

基于UDP的server端和client端：

#include <stdio.h>   
#include <winsock2.h>   
#include<WS2tcpip.h>
#pragma comment(lib,"ws2_32.lib")    

int main(int argc, char* argv[])
{
	WSADATA wsaData;
	WORD sockVersion = MAKEWORD(2, 2);
	if (WSAStartup(sockVersion, &wsaData) != 0)
	{
		return 0;
	}

	SOCKET serSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //服务端套接字
	if (serSocket == INVALID_SOCKET)
	{
		printf("socket error !");
		return 0;
	}

	sockaddr_in serAddr;
	serAddr.sin_family = AF_INET;
	serAddr.sin_port = htons(8888);
	serAddr.sin_addr.S_un.S_addr = INADDR_ANY;
	if (bind(serSocket, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
	{
		printf("bind error !");
		closesocket(serSocket);
		return 0;
	}

	sockaddr_in remoteAddr;
	int nAddrLen = sizeof(remoteAddr);
	while (true)
	{
		char recvData[255];
		int ret = recvfrom(serSocket, recvData, 255, 0, (sockaddr*)&remoteAddr, &nAddrLen);
		if (ret > 0)
		{
			recvData[ret] = 0x00;
			char sendBuf[20] = { '\0' };
			printf("接受到一个连接：%s \r\n", inet_ntop(AF_INET, (void*)&remoteAddr.sin_addr, sendBuf, 16));
			printf(recvData);
		}

		const char * sendData = "一个来自服务端的UDP数据包\n";
		sendto(serSocket, sendData, strlen(sendData), 0, (sockaddr *)&remoteAddr, nAddrLen);

	}
	closesocket(serSocket);
	WSACleanup();
	return 0;
}

//Server_demo_UDP

#include <stdio.h>   
#include <winsock2.h>   
#include<WS2tcpip.h>
#pragma comment(lib,"ws2_32.lib")    

int main(int argc, char* argv[])
{
	WORD socketVersion = MAKEWORD(2, 2);
	WSADATA wsaData;
	if (WSAStartup(socketVersion, &wsaData) != 0)
	{
		return 0;
	}
	SOCKET sclient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); //客户端套接字

	sockaddr_in sin;
	sin.sin_family = AF_INET;
	sin.sin_port = htons(8888);
	/*sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");*/
	inet_pton(AF_INET, "127.0.0.1", (void*)&sin.sin_addr.S_un.S_addr);

	int len = sizeof(sin);

	const char * sendData = "来自客户端的数据包.\n";
	sendto(sclient, sendData, strlen(sendData), 0, (sockaddr *)&sin, len);

	char recvData[255];
	int ret = recvfrom(sclient, recvData, 255, 0, (sockaddr *)&sin, &len);
	if (ret > 0)
	{
		recvData[ret] = 0x00;
		printf(recvData);
	}
	system("pause");
	closesocket(sclient);
	WSACleanup();
	return 0;
}

//Client_demo_UDP

创建两个项目，打开两个cpp文件运行就可以了。

参考链接：https://www.cnblogs.com/codebirdhan/p/7462889.html