C++socket网络编程实战http服务器(支持php)(上)

@TOC

第一章 Socket快速入门篇

1、TCP/IP模型

C++socket网络编程实战http服务器(支持php)(上)_第1张图片

C++socket网络编程实战http服务器(支持php)(上)_第2张图片

用Wireshark抓包工具来看一下上图TCP/IP模型这种4层协议里面究竟有什么内容。

C++socket网络编程实战http服务器(支持php)(上)_第3张图片

C++socket网络编程实战http服务器(支持php)(上)_第4张图片

C++socket网络编程实战http服务器(支持php)(上)_第5张图片

C++socket网络编程实战http服务器(支持php)(上)_第6张图片

在windows和Linux系统之间配置共享

首先保证我们的putty已经连接上了linux服务器,然后我们要安装samba这么一个目录共享工具:

apt-get install samba
where samba
vim /etc/samba/smb.conf
移动该配置项最后,添加内容:

[code]	#这就表示你这个对外部显示的共享目录的名字
path=/code	#我们在根目录下面创建的code目录
writeable=yes
browseable=yes
guest ok = yes

pkill smbd //如果当前smbda已经启动了,先把它杀掉
smbd //重新启动
ps -ef //这只是当前控制端的进程列表
C++socket网络编程实战http服务器(支持php)(上)_第7张图片

ps -ef | grep smbd
竖线表示一个管道,就是把前面命令的输出传给后面,后面再做处理、过滤输出
C++socket网络编程实战http服务器(支持php)(上)_第8张图片

mkdir /code
chmod 777 /code //这是偷懒的办法,更保险的是我们看一下目录当前的权限
ls -l | grep code //这会把每一行的输出进行过滤,匹配之后才输出
在这里插入图片描述

第一个root和第二个root表示这个目录文件所属的用户和所属的组,最左边是权限部分:
d表示它是一个目录,没有的话可能是文件,字母l表示链接;
d后面有9个字母,每3个字母表示一组权限,第一组3个字母rwx表示拥有者用户(owner)的权限,就是这个文件是由谁来创建的,像上图这里显示的是root用户创建的;
中间3个字母r-x表示同组用户(group)的权限;
r-x最后3个字母表示其他人(other)的权限。
我们的目录共享是以一个默认用户进来的,所以说它应该是其他用户,所以我们看到,这个code只能被其他用户读和执行,但是不可以写,而我们是要在windows上编辑linux上的文件,那它就必须要具有写的权限。
我们有两个方案,一个方案就是给这个目录设置3组权限都为rwx:

chmod 777 code
还有一个方案就是给这个目录指定用户可以访问:
在这里插入图片描述

我们设定这个用户和这个组可以访问这个目录。

我们先把这个共享目录code删除,再看看从windows上访问该目录的效果:
在这里插入图片描述

我们按键盘上的窗口键+r打开运行窗口,输入\\192.168.3.69打开linux服务器共享的目录:
C++socket网络编程实战http服务器(支持php)(上)_第9张图片

这就说明我们访问该目录没有权限。

C++socket网络编程实战http服务器(支持php)(上)_第10张图片

在这里插入图片描述

C++socket网络编程实战http服务器(支持php)(上)_第11张图片

C++socket网络编程实战http服务器(支持php)(上)_第12张图片

这样就可以在windows上编辑文件、创建目录了,还可以通过svn或git提交,都可以在windows上执行了。

系统socket库介绍

C++socket网络编程实战http服务器(支持php)(上)_第13张图片

C++socket网络编程实战http服务器(支持php)(上)_第14张图片

2、windows上加载socket库、并创建socket

//main.cpp
//
#include 

int main(int argc, char* argv[])
{
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
	
	return 0;
}

设置项目属性,链接器、输入,ws2_32.lib;

编译成功!

我们调用socket函数:

//main.cpp
//
#include 
#include 

int main(int argc, char* argv[])
{
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
	for(int i = 0; i < 1000; i++)
	{
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
		printf("sock = [%d]\n", sock);
		
		closesocket(sock);
	}
	getchar();
	
	return 0;
}

第一个参数,是用什么协议,AF_INET,就是TCP/IP协议;
第二个参数,传输层用udp还是tcp,这里我们用tcp的;
返回值,socket句柄的值。

