C++sokcet网络编程笔记

C++网络编程

TCP/IP协议

网络介质层：将模拟信号转化成数字信号，会形成一个MAC地址（本机地址，一般情况下不会变化）。百兆宽带用4根线，千兆宽带用8根线进行传输。

网络层：进行网络层的通讯，IP地址对IP地址。

数据进行协议栈时的封装：

WireShark抓包工具

可以通过wireshark进行网络抓包分析，具体教程可以参考网络分析工具——WireShark的使用（超详细）教程进行软件安装和使用，注意Windows可能需要安装一个小插件，软件才能实现本地化配置，具体博客内已经详细说明了情况，这里附上软件下载地址：win10pcap。

windows和linux系统之间配置共享

使用windows编辑工具直接编辑linux代码：

• 直接用在windows中提交linux上源码
• 使用VS直接编辑linux跨平台代码
• 安装配置samba

samba安装

切换到管理员账号/使用sudo权限，

apt-get install sambda

然后编辑sambda的配置文件

vim /etc/samba/smb.conf

在文件末尾加载以下内容：

[code]
path=/your_dir
writeable=yes
browseable=yes
guest ok =yes

然后使用命令在服务器上创建your_dir：

mkdir /your_dir

然后重启smbd，先杀掉进程，在重启：

pkill smbd
smbd

接着设置your_dir的访问权限，防止不能在文件内进行操作：

chown nobody:nogroup /your_dir

然后使用cmd，输入\\ip_adress，我的就是\\192.168.20.121回车之后就可以跳转到文件夹中，进行创建文件、修改文件，修改后服务器也会自动进行修改。

socke函数

socket又称为套接字。
套接字的定义：

1. 套接字是一个主机本地应用程序所创建的，为操作系统所控制的接口（门），其实也就是程序使用socket通知操作系统对主机硬件进行操作。
2. 应用进程通过这个接口，使用传输层提供的服务，跨网络发送（/接收）消息到（/从）其他应用进程。
3. Client/server模式的通信接口——套接字接口。

socket其实就是文件，Socket发送方和接收方都不是实时的，需要排队进行处理（好处是稳定可靠、坏处是可能不执行）。socket不仅仅只用于网络通信，还可以用于蓝牙、红外等。

windows/linux创建socket

//使用ifdef-endif可以在程序运行开始前识别主机环境
#ifdef WIN32
#include
#else
#include
#include
#include
//函数名替换，重定义，将close关闭sock的函数转化为closesocket
#define closesocket close
#endif
#include 

using namespace std;

int main(int argc,char* argv[])
{	
	#ifdef WIN32
	//通过进程启动Winsock DLL使用
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
	#endif
	for (int i = 0; i < 1000; i++) {
		//创建socket，创建失败返回-1，AF_INET表示ipv4协议，SOCK_STREAM表示接受tcp/ip协议的数据
		int sock = socket(AF_INET, SOCK_STREAM, 0);
		if (sock == -1) {
			cout << "create socket failed" << endl;
			return -1;
		}
		cout << "[" << sock << "]" << endl;
		//socket关闭
		closesocket(sock);
	}
	return 0;
}

windows用户在vs studio上运行需要添加ws2_32.lib进行编译，否则会出错。具体可以参考Visual Studio 2019 C++实现socket通信，添加ws2_32.lib库，新手代码。

TCP协议

TCP协议的性质：

• TCP是面向连接的，需要三次握手确定连接后才开始发送数据，而UDP是直接发送数据的。
• TCP提供了可靠性，实现了丢失重传。RTT的估算。
• TCP通过给所发送数据的每一个段管理一个序列号进行排序。
• TCP提供流量控制。通信窗口、拥塞窗口。
• TCP连接是全双工的，也就是说基于TCP连接的程序/进程可以同时接收数据和发送数据，具有不同的传出信道。

TCPServer在windows/linux通用程序

#ifdef WIN32
#include
#define socklen_t int
#else
#include
#include
#include
#include
//函数名替换，重定义，将close关闭sock的函数转化为closesocket
#define closesocket close
#endif
#include 
#include
#include
#include

using namespace std;