3、移植到Linux并设置单进程创建socket的最大数量

//main.cpp
//
#ifdef _WIN32
#include 
#endif
#include 

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	for(int i = 0; i < 1000; i++)
	{
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
		printf("sock = [%d]\n", sock);
		
		closesocket(sock);
	}
	getchar();
	
	return 0;
}

make main
编译如果报错,根据信息可以判断是由于没有添加响应头文件导致的,那么socket相关的头文件是什么呢,我们通过man手册来查找。

man socket
C++socket网络编程实战http服务器(支持php)(上)_第15张图片

//main.cpp
//
#ifdef _WIN32
#include 
#else
#include 
#include 
#endif
#include 

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	for(int i = 0; i < 2000; i++)
	{
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
		printf("sock = [%d]\n", sock);
		
		//closesocket(sock);
	}
	getchar();
	
	return 0;
}

make main
默认会执行编译命令:g++ main.cpp -o main

在这里插入图片描述

在这里插入图片描述

可以看到在linux下,当它创建到1023的时候,再创建socket就失败了,而且我们可以看到在linux下socket是从3开始的,0、1、2是默认已经用掉的,它们分别是标准输入、标准输出、标准错误;
在linux当中,它对单个进程是文件句柄的最大数限制的,我们怎么看这个文件句柄的最大数呢?

ulimit -n
在这里插入图片描述

所以说,我们可以把这个值改掉,也可以把这个限制关闭掉就行了:

ulimit -n 3000

那么怎么保存这个值使之一直生效呢,我们可以把它放在启动项;
或者写一个启动脚本,在这个启动脚本当中把这个指令加进去;或者通过代码来实现。

另外,由于在windows和linux下,关闭socket的函数是不一样的:
C++socket网络编程实战http服务器(支持php)(上)_第16张图片

所以我们修改代码:

//main.cpp
//
#ifdef _WIN32
#include 
#else
#include 
#include 
#include 
#define closesocket close
#endif
#include 

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	for(int i = 0; i < 2000; i++)
	{
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
		printf("sock = [%d]\n", sock);
		
		//closesocket(sock);
	}
	getchar();
	
	return 0;
}

第二章 TCP服务器

TPC协议

  • TCP协议
    C++socket网络编程实战http服务器(支持php)(上)_第17张图片

C++socket网络编程实战http服务器(支持php)(上)_第18张图片

C++socket网络编程实战http服务器(支持php)(上)_第19张图片

网络字节序

C++socket网络编程实战http服务器(支持php)(上)_第20张图片

C++socket网络编程实战http服务器(支持php)(上)_第21张图片

创建tcp服务端

  • int accept(int sockfd, void *addr, int *addrlen);
    C++socket网络编程实战http服务器(支持php)(上)_第22张图片
//main.cpp
//
#include 
#include 
#include 
#ifdef _WIN32
#include 
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
	printf("sock = [%d]\n", sock);
	unsigned short port = 8080;
	if(argc > 1)
		port = atoi(argv[1]);
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	if(bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return -2;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	
	sockaddr_in cliAddr;
	socklen_t socklen = sizeof(cliAddr);
	//这个sock是专门用来建立连接的
	//accept函数返回一个客户端的socket
	int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
	printf("accept client %d\n", client);
	char* ip = inet_ntoa(cliAddr.sin_addr);
	unsigned short cliPort = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
	printf("client ip is %s, port is %d\n", ip, cliPort);
	char buf[1024] = {0};
	for(;;)
	{
		int recvLen = recv(client, buf, sizeof(buf) - 1, 0);
		if(recvLen <= 0)
			break;
		//赋一个\0
		buf[recvLen] = '\0';
		if(strstr(buf, "quit") != nullptr)
		{
			char re[] = "quit success!\n";
			send(client, re, strlen(re) + 1, 0);
			break;
		}
		int sendLen = send(client, "ok\n", 4, 0);
		printf("recv %s\n", buf);
	}

	closesocket(client);
	
	
	//closesocket(sock);
		
	getchar();
	
	return 0;
}

TCP的3次握手是由系统内部已经做完了,我们accept函数只是读取了它3次握手后的信息,所以说是在我们绑定bind、进行lisent之后,对方客户端用连接请求的时候,它就已经完成了3次握手。

//我们现在增加一个功能,每来一个客户端,我们就把它加到一个新的线程当中,这样保证我能同时并发处理多个客户端的数据,
//我们采用C++11的线程

//main.cpp
//
#include 
#include 
#include 
#ifdef _WIN32
#include 
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;

class TcpThread
{
public:
	void Main()
	{
		char buf[1024] = {0};
		for(;;)
		{
			int recvLen = recv(client, buf, sizeof(buf) - 1, 0);
			if(recvLen <= 0)
				break;
			//赋一个\0
			buf[recvLen] = '\0';
			if(strstr(buf, "quit") != nullptr)
			{
				char re[] = "quit success!\n";
				send(client, re, strlen(re) + 1, 0);
				break;
			}
			int sendLen = send(client, "ok\n", 4, 0);
			printf("recv %s\n", buf);
		}

		closesocket(client);
	}
	int client = 0;
};

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
	printf("sock = [%d]\n", sock);
	unsigned short port = 8080;
	if(argc > 1)
		port = atoi(argv[1]);
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	if(bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return -2;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	
	for(;;)
	{
		sockaddr_in cliAddr;
		socklen_t socklen = sizeof(cliAddr);
		//这个sock是专门用来建立连接的
		//accept函数返回一个客户端的socket
		int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
		if(client <= 0)
			break;
		printf("accept client %d\n", client);
		char* ip = inet_ntoa(cliAddr.sin_addr);
		unsigned short cliPort = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
		printf("client ip is %s, port is %d\n", ip, cliPort);
		
		TcpThread *th = new TcpThread();
		th->client = client;
		thread subTh(&TcpThread::Main, th);
		//释放我的主线程拥有的子线程的资源
		sth.detach();
	}
	
	closesocket(client);
	getchar();
	
	return 0;
}

C++socket网络编程实战http服务器(支持php)(上)_第23张图片

编译后报错,提示没有thread,并且你没有用c++11来进行编译,make只是一个简单的自动推导,它不会把这些参数加进去。
重写一个makefile:

tcpserver:main.cpp
	g++ main.cpp -o tcpserver -std=c++11

C++socket网络编程实战http服务器(支持php)(上)_第24张图片
编译报错,它是没找到pthread_create的定义,但是我们其实没调用这个函数,因为c++11它封装的这个thread里面调用了系统的pthread库,因为它针对windows和linux调用了不同的库,所以我们这里要把pthread库给它引用进来,这个库系统都是默认自带的。
我们再改下makefile:

tcpserver:main.cpp
	g++ main.cpp -o tcpserver -std=c++11 -lpthread

C++socket网络编程实战http服务器(支持php)(上)_第25张图片

这样就可以同时处理多路数据,我们就做了并发处理。

接下来我们在windows下编译该代码,正常情况下肯定会有一些错误,毕竟和linux有所区别。

//main.cpp
//
#include 
#include 
#include 
#ifdef _WIN32
#include 
#define socklen_t int
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;

class TcpThread
{
public:
	void Main()
	{
		char buf[1024] = {0};
		for(;;)
		{
			int recvLen = recv(client, buf, sizeof(buf) - 1, 0);
			if(recvLen <= 0)
				break;
			//赋一个\0
			buf[recvLen] = '\0';
			if(strstr(buf, "quit") != nullptr)
			{
				char re[] = "quit success!\n";
				send(client, re, strlen(re) + 1, 0);
				break;
			}
			int sendLen = send(client, "ok\n", 4, 0);
			printf("recv %s\n", buf);
		}

		closesocket(client);
	}
	int client = 0;
};