class TCPThread {
public:
	void main() {
		while (true) {

			//recv和send都不能保证能够发送信息和收到信息成功
			char buf[1024] = { 0 };
			//接收客户端发送得请求，并将其内容存储在buf字符串中
			int reclen = recv(client_sock, buf, sizeof(buf) - 1, 0);
			if (reclen <= 0) {
				break;
			}
			buf[reclen] = '\0';
			if (strstr(buf, "quit") != NULL) {
				char re[] = "quit success!\n";
				//服务器向客户端发送数据
				send(client_sock, re, strlen(re) + 1, 0);
				break;
			}
			int sendlen = send(client_sock, "ok\n", 4, 0);
			cout << "receive data: " << buf << endl;
		}
		closesocket(client_sock);
		delete this;
	}
	int client_sock=0;
};

int main(int argc, char* argv[])
{
#ifdef WIN32
	//通过进程启动Winsock DLL使用
	WSADATA ws;
	WSAStartup(MAKEWORD(2, 2), &ws);
#endif
	
	//创建socket，创建失败返回-1，AF_INET表示ipv4协议，SOCK_STREAM表示接受tcp/ip协议的数据
	int sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		cout << "create socket failed" << endl;
		return -1;
	}
	cout << "[" << sock << "]" << endl;

	//获得端口号
	unsigned short port = 8080;
	if (argc > 1) {
		port = atoi(argv[1]);
	}
	//绑定地址
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	//大端字节序和小端字节序的问题，
	saddr.sin_port = htons(port);
	//0设置为绑定本机地址
	saddr.sin_addr.s_addr = htonl(0);

	//绑定地址
	if (bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0) {
		cout << "bind port " << port << " failed.\n";
		return -2;
	}
	cout << "bind port " << port << " successful.\n";

	//监听客户端发送的信息
	//backlog=10表示缓冲大小
	listen(sock, 10);

	while (true) {
		//每个连接就会生成一个client
		sockaddr_in caddr;
		socklen_t len = sizeof(caddr);
		//在accept之前会进行三次握手（由操作系统完成），accept只是获取了握手后的信息
		int client_sock = accept(sock, (sockaddr*)&caddr, &len);
		if (client_sock <= 0) {
			break;
		}
		cout << "accept client " << client_sock << ".\n";
		char* ip = inet_ntoa(caddr.sin_addr);
		unsigned short cport = ntohs(caddr.sin_port);
		cout << "client ip address " << ip << ".\n";
		cout << "client port " << cport << ".\n";

		TCPThread* th = new TCPThread();
		th->client_sock = client_sock;
		//启动多线程，第一个参数是函数地址，第二个为对象本身
		thread sth(&TCPThread::main, th);
		//释放主线程中子线程的资源
		sth.detach();
	}
	//socket关闭
	closesocket(sock);

	return 0;
}

TCP封装成函数便于使用

XTCP.h

#ifndef XTCP_H //保证只初始化一次
#define XTCP_H

#ifdef WIN32
#pragma once

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

#else
#define XSOCKET_API
#endif // WIN32

#include
class XSOCKET_API XTCP
{
public:
	int createSocket();
	bool bindListen(unsigned short port);
	void closeSocket();
	int receiveData(char* buf,int bufsize);
	int sendData(const char* buf, int sendsize);
	bool connectSocket(const char* ip, unsigned short port);
	XTCP acceptClient();
	XTCP();
	virtual ~XTCP();

	int sock = 0;
	unsigned short port = 0;
	char ip[16];
};
#endif // !XTCP_H

XTCP.cpp

#include "XTCP.h"
#ifdef WIN32
#include
#define socklen_t int
#else
#include
#include
#include
#include
//函数名替换，重定义，将close关闭sock的函数转化为closesocket
#define closesocket close
#define strcpy_s strcpy
#endif
#include 
#include
#include

XTCP::XTCP() {
#ifdef WIN32
	static bool is_first = true;
	if (is_first) {
		is_first = false;		
		//通过进程启动Winsock DLL使用
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);		
	}
#endif
}