int main(int argc, char* argv[])
{
//在linux当中socket不需要初始化
#ifdef _WIN32
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	int sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
			return -1;
		}
	printf("sock = [%d]\n", sock);
	unsigned short port = 8080;
	if(argc > 1)
		port = atoi(argv[1]);
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	//为了不和c++11的bind冲突,这里我们用全局的bind
	if(::bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return -2;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	
	for(;;)
	{
		sockaddr_in cliAddr;
		socklen_t socklen = sizeof(cliAddr);
		//这个sock是专门用来建立连接的
		//accept函数返回一个客户端的socket
		int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
		if(client <= 0)
			break;
		printf("accept client %d\n", client);
		char* ip = inet_ntoa(cliAddr.sin_addr);
		unsigned short cliPort = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
		printf("client ip is %s, port is %d\n", ip, cliPort);
		
		TcpThread *th = new TcpThread();
		th->client = client;
		thread subTh(&TcpThread::Main, th);
		//释放我的主线程拥有的子线程的资源
		sth.detach();
	}
	
	closesocket(client);
	getchar();
	
	return 0;
}

第三章 TCP类封装

添加一个类,XTcp,勾选虚析构函数,确定。

大家记得一点,你这个头文件的引用尽量要放在.cpp当中,为什么要放在.cpp当中,而不放在.h当中呢?
你.h如果是被第三方引用,对于调用者来说他只要知道.h就行了,他不需要知道.cpp,你甚至可以把.cpp变成动态链接库,但是.h你是需要给他的,如果你.h当中引用了一些头文件比如windows.h,那就有可能给调用者造成冲突影响,就像std命名空间里面有很多库会与很多库产生冲突,包括windows.h也是一样,它涉及到引用次序,也会对很多函数产生影响;
所以说我们最保险的做法,像windows.h一定不要放在.h当中,放在.cpp当中这样就不会对别人产生影响;产生影响只局限于你本.cpp内部,你可以内部就把它调整过来,当出现一种交错影响的时候,那代码是相当的难调试的。

//XTcp.h
//
#pragma once
#include 

class XTcp
{
public:
	int CreateSocket();
	//绑定端口和listen
	bool Bind(unsigned short port);
	XTcp Accept();
	void Close();
	int Recv(char *buf, int bufsize);
	int Send(const char *buf, int sendsize);
	XTcp();
	virtual ~XTcp();
	int sock = 0;
	unsigned short port = 0;
	std::string ip;
};
//XTcp.cpp
//
#include "XTcp.h"
#include 
#include 
#include 
#ifdef _WIN32
#include 
#define socklen_t int
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;


XTcp::XTcp()
{
#ifdef _WIN32
	static bool first = true;
	if(first)
	{
		first = false;
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);
	}
#endif
}

int XTcp::CreateSocket()
{
	if(sock <= 0)
	{
		sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
		}
	}
	return sock;
}

bool XTcp::Bind(unsigned short port)
{
	if(sock <= 0)
	{
		CreateSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	//为了不和c++11的bind冲突,这里我们用全局的bind
	if(::bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return false;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	return true;
}

XTcp XTcp::Accept()
{
	XTcp tcp;
	sockaddr_in cliAddr;
	socklen_t socklen = sizeof(cliAddr);
	//这个sock是专门用来建立连接的
	//accept函数返回一个客户端的socket
	int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
	if(client <= 0)
		return tcp;
	printf("accept client %d\n", client);
	tcp.sock = client;
	tcp.ip = inet_ntoa(cliAddr.sin_addr);
	tcp.port = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
	printf("client ip is %s, port is %d\n", tcp.ip.c_str(), tcp.port);
	return tcp;
}

int XTcp::Recv(char *buf, int bufsize)
{
	return recv(sock, buf, bufsize, 0);
}

int XTcp::Send(const char *buf, int size)
{
	int sendedSize = 0;
	while(sendedSize != size)
	{
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if(len <= 0)
			break;
		sendedSize += len;
	}
	return sendedSize;
}

void XTcp::Close()
{
	if(sock <= 0) return;
	closesocket(sock);
}

XTcp::~XTcp()
{

}
//main.cpp
//
#include 
#include "XTcp.h"
#include 
#include 

class TcpThread
{
public:
	void Main()
	{
		char buf[1024] = {0};
		for(;;)
		{
			int recvLen = client.Recv(buf, sizeof(buf) - 1);
			if(recvLen <= 0)
				break;
			//赋一个\0
			buf[recvLen] = '\0';
			if(strstr(buf, "quit") != nullptr)
			{
				char re[] = "quit success!\n";
				client.Send(re, strlen(re) + 1);
				break;
			}
			int sendLen = client.Send("ok\n", 4);
			printf("recv %s\n", buf);
		}

		client.Close();
	}
	XTcp client;
};

int main(int argc, char* argv[])
{
	unsigned short port = 8080;
	if(argc > 1)
	{
		port = atoi(argv[1]);
	}
	XTcp server;
	server.CreateSocket();
	server.Bind(port);
	
	for(;;)
	{
		XTcp client = server.Accept();
		
		TcpThread *th = new TcpThread();
		th->client = client;
		std::thread subTh(&TcpThread::Main, th);
		//释放我的主线程拥有的子线程的资源
		sth.detach();
	}
	
	server.Close();
	
	getchar();
	
	return 0;
}

在windows下编译运行测试成功!

在linux下编译报错:

错误提示Recv、Send函数和Close函数没有定义,那是因为我们的makefile里面没有包含XTcp.cpp这个文件,我们把makefile修改一下:

tcpserver:main.cpp XTcp.cpp XTcp.h
	g++ main.cpp XTcp.cpp -o tcpserver -std=c++11 -lpthread

C++socket网络编程实战http服务器(支持php)(上)_第26张图片

创建XTcp动态dll链接库项目并测试

我们把前面做的XTcp这个类放到一个动态链接库当中,分别在windows和linux当中都来实现这个动态链接库。
我们新建一个Win32 控制台应用程序,XSocket,应用程序类型选择DLL,附加选项选择导出符号,导出符号的好处项目当中有一些宏已经帮你定义好了,省得你定义了。
把前面做的XTcp.h和XTcp.cpp拷贝到当前项目目录中,并添加到当前项目中。

//XTcp.h
//
#pragma once
#include 

#ifdef XSOCKET_EXPORTS
#define XSOCKET_API __declspec(dllexport)
#else
#define XSOCKET_API __declspec(dllimport)
#endif

class XSOCKET_EXPORTS XTcp
{
public:
	int CreateSocket();
	//绑定端口和listen
	bool Bind(unsigned short port);
	XTcp Accept();
	void Close();
	int Recv(char *buf, int bufsize);
	int Send(const char *buf, int sendsize);
	XTcp();
	virtual ~XTcp();
	int sock = 0;
	unsigned short port = 0;
	char ip[16];
};

记得关闭预编译头。

//XTcp.cpp
//
#include "XTcp.h"
#include 
#include 
#include 
#ifdef _WIN32
#include 
#define socklen_t int
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;


XTcp::XTcp()
{
#ifdef _WIN32
	static bool first = true;
	if(first)
	{
		first = false;
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);
	}
#endif
}

int XTcp::CreateSocket()
{
	if(sock <= 0)
	{
		sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
		}
	}
	return sock;
}