bool XTCP::connectSocket(const char* ip, unsigned short port) {
	if (sock <= 0) {
		createSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	//将字符串ip地址转化为网络地址
	saddr.sin_addr.s_addr = inet_addr(ip);

	if (connect(sock, (const sockaddr*)&saddr, sizeof(saddr)) != 0) {
		// strerror(errno)将错误转化为字符串
		std::cout << "connect " << ip << " : " << port << " failed! ";
		return false;
	}
	std::cout << "connect " << ip << " : " << port << " success!\n ";
	return true;
}

int XTCP::createSocket() {
	//创建socket，创建失败返回-1，AF_INET表示ipv4协议，SOCK_STREAM表示接受tcp/ip协议的数据
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		std::cout << "create socket failed" << std::endl;
	}
	return sock;
}

bool XTCP::bindListen(unsigned short port) {
	if (sock <= 0) {
		createSocket();
	}
	//绑定地址
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	//大端字节序和小端字节序的问题，
	saddr.sin_port = htons(port);
	//0设置为绑定本机地址
	saddr.sin_addr.s_addr = htonl(0);

	//绑定地址
	if (bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0) {
		std::cout << "bind port " << port << " failed.\n";
		return false;
	}
	std::cout << "bind port " << port << " successful.\n";

	//监听客户端发送的信息
	//backlog=10表示缓冲大小
	listen(sock, 10);
	return true;
}

XTCP XTCP::acceptClient() {
	XTCP tcp;
	//每个连接就会生成一个client
	sockaddr_in caddr;
	socklen_t len = sizeof(caddr);
	//在accept之前会进行三次握手（由操作系统完成），accept只是获取了握手后的信息
	int client_sock = accept(sock, (sockaddr*)&caddr, &len);
	if (client_sock <= 0) {
		return tcp;
	}
	tcp.sock = client_sock;
	std::cout << "accept client " << client_sock << ".\n";
	char* ip = inet_ntoa(caddr.sin_addr);
	strcpy_s(tcp.ip, ip);
	tcp.port = ntohs(caddr.sin_port);
	std::cout << "client ip address " << tcp.ip << ".\n";
	std::cout << "client port " << tcp.port << ".\n";
	return tcp;
}


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

int XTCP::sendData(const char* buf, int sendsize) {
	//需要全部发送完全才能结束
	int sendedSize = 0;
	while (sendedSize!=sendsize) {
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if (len <= 0) {
			break;
		}
		sendedSize += len;
	}
	return sendedSize;
}

void XTCP::closeSocket() {
	if (sock <= 0) {
		return;
	}
	closesocket(sock);
}

XTCP::~XTCP() {

}

通过上述函数就可以实现在Windows封装成lib文件，在Linux封装成so文件进行更方便的使用。更多细节参考C/C++封装：Windows/Linux下封装.lib/.so文件。

makefile最基本使用

tcpserver:testSocket2.cpp XTCP.h XTCP.cpp
        g++ testSocket2.cpp XTCP.cpp -o tcpserver -std=c++11 -lpthread

目标文件:源文件和头文件（空格隔开）
		g++ 源文件（不需要头文件） -o 目标文件名 附加命令
		-lpthread：表示多线程使用
		-std：表示c++版本

直接使用make命令就可以执行该程序了

编译成.so文件：

libxsocket.so:XTCP.cpp XTCP.h
        g++ $+ -o $@ -fpic -shared -std=c++11
        
$+:文件列表——依赖项
$@：目标文件——目标项
-fpic：代码与位置无关
-shared：把代码编译成动态链接库

三次握手

第一次握手：客户端给服务器发送一个J信号。
第二次握手：服务器接收客户端发送的请求，并得到客户端发送的J信号（但这个信号不一定正确），所以服务器会返回J+1信号和一个K信号。
第三次握手：客户端接收服务器发送返回的J+1信号，如果正确表示客户端和服务器端通信正常，但是此时服务器端还不知道通信是否正常，所以客户端还需要将服务器发送的K进行处理，发送K+1信号给服务器端，告知服务器通信正常。

服务器和客户端进行TCP/IP通信的流程

服务器的close会关闭两个通信口，一个是接收数据通信的send和recv的通道，一个是socket客户端和服务器端连接的通道。

设置阻塞方式

在Windows和Linux中，socket阻塞和及时通信方式具有很大的差异，windows通过使用ioctsocket()函数进行设置，而linux则是通过fcntl()函数进行处理。具体如下代码所示。