bool XTcp::Bind(unsigned short port)
{
	if(sock <= 0)
	{
		CreateSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	//为了不和c++11的bind冲突,这里我们用全局的bind
	if(::bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return false;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	return true;
}

XTcp XTcp::Accept()
{
	XTcp tcp;
	sockaddr_in cliAddr;
	socklen_t socklen = sizeof(cliAddr);
	//这个sock是专门用来建立连接的
	//accept函数返回一个客户端的socket
	int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
	if(client <= 0)
		return tcp;
	printf("accept client %d\n", client);
	tcp.sock = client;
	char *ip = inet_ntoa(cliAddr.sin_addr);
	strcpy(tcp.ip, ip);
	tcp.port = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
	printf("client ip is %s, port is %d\n", tcp.ip, tcp.port);
	return tcp;
}

int XTcp::Recv(char *buf, int bufsize)
{
	return recv(sock, buf, bufsize, 0);
}

int XTcp::Send(const char *buf, int size)
{
	int sendedSize = 0;
	while(sendedSize != size)
	{
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if(len <= 0)
			break;
		sendedSize += len;
	}
	return sendedSize;
}

void XTcp::Close()
{
	if(sock <= 0) return;
	closesocket(sock);
}

XTcp::~XTcp()
{

}

我们参考开源项目,调整一下代码的结构,创建几个目录:bin、src、lib、doc。

  • 打开项目属性、配置属性、常规,把项目的输出目录修改为..\..\bin\
  • 链接器、高级,我们修改导入库,把生成的lib文件放到..\..\lib\$(TargetName).lib
  • 配置属性、调试,修改工作目录..\..\bin\,调试中的这个工作目录是指你这个执行程序在哪个路径下执行,因为你的dll在bin目录中,所以你这个调试路径不设置为bin目录的话,你就无法通过测试程序调试这个dll。

测试

右击解决方案,添加新项目,tcpserver,应用程序类型选择控制台应用程序,空项目。
打开解决方案属性,设置启动项目为tcpserver,项目依赖项为tcpserver依赖于xsocket,也就是当tcpserver要运行的时候,必须保证xsocket已经编译过了。
给tcpserver项目添加server.cpp,我们还要引用头文件XTcp.h和对应的链接库:

  • 打开tcpserver属性,C/C++,设置附加包含目录为..\xsocket
  • 链接器,常规,设置附加库目录为..\..\lib
  • 链接器,输入,给附加依赖项添加xsocket.lib
//server.cpp
//
#include "XTcp.h"
int main(int argc, char *argv[])
{
	unsigned short port = 8080;
	if(argc > 1)
	{
		port = atoi(argv[1]);
	}
	XTcp server;
	server.Bind(port);
	XTcp client = server.Accept();

	server.Close();
	
	getchar();
	return 0;
}

我们先写一个简单的,保证输出测试成功。
打开项目的配置属性,常规,设置输出目录为..\..\bin\
配置属性,调试,设置工作目录为..\..\bin\

测试成功后,我们再把之前代码中的线程那部分代码拷贝过来:

//server.cpp
//
#include 
#include "XTcp.h"
#include 
#include 

class TcpThread
{
public:
	void Main()
	{
		char buf[1024] = {0};
		for(;;)
		{
			int recvLen = client.Recv(buf, sizeof(buf) - 1);
			if(recvLen <= 0)
				break;
			//赋一个\0
			buf[recvLen] = '\0';
			if(strstr(buf, "quit") != nullptr)
			{
				char re[] = "quit success!\n";
				client.Send(re, strlen(re) + 1);
				break;
			}
			int sendLen = client.Send("ok\n", 4);
			printf("recv %s\n", buf);
		}

		client.Close();
	}
	XTcp client;
};

int main(int argc, char* argv[])
{
	unsigned short port = 8080;
	if(argc > 1)
	{
		port = atoi(argv[1]);
	}
	XTcp server;
	server.CreateSocket();
	server.Bind(port);
	
	for(;;)
	{
		XTcp client = server.Accept();
		
		TcpThread *th = new TcpThread();
		th->client = client;
		std::thread subTh(&TcpThread::Main, th);
		//释放我的主线程拥有的子线程的资源
		sth.detach();
	}
	
	server.Close();
	
	getchar();
	
	return 0;
}

创建XTcp动态so链接库项目(Linux)并测试

在xsocket项目目录中,新建并编写makefile文件:

libxsocket.so:XTcp.cpp XTcp.h
	g++ $+ -o $@ -fpic -shared -std=c++11

编译出错,主要是在linux当中不认识windows中的几个宏,我们修改动态链接库的代码:

//XTcp.h
//
#ifndef _XTCP_H_
#define _XTCP_H_
#include 

#ifdef _WIN32
#ifdef XSOCKET_EXPORTS
#define XSOCKET_API __declspec(dllexport)
#else
#define XSOCKET_API __declspec(dllimport)
#endif
#else
#define XSOCKET_API
#endif

class XSOCKET_EXPORTS XTcp
{
public:
	int CreateSocket();
	//绑定端口和listen
	bool Bind(unsigned short port);
	XTcp Accept();
	void Close();
	int Recv(char *buf, int bufsize);
	int Send(const char *buf, int sendsize);
	XTcp();
	virtual ~XTcp();
	int sock = 0;
	unsigned short port = 0;
	char ip[16];
};

#endif
//XTcp.cpp
//
#include "XTcp.h"
#include 
#include 
#include 
#ifdef _WIN32
#include 
#define socklen_t int
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;


XTcp::XTcp()
{
#ifdef _WIN32
	static bool first = true;
	if(first)
	{
		first = false;
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);
	}
#endif
}

int XTcp::CreateSocket()
{
	if(sock <= 0)
	{
		sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
		}
	}
	return sock;
}

bool XTcp::Bind(unsigned short port)
{
	if(sock <= 0)
	{
		CreateSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	//为了不和c++11的bind冲突,这里我们用全局的bind
	if(::bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return false;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	return true;
}

XTcp XTcp::Accept()
{
	XTcp tcp;
	sockaddr_in cliAddr;
	socklen_t socklen = sizeof(cliAddr);
	//这个sock是专门用来建立连接的
	//accept函数返回一个客户端的socket
	int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
	if(client <= 0)
		return tcp;
	printf("accept client %d\n", client);
	tcp.sock = client;
	char *ip = inet_ntoa(cliAddr.sin_addr);
	strcpy(tcp.ip, ip);
	tcp.port = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
	printf("client ip is %s, port is %d\n", tcp.ip, tcp.port);
	return tcp;
}

int XTcp::Recv(char *buf, int bufsize)
{
	return recv(sock, buf, bufsize, 0);
}

int XTcp::Send(const char *buf, int size)
{
	int sendedSize = 0;
	while(sendedSize != size)
	{
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if(len <= 0)
			break;
		sendedSize += len;
	}
	return sendedSize;
}

void XTcp::Close()
{
	if(sock <= 0) return;
	closesocket(sock);
}

XTcp::~XTcp()
{

}

测试

在tcpserver项目目录中,新建并编写makefile文件:

tcpserver:server.cpp
	g++ $+ -o $@

编译报错:
C++socket网络编程实战http服务器(支持php)(上)_第27张图片

我们要把头文件路径给它指定一下:

tcpserver:server.cpp
	g++ $+ -o $@ -I../xsocket/ -std=c++11 -lpthread -lxsocket -L../xsocket

在这里插入图片描述

提示说它找不到这个xsocket这个库,在linux你必须要指定环境变量,所以我们一个方案就是可以写一个脚本run:

export LD_LIBRARY_PATH = ../xsocket
./tcpserver

chmod +x run
./run

还有一个省事的方案,你把动态链接库每次改变的时候,你把它拷贝到系统目录下面:

libxsocket.so:XTcp.cpp XTcp.h
	g++ $+ -o $@ -fpic -shared -std=c++11
	cp *.so /usr/lib/

假设我们想直接输入tcpserver运行呢?
那我们要把tcpserver也放在系统的环境变量下面去。

tcpserver:server.cpp
	g++ $+ -o $@ -I../xsocket/ -std=c++11 -lpthread -lxsocket -L../xsocket
	cp $@ /usr/bin/

第四章 TCP客户端

新建一个控制台应用程序的空项目,在这个项目当中我们引用之前做好的XTcp这个库,右击解决方案,添加现有项目,把我们的xsocket项目加进来。
再做一下启动项和依赖项的设置。
再把输出目录,工作目录,附加包含目录,附加库目录,附加依赖项。

我们这个客户端很简单,就演示一下建立连接、发送数据、接收数据。

//tcpclient.cpp
//
#include "XTcp.h"

int main()
{
	XTcp client;
	
	return 0;
}

C++socket网络编程实战http服务器(支持php)(上)_第28张图片

看上图,我们来看一下TCP的三次握手的过程。
服务端这里创建了一个Socket,绑定了一个端口,通过listen开始监听,listen之后就是被动打开,也就是说它是由对方发送信息,它被动的反应,而不是主动去做。
服务端做好了之后,客户端是怎么进行三次握手的呢?
客户端它也要创建一个Socket,通过这个Socket调用Connect,Connect也是一个阻塞的函数,它是主动打开,它发一个SYN一个J过去,服务端收到这个包之后,服务端也会发一个SYN一个K过去,然后它会回一个ack的J+1回去,这个过程你在TCP协议头当中都会包含这几个内容;
当客户端收到服务端发过来的这个回应之后,Connect就会再发送一个ack K+1过去,就是告诉服务器我也收到你的信息了。

三次握手的过程在Connect函数内部其实就已经完成了,Accept只是读三次握手已经完成后的数据。

//XTcp.h
//
#ifndef _XTCP_H_
#define _XTCP_H_
#include 

#ifdef _WIN32
#ifdef XSOCKET_EXPORTS
#define XSOCKET_API __declspec(dllexport)
#else
#define XSOCKET_API __declspec(dllimport)
#endif
#else
#define XSOCKET_API
#endif

class XSOCKET_EXPORTS XTcp
{
public:
	int CreateSocket();
	//绑定端口和listen
	bool Bind(unsigned short port);
	XTcp Accept();
	void Close();
	int Recv(char *buf, int bufsize);
	int Send(const char *buf, int sendsize);
	bool Connect(const char *ip, unsigned short port);
	XTcp();
	virtual ~XTcp();
	int sock = 0;
	unsigned short port = 0;
	char ip[16];
};

#endif
//XTcp.cpp
//
#include "XTcp.h"
#include 
#include 
#include 
#ifdef _WIN32
#include 
#define socklen_t int
#else
#include 
#include 
#include 
#include 
#define closesocket close
#endif

#include 
using namespace std;


XTcp::XTcp()
{
#ifdef _WIN32
	static bool first = true;
	if(first)
	{
		first = false;
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);
	}
#endif
}

int XTcp::CreateSocket()
{
	if(sock <= 0)
	{
		sock = socket(AF_INET, SOCK_STREAM, 0);
		if(sock == -1)
		{
			printf("create socket failed! sock = %d\n", sock);
		}
	}
	return sock;
}

bool XTcp::Bind(unsigned short port)
{
	if(sock <= 0)
	{
		CreateSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);	//本地字节序转成网络字节序、主机字节序转成网络字节序
	saddr.sin_addr.s_addr = htonl(0);	//任意的IP地址发过来的数据我们都接收
	//为了不和c++11的bind冲突,这里我们用全局的bind
	if(::bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("bind port %d failed! \n", port);
		return false;
	}
	printf("bind port %d success!\n", port);
	listen(sock, 10);
	return true;
}

XTcp XTcp::Accept()
{
	XTcp tcp;
	sockaddr_in cliAddr;
	socklen_t socklen = sizeof(cliAddr);
	//这个sock是专门用来建立连接的
	//accept函数返回一个客户端的socket
	int client = accept(sock, (sockaddr*)&cliAddr, &socklen);
	if(client <= 0)
		return tcp;
	printf("accept client %d\n", client);
	tcp.sock = client;
	char *ip = inet_ntoa(cliAddr.sin_addr);
	strcpy(tcp.ip, ip);
	tcp.port = ntohs(cliAddr.sin_port);	//网络字节序转成本地字节序
	printf("client ip is %s, port is %d\n", tcp.ip, tcp.port);
	return tcp;
}

int XTcp::Recv(char *buf, int bufsize)
{
	return recv(sock, buf, bufsize, 0);
}

int XTcp::Send(const char *buf, int size)
{
	int sendedSize = 0;
	while(sendedSize != size)
	{
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if(len <= 0)
			break;
		sendedSize += len;
	}
	return sendedSize;
}

void XTcp::Close()
{
	if(sock <= 0) return;
	closesocket(sock);
}

bool XTcp::Connect(const char *ip, unsigned short port)
{
	if(sock <= 0)
		CreateSocket();
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	saddr.sin_addr.s_addr = inet_addr(ip);
	if(connect(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
	{
		printf("connect %s:%d failed!:%s\n", ip, port, strerror(errno));
		return false;
	}
	printf("connect %s:%d success!\n", ip, port);
	return true;
}

XTcp::~XTcp()
{

}
//tcpclient.cpp
//
#include "XTcp.h"

int main()
{
	XTcp client;
	client.Connect("192.168.0.108", 8080);
	client.Send("client", 6);
	char buf[1024] = {0};
	client.Recv(buf, sizeof(buf));
	printf("client recv : %s\n", buf);
	
	return 0;
}
tcpclient:tcpclient.cpp
	g++ $+ -o $@ -I../xsocket/ -std=c++11 -lpthread -lxsocket -L../xsocket
	cp $@ /usr/bin/

C++socket网络编程实战http服务器(支持php)(上)_第29张图片

第五章 TCP阻塞超时和高并发处理

超时处理

你可能感兴趣的:(windows程序设计,服务器,网络,c++,socket)