bool XTCP::setBlock(bool isBlock) {
	//默认为阻塞模式 isBlock=true
	if (sock <= 0) {
		return false;
	}
	#ifdef WIN32
		unsigned long ul = 0;
		if (!isBlock) {
			ul = 1;
		}
		//ul=1就会立刻返回结果，反之，则不会立即返回，只有windows才有这个函数
		ioctlsocket(sock, FIONBIO, &ul);
	#else
		#include //头文件
		//fcntl操作文件描述符的函数，
		int flag=fcntl(sock, F_GETFL, 0);
		if (flag < 0) {
			return false;
		}
		if (isBlock) {
			flag = flag & ~O_NONBLOCK;
		}
		else {
			flag = flag | O_NONBLOCK;
		}
		if (fcntl(sock, F_SETFL, flag) != 0) {
			return false;
		}
	#endif // WIN32

	return true;
}

select实现connect超时退出

当客户端请求ip、port出现错误时，connect()原始来阻塞模式，会导致程序一直阻塞在这里，无法执行后续代码。而select()函数就可以打破这个僵局，实现超时跳过的操作，并且具有多路复用、同时监听多个文件的功能，具体代码可以如下所示：

bool XTCP::connectSocket(const char* ip, unsigned short port, int timeoutms) {
	if (sock <= 0) {
		createSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	//将字符串ip地址转化为网络地址
	saddr.sin_addr.s_addr = inet_addr(ip);

	setBlock(false);
	fd_set set;

	if (connect(sock, (const sockaddr*)&saddr, sizeof(saddr)) != 0) {
		//置空
		FD_ZERO(&set);
		FD_SET(sock, &set);
		// 两个参数的结构体，分别是秒和微秒
		timeval tm;
		tm.tv_sec = 0;
		tm.tv_usec = timeoutms * 1000;
		if (select(sock + 1, 0, &set, 0, &tm) <= 0) {
			printf("connect time or error!\n");
			// strerror(errno)将错误转化为字符串
			std::cout << "connect " << ip << " : " << port << " failed! ";
			return false;
		}
	}
	setBlock(true);
	std::cout << "connect " << ip << " : " << port << " success!\n ";
	return true;
}

更多select()函数解析可以查看网络编程之select。

apache2使用

apache用于网络测数，linux安装apt-get install apache2，安装完成后就可以使用命令进行操作了。例如：

ab -n 1000 -c 5 https://www.baidu.com/

表示连接数为1000，连接的线程数为5，访问的网址为：https://www.baidu.com/，也可以测自己本地的局域网服务器。输出结果如下图所示：

root@xiehou--ubuntu:/cpp_study/socket/src/tcpClient# ab -n 100 -c 5 https://www.baidu.com/
This is ApacheBench, Version 2.3 <$Revision: 1843412 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking www.baidu.com (be patient).....done


Server Software:        BWS/1.1
Server Hostname:        www.baidu.com
Server Port:            443
SSL/TLS Protocol:       TLSv1.2,ECDHE-RSA-AES128-GCM-SHA256,2048,128
Server Temp Key:        ECDH P-256 256 bits
TLS Server Name:        www.baidu.com

Document Path:          /
Document Length:        227 bytes

Concurrency Level:      5
Time taken for tests:   1.305 seconds
Complete requests:      100
Failed requests:        0
Total transferred:      139893 bytes
HTML transferred:       22700 bytes
Requests per second:    76.65 [#/sec] (mean)
Time per request:       65.231 [ms] (mean)
Time per request:       13.046 [ms] (mean, across all concurrent requests)
Transfer rate:          104.72 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:       36   47  15.2     44     125
Processing:    11   15   2.6     14      33
Waiting:       11   14   2.6     14      32
Total:         49   62  15.6     58     139

Percentage of the requests served within a certain time (ms)
  50%     58
  66%     60
  75%     62
  80%     64
  90%     73
  95%    109
  98%    135
  99%    139
 100%    139 (longest request)

epoll多路复用IO高并发（Linux中）

epoll应对的现状：

1. 大量并发连接中只有少量活跃。
2. LT（level Triggered），水平触发， 一直触发。
3. ET（Edge Triggered），边沿触发，只触发一次 ， 只有文件描述符从不可读变为可读的时候才会被触发， EPOLLET 这个宏用于设置ET模式。

更多epoll学习资料可以参考tcp使用epoll进行实现并发。

HTTP协议

• HTTP超文本传输协议，所有的WWW文件都必须遵守这个标准。
• HTTP/1.0短连接（接受连接之后就会关闭），HTTP/1.1它支持持续连接，端口默认是80端口。

HTTP URL（URL是一种特殊类型的URI，包含了用于查找某个资源的足够的信息）格式如http://host[":" port][abs_path]。

http表示要通过HTTP协议来定位网络资源，host表示合法的Internet主机域名或者IP地址；port指定一个端口号，为空则使用缺省端口80；abs_path指定请求资源的URI；如果URL中没有给出abs_path，那么当它作为请求URI时，必须以“/”的形式给出，通常这个工作浏览器自动完成。

Method Request-URI HTTP-Version CRLF，CRLF表示换行。
HTTP请求的方法具有很多种：

• GET。请求获取Request-URI所标识的资源。
• POST，在Request-URI所标识的资源后附加新的数据。
• HEAD。请求获取由Request-URI所表示的资源的响应消息报头。
• PUT。请求服务器存储一个资源，并用Request-URI作为标识。
• DELETE。请求服务器删除Request-URI所标识的资源。
• TRACE。请求服务器会送收到的请求消息，主要用于测试或诊断
• CONNECT。保留将来使用。
• OPTIONS。请求查询服务器的性能，或者查询与资源相关的选项和需求。

HTTP响应信息包含：
主要有三个部分组成，分别是：状态行、消息报头、响应正文。
状态行：HTTP-Version Status-Code Reason-Phrase CRLF。HTTP-Version表示服务器HTTP协议版本；Status-Code表示服务器发回的响应状态代码；Reason-Phrase表示状态代码的文本描述。

使用socket简单封装一个http服务器

XTCP.h

#ifndef XTCP_H //保证只初始化一次
#define XTCP_H

#ifdef WIN32
#pragma once

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

#else

#define XSOCKET_API

#endif // WIN32

#include
class XSOCKET_API XTCP
{
public:
	int createSocket();
	bool bindListen(unsigned short port);
	void closeSocket();
	int receiveData(char* buf,int bufsize);
	int sendData(const char* buf, int sendsize);
	bool connectSocket(const char* ip, unsigned short port);
	bool connectSocket(const char* ip, unsigned short port,int timeoutms);
	bool setBlock(bool isBlock);
	XTCP acceptClient();
	XTCP();
	virtual ~XTCP();

	int sock = 0;
	unsigned short port = 0;
	char ip[16];
};

#endif // !XTCP_H

XTCP.cpp

#include "XTCP.h"
#ifdef WIN32
#include
#define socklen_t int
#else
#include
#include
#include
#include
#include
//函数名替换，重定义，将close关闭sock的函数转化为closesocket
#define closesocket close
#define strcpy_s strcpy
#endif
#include 
#include
#include

XTCP::XTCP() {
#ifdef WIN32
	static bool is_first = true;
	if (is_first) {
		is_first = false;		
		//通过进程启动Winsock DLL使用
		WSADATA ws;
		WSAStartup(MAKEWORD(2, 2), &ws);		
	}
#endif
}


bool XTCP::connectSocket(const char* ip, unsigned short port, int timeoutms) {
	if (sock <= 0) {
		createSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	//将字符串ip地址转化为网络地址
	saddr.sin_addr.s_addr = inet_addr(ip);

	setBlock(false);
	fd_set set;

	if (connect(sock, (const sockaddr*)&saddr, sizeof(saddr)) != 0) {
		//置空
		FD_ZERO(&set);
		FD_SET(sock, &set);
		// 两个参数的结构体，分别是秒和微秒
		timeval tm;
		tm.tv_sec = 0;
		tm.tv_usec = timeoutms * 1000;
		if (select(sock + 1, 0, &set, 0, &tm) <= 0) {
			printf("connect time or error!\n");
			// strerror(errno)将错误转化为字符串
			std::cout << "connect " << ip << " : " << port << " failed! ";
			return false;
		}
	}
	setBlock(true);
	std::cout << "connect " << ip << " : " << port << " success!\n ";
	return true;
}

bool XTCP::connectSocket(const char* ip, unsigned short port) {
	if (sock <= 0) {
		createSocket();
	}
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	saddr.sin_port = htons(port);
	//将字符串ip地址转化为网络地址
	saddr.sin_addr.s_addr = inet_addr(ip);

	if (connect(sock, (const sockaddr*)&saddr, sizeof(saddr)) != 0) {
		// strerror(errno)将错误转化为字符串
		std::cout << "connect " << ip << " : " << port << " failed! ";
		return false;
	}
	std::cout << "connect " << ip << " : " << port << " success!\n ";
	return true;
}

int XTCP::createSocket() {
	//创建socket，创建失败返回-1，AF_INET表示ipv4协议，SOCK_STREAM表示接受tcp/ip协议的数据
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sock == -1) {
		std::cout << "create socket failed" << std::endl;
	}
	return sock;
}

bool XTCP::bindListen(unsigned short port) {
	if (sock <= 0) {
		createSocket();
	}
	//绑定地址
	sockaddr_in saddr;
	saddr.sin_family = AF_INET;
	//大端字节序和小端字节序的问题，
	saddr.sin_port = htons(port);
	//0设置为绑定本机地址
	saddr.sin_addr.s_addr = htonl(0);

	//绑定地址
	if (bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0) {
		std::cout << "bind port " << port << " failed.\n";
		return false;
	}
	std::cout << "bind port " << port << " successful.\n";

	//监听客户端发送的信息
	//backlog=10表示缓冲大小
	listen(sock, 10);
	return true;
}

XTCP XTCP::acceptClient() {
	XTCP tcp;
	//每个连接就会生成一个client
	sockaddr_in caddr;
	socklen_t len = sizeof(caddr);
	//在accept之前会进行三次握手（由操作系统完成），accept只是获取了握手后的信息
	int client_sock = accept(sock, (sockaddr*)&caddr, &len);
	if (client_sock <= 0) {
		return tcp;
	}
	tcp.sock = client_sock;
	std::cout << "accept client " << client_sock << ".\n";
	char* ip = inet_ntoa(caddr.sin_addr);
	strcpy_s(tcp.ip, ip);
	tcp.port = ntohs(caddr.sin_port);
	std::cout << "client ip address " << tcp.ip << ".\n";
	std::cout << "client port " << tcp.port << ".\n";
	return tcp;
}


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

bool XTCP::setBlock(bool isBlock) {
	//默认为阻塞模式
	if (sock <= 0) {
		return false;
	}
	#ifdef WIN32
		unsigned long ul = 0;
		if (!isBlock) {
			ul = 1;
		}
		//ul=1就会立刻返回结果，反之，则不会立即返回，只有windows才有这个函数
		ioctlsocket(sock, FIONBIO, &ul);
	#else
		//fcntl操作文件描述符的函数，
		int flag=fcntl(sock, F_GETFL, 0);
		if (flag < 0) {
			return false;
		}
		if (isBlock) {
			flag = flag & ~O_NONBLOCK;
		}
		else {
			flag = flag | O_NONBLOCK;
		}
		if (fcntl(sock, F_SETFL, flag) != 0) {
			return false;
		}
	#endif // WIN32

	return true;
}

int XTCP::sendData(const char* buf, int sendsize) {
	//需要全部发送完全才能结束
	int sendedSize = 0;
	while (sendedSize!=sendsize) {
		//printf("--sock:%d--\n", sock);
		int len = send(sock, buf + sendedSize, sendsize - sendedSize, 0);
		if (len <= 0) {
			break;
		}
		sendedSize += len;
	}
	return sendedSize;
}

void XTCP::closeSocket() {
	if (sock <= 0) {
		return;
	}
	closesocket(sock);
}

XTCP::~XTCP() {

}

httpServer.cpp

#include"XTCP.h"
#include
#include
#include
#include
using namespace std;

class HTTPThread {
public:
	void main() {
		char buf[10000] = { 0 };
		//接收http客户端请求
		int recvLen = client.receiveData(buf, sizeof(buf) - 1);
		if (recvLen <= 0) {
			client.closeSocket();
			delete this;
			return;
		}
		printf("===========recv=============== \n%s========================\n", buf);
		
		//回应http请求
		string rmsg = "";
		rmsg = "HTTP/1.1 200 OK\r\n";
		rmsg += "Server: XHttp\r\n";
		rmsg += "Content-Type: text/html\r\n";
		rmsg += "Content-Length: ";
		rmsg += "10\r\n";
		rmsg += "\r\n";
		rmsg += "0123456789";
		int flag=client.sendData(rmsg.c_str(), rmsg.size());
		if (flag > 0) {
			cout << "=============send=====================" << endl;
			cout << rmsg << endl;
			cout << "======================================" << endl;
		}

		client.closeSocket();
		//while (true) {
		//	//recv和send都不能保证能够发送信息和收到信息成功
		//	char buf[1024] = { 0 };
		//	//接收客户端发送得请求，并将其内容存储在buf字符串中
		//	int reclen = client.receiveData(buf, sizeof(buf) - 1);
		//	if (reclen <= 0) {
		//		break;
		//	}
		//	buf[reclen] = '\0';
		//	if (strstr(buf, "quit") != NULL) {
		//		char re[] = "quit success!\n";
		//		//服务器向客户端发送数据
		//		client.sendData(re, strlen(re) + 1);
		//		break;
		//	}
		//	int sendlen = client.sendData("ok\n", 4);
		//	cout << "receive data: " << buf << endl;
		//}
		//client.closeSocket();
		delete this;
	}
	XTCP client;
};
int main(int argc, char* argv[])
{
	//获得端口号
	unsigned short port = 80;
	if (argc > 1) {
		port = atoi(argv[1]);
	}
	XTCP server;
	server.createSocket();
	server.bindListen(port);

	while (true) {
		//每个连接就会生成一个client
		XTCP client = server.acceptClient();
		HTTPThread* th = new HTTPThread();
		th->client = client;
		//启动多线程，第一个参数是函数地址，第二个为对象本身
		thread sth(&HTTPThread::main, th);
		//释放主线程中子线程的资源
		sth.detach();

	}
	//socket关闭
	server.closeSocket();

	return 0;
}

UDP协议

UDP：用户数据报协议，具有特性

• UDP提供无连接服务。
• UDP缺乏可靠性支持，应用程序必须实现：确认、超时、重传、流控等。
• UDP面向记录服务。

UDP的数据报格式：

Windows配置C++的UDP协议：
在VS中 项目属性 -> 连接器 -> 输入 -> 附加依赖项添加ws2_32.lib。

没有配置则会显示socket相关的函数没有找到。

UDP通信Windows版本

udpserver.cpp

#include
#include 

using namespace std;
int main(int argc,char* argv[])
{   
    unsigned short port = 8080;
    if (argc > 1)
    {
        port = atoi(argv[1]);
    }

    WSADATA ws;
    WSAStartup(MAKEWORD(2, 2), &ws);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock <= 0)
    {
        cout << "create socket failed!" << endl;
        return -1;
    }
    sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    saddr.sin_addr.s_addr = htonl(0);
    if (bind(sock, (sockaddr*)&saddr, sizeof(saddr)) != 0)
    {
        cout << "bind port " << port << " failed!" << endl;
        return -2;
    }

    cout << "bind port " << port << "success!" << endl;
    listen(sock, 10);
    sockaddr_in client;
    int len = sizeof(client);
    char buf[10240] = { 0 };
    int re = recvfrom(sock, buf, sizeof(buf), 0, (sockaddr*)&client, &len);
    if (re <= 0)
    {
        cout << "recefrom failed!" << endl;
        return -3;
    }
    buf[re] = '\0';
    cout << buf << endl;

    return 0;
}

udpclient.cpp

#include
#include 

using namespace std;
int main(int argc, char* argv[])
{
    unsigned short port = 8080;
    if (argc > 1)
    {
        port = atoi(argv[1]);
    }

    WSADATA ws;
    WSAStartup(MAKEWORD(2, 2), &ws);

    int sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock <= 0)
    {
        cout << "create socket failed!" << endl;
        return -1;
    }
    sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");       //htonl(0);

    int len=sendto(sock, "12345", 6, 0,(sockaddr*)&saddr, sizeof(saddr));
    cout << "sendto size is " << len << endl;
    return 0;
}

UDP客户端和服务器端通信成功！！！

UDP广播

广播所用的广播地址为255.255.255.255。

本地广播信息是不会被路由器转发。