c++ socket实现http及websocket通信

最新推荐文章于 2024-06-03 16:05:41 发布
最新推荐文章于 2024-06-03 16:05:41 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： C++ 文章标签： c++ http websocket
原文链接：https://blog.csdn.net/qq_24172609/article/details/106086228
版权

       最近由于工程需要，需要在本地实现网页与本地程序实时通信，但网页又不能直接通过socket与本地程序通信，只能支持相关的web协议，经过考虑我选择了http与websocket协议，这样的话就要实现本地服务器，网上有很多开源库websocketpp之类的开源库，但是我觉得很麻烦，不够轻量化，配置也是麻烦的很。我选择了自己实现一个，我的开发环境为win10  VS2017。
       首先编写套接字通信程序如下：
（1）main.cpp

#include  <iostream>

#include <thread>
#include <WinSock2.h>
#include <Ws2tcpip.h>
#pragma comment(lib,"ws2_32.lib")
#include "webServer.h"
 
void main() {

	WSADATA wsd;
	WSAStartup(MAKEWORD(2, 2), &wsd);  //初始化套接字
	SOCKET socketServer = socket(AF_INET,SOCK_STREAM,0);  //创建监听套接字
 
	sockaddr_in serverAddr;   //设置监听端口ip、端口、协议等
	serverAddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr.S_un.S_addr);  //将点分十进制转为二进制整数
	serverAddr.sin_port = htons(80);
 
	int bindRe = bind(socketServer, (sockaddr*)&serverAddr, sizeof(serverAddr));   //绑定监听套接字与要监听的ip端口
 
 
	listen(socketServer, 10);   //开始监听套接字,设置等待接受队列为10
 
	sockaddr_in clientAddr;   //用于存储客户端信息
	int len = sizeof(clientAddr);
	
	while (true)
	{
		SOCKET communicationServer = accept(socketServer, (sockaddr*)&clientAddr, &len);  //监听到新的连接请求信息后创建通信套接字
 
		//char clientIp[INET_ADDRSTRLEN];  //ipv4
		//inet_ntop(AF_INET, &clientAddr.sin_addr, clientIp, sizeof(clientIp));   //将二进制整数转为点分十进制
 
		std::thread httpThread(webServer, communicationServer);
		httpThread.detach();
	}
 
	closesocket(socketServer);
	WSACleanup();
	system("pause");
}

(2)webServer.h
 

#include <iostream>
#include <thread>
#include <WinSock2.h>
#include <Ws2tcpip.h>
#pragma comment(lib,"ws2_32.lib")
#include "webServer.h"
 
void main() {
 
	WSADATA wsd;
	WSAStartup(MAKEWORD(2, 2), &wsd);  //初始化套接字
	SOCKET socketServer = socket(AF_INET,SOCK_STREAM,0);  //创建监听套接字
 
	sockaddr_in serverAddr;   //设置监听端口ip、端口、协议等
	serverAddr.sin_family = AF_INET;
	inet_pton(AF_INET, "127.0.0.1", &serverAddr.sin_addr.S_un.S_addr);  //将点分十进制转为二进制整数
	serverAddr.sin_port = htons(80);
 
	int bindRe = bind(socketServer, (sockaddr*)&serverAddr, sizeof(serverAddr));   //绑定监听套接字与要监听的ip端口
 
 
	listen(socketServer, 10);   //开始监听套接字,设置等待接受队列为10
 
	sockaddr_in clientAddr;   //用于存储客户端信息
	int len = sizeof(clientAddr);
	
	while (true)
	{
		SOCKET communicationServer = accept(socketServer, (sockaddr*)&clientAddr, &len);  //监听到新的连接请求信息后创建通信套接字
 
		//char clientIp[INET_ADDRSTRLEN];  //ipv4
		//inet_ntop(AF_INET, &clientAddr.sin_addr, clientIp, sizeof(clientIp));   //将二进制整数转为点分十进制
 
		std::thread httpThread(webServer, communicationServer);
		httpThread.detach();
	}
 
	closesocket(socketServer);
	WSACleanup();
	system("pause");
}

(3)webServer.cpp
 

#include "webServer.h"
 
 
void webServer(SOCKET communicationServer)
{
	std::cout << "开启一个web服务线程！"<< "线程id！" << std::this_thread::get_id() << std::endl;
 
	char recvbuf[1024*64];  //64kb容量
	while (true)
	{
		int clientSocketStatus = recv(communicationServer, recvbuf, sizeof(recvbuf), 0);
 
		if (clientSocketStatus == 0) {  //客户端关闭了通信套接字
			std::cout << "客户端关闭了通信套接字!" << std::endl;
			closesocket(communicationServer);   //关闭服务器端套接字
			break;
		}
		else if (clientSocketStatus > 0)   //clientSocketStatus此时为接收到的字节数
		{
			recvbuf[clientSocketStatus] = '\0';
			requestHttp reqHttp = httpAnalysis(recvbuf);
			if (reqHttp.version.compare("HTTP/1.1") == 0 && reqHttp.Connection.find("Upgrade") == std::string::npos)  //协议版本为HTTP/1.1且未要求协议升级，普通http请求
			{
				if (httpServer(communicationServer, reqHttp) == 0) {
					closesocket(communicationServer);
					break;
				};
			}
			else if (reqHttp.version.compare("HTTP/1.1") == 0 && reqHttp.Connection.find("Upgrade") != std::string::npos && reqHttp.Upgrade.find("websocket") != std::string::npos) {
				if (webscoketServer(communicationServer, reqHttp) == 0) {
					closesocket(communicationServer);
					break;
				}
			}
			else{
				// do not 暂不支持其他协议
			}
		}
		else
		{
			std::cout << "接收数据失败！,接收状态：" << clientSocketStatus << std::endl;
			closesocket(communicationServer);   //关闭服务器端套接字
			break;
		}
	}
	
	std::cout << "服务器进程结束！" << std::endl;
}
 
int httpServer(SOCKET communicationServer, requestHttp reqHttp)
{
	std::cout << "http服务！" << std::endl;
 
	std::string response;
	response.append("HTTP/1.1 200 OK\r\n");
	//response.append("Content-Type: application/json;charset=UTF-8\r\n");
	response.append("Content-Type: text/html;charset=ANSI\r\n");      //c++标准库中的string默认是本地码，即ANSI编码格式
	response.append("Server: wxj233\r\n");
	response.append("Connection: close\r\n");
	response.append("\r\n");
 
	response.append("我是内容哈哈哈哈哈！");
 
	int sendStatus = send(communicationServer, response.c_str(), response.length(), 0);
	return 0;
}
 
int webscoketServer(SOCKET communicationServer, requestHttp reqHttp)
{
	std::cout << "websocket服务！" << std::endl;
 
	std::string SecWebSocketAccept = BASE64code(SHA1code(reqHttp.SecWebSocketKey + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"));
	std::string response;
	response.append("HTTP/1.1 101 Switching Protocols\r\n");
	response.append("Upgrade: websocket\r\n");
	response.append("Connection: Upgrade\r\n");
	response.append("Sec-WebSocket-Accept: " +SecWebSocketAccept + "\r\n");
 
	int sendStatus = send(communicationServer, response.c_str(), response.length(), 0);
 
	char recvbuf[1024 * 64];  //64kb容量
	while (true)
	{
		int clientSocketStatus = recv(communicationServer, recvbuf, sizeof(recvbuf), 0);  //阻塞模式无请求不会继续执行
		if (clientSocketStatus == 0) {  //客户端关闭了通信套接字
			return 0;
		}
		else if(clientSocketStatus > 0) {
			recvbuf[clientSocketStatus] = '\0';
			wsProtocol wsFrame = websocketAnalysis(recvbuf);
			if (wsFrame.frameType == 0x1) {
				std::cout << "收到数据:" << wsFrame.Payload <<"数据长度："<< (int)wsFrame.PayloadLen << std::endl;
 
				std::string sendstr = "aaa";
 
				char* sendTr = websocketDataSend((char*)sendstr.c_str());
				int sendStatus = send(communicationServer, sendTr, 2 + sendstr.size(), 0);
 
				delete[] sendTr;
			}
			else if(wsFrame.frameType == 0x9){
				std::cout << "收到ping" << std::endl;
				char* pong = pongSend();
				int sendStatus = send(communicationServer, pong, 2, 0);
 
 
			}
			else if (wsFrame.frameType == 0x8) {
				std::cout << "关闭套接字" << std::endl;
				return 0;
			}
		}
		else
		{
			return 0;
		}
	}
}
 
/* http协议解析 */
requestHttp httpAnalysis(std::string requestStr)
{
	requestHttp reqHttp;
	std::vector<std::string> httpStrs = split(requestStr, "\r\n");
	for (size_t i = 0; i < httpStrs.size(); i++)
	{
		if (i == 0) {
			//首行内容
			std::vector<std::string> requestTop = split(httpStrs.at(i), " ");
			reqHttp.Method = requestTop.at(0);
			reqHttp.URL = requestTop.at(1);
			reqHttp.version = requestTop.at(2);
 
			if (reqHttp.URL.find("?") != std::string::npos)
			{
				std::string content = split(reqHttp.URL, "?").at(1);
				std::vector<std::string> paramStrs = split(content, "&");
				for (std::vector<std::string>::iterator iter = paramStrs.begin(); iter != paramStrs.end(); iter++)
				{
					std::vector<std::string> paramStr = split(*iter, "=");
					reqHttp.param.insert(std::pair<std::string, std::string>(paramStr.at(0), paramStr.at(1)));
				}
			}
		}
		else if (i >0 && i < httpStrs.size() - 1) {
			//头部内容
			std::vector<std::string> requestHead = split(httpStrs.at(i), ": ");
			if (httpStrs.at(i).find("Host") != std::string::npos) {
				reqHttp.Host = requestHead.at(1);
			}
			else if (httpStrs.at(i).find("Connection") != std::string::npos) {
				reqHttp.Connection = requestHead.at(1);
			}
			else if (httpStrs.at(i).find("Upgrade") != std::string::npos) {
				reqHttp.Upgrade = requestHead.at(1);
			}
			else if (httpStrs.at(i).find("Sec-WebSocket-Key") != std::string::npos){
				reqHttp.SecWebSocketKey = requestHead.at(1);
			}
		}
		else{
			//std::cout << "请求主体："<< httpStrs.at(i) <<std::endl;
		}
	}
	return reqHttp;
}
 
wsProtocol websocketAnalysis(char* frame)
{
	wsProtocol wsFrame;
 
	int pos = 0;
	wsFrame.msgType = (uint8_t)((frame[pos] >> 7) & 0x1);
	wsFrame.frameType = (uint8_t)(frame[pos] & 0xf);
	pos++;
	wsFrame.Mask = (uint8_t)((frame[pos] >> 7) & 0x1);
	wsFrame.PayloadLen = (uint8_t)(frame[pos] & 0x7f);
	pos++;
 
	if (wsFrame.frameType == 0x1) {
		if (wsFrame.PayloadLen == 126) {
			memcpy(&wsFrame.PayloadLen, frame + pos, 2);
			wsFrame.PayloadLen = ntohs(wsFrame.PayloadLen);
			pos += 2;
		}
		else if (wsFrame.PayloadLen == 127) {
			memcpy(&wsFrame.PayloadLen, frame + pos, 8);
			wsFrame.PayloadLen = ntohl(wsFrame.PayloadLen);
			pos += 8;
		}
		wsFrame.Payload = new char[wsFrame.PayloadLen + 1];
 
		if (wsFrame.Mask == 1) {
			memcpy(wsFrame.Maskingkey, frame + pos, 4);
			pos += 4;
 
			for (int i = 0; i < wsFrame.PayloadLen; i++) {
				int j = i % 4;
				wsFrame.Payload[i] = frame[pos + i] ^ wsFrame.Maskingkey[j];
			}
		}
		else {
			memcpy(wsFrame.Payload, frame + pos, wsFrame.PayloadLen);
		}
		wsFrame.Payload[wsFrame.PayloadLen] = '\0';
	}
	
 
	return wsFrame;
}
 
char* websocketDataSend(char * sendStr)
{
	int len = strlen(sendStr)+2;
	char* header = new char[len];     //报文
	header[0] = 0x81;
	header[1] = strlen(sendStr);
	memcpy(header+2, sendStr, strlen(sendStr));
	return header;
}
 
char* pongSend()
{
	char header[2];     //报文头
	header[0] = 0x8A;
	header[1] = 0;
 
	return header;
}

(4)stringUnit.h
 

#pragma once
#include <vector>
#include "cryptopp/cryptlib.h"
#include "cryptopp/sha.h"
#include "cryptopp/base64.h"
#include "cryptopp/filters.h"
#include <Windows.h>
 
/*
 * 分割字符串
 * @param str 待分割字符串
 * @param splitStr 分割的字符
 * @return 分割后的字符串数组
 */
std::vector<std::string> split(std::string str, std::string splitStr);
 
/*
 * SHA1加密
 * @param str 被加密的字符串 
 * @return 加密后的字符串
 */
std::string SHA1code(std::string str);
 
/*
* base64加密
* @param str 被加密的字符串
* @return 加密后的字符串
*/
std::string BASE64code(std::string str);

(5)stringUnit.cpp
 

#include "stringUnit.h"
 
std::vector<std::string> split(std::string str, std::string splitStr)
{
	std::vector<std::string> stringVector;
 
	int index1 = 0;
	int index2 = 0;
	int size = splitStr.length();
	while (true)
	{
		index2 = str.find(splitStr, index1);
 
		if (index2 != std::string::npos) {
			std::string temp = str.substr(index1, index2-index1);
				stringVector.push_back(temp);
		}
		else{
			std::string temp = str.substr(index1, str.length() - index1);
				stringVector.push_back(temp);
			break;
		}
 
		index1 = index2 + size;
	}
	return stringVector;
}
 
std::string SHA1code(std::string str)
{
	std::string distStr;
	CryptoPP::SHA1 hash;
	CryptoPP::StringSource(str, true, new CryptoPP::HashFilter(hash, new CryptoPP::StringSink(distStr)));
	return distStr;
}
 
std::string BASE64code(std::string str)
{
	std::string encoded;
 
	CryptoPP::StringSource ss(str, true,
		new CryptoPP::Base64Encoder(
			new CryptoPP::StringSink(encoded)
		) // Base64Encoder
	);
	return encoded;
}

相关链接：HTTP Headers

我的socket为阻塞模式，该服务器支持多线程，支持中文；支持http及websocket方法其他方法读者可以自行添加。其中websocket协议涉及SHA1加密算法和base64编码，我直接使用了开源库cryptopp，这个开源库里面的算法挺多的。

用Socket写的HTTP类，商业级C++源码。
rar 5星 超过95%的资源 16KB
下载

期间我也遇到了不少问题，因为小编不是一个c++大佬，怎么引用lib也搞不清楚，所以遇到了不少麻烦，关于cryptopp算法库，首先需要自行下载，下载链接为：https://www.cryptopp.com/  同时里面有很多算法说明 。下载下来之后会有4个工程，如下图：

可以编译动态链接库、静态链接库，我编译了cryplib，注意编译版本和你自己的要引用该库的项目应该一致我自己的项目是debug 64，所以我编译的也是debug 64，另外注意运行库的选择也需要和你自己的项目一直：

静态库的引用将所有的.h文件和生成的lib文件添加至项目中即可。后续我会上传源码可可调用接口版本。
html测试的代码如下：

<!DOCTYPE html>
<html>
<head> 
<meta charset="utf-8"> 
<title>websocketTest</title> 
</head>
<body>
<div id="test">websocketTest</div>
 
<script>
if ("WebSocket" in window){
	            var ws = new WebSocket("ws://127.0.0.1:80/");
			ws.onopen = function()
	            {
			console.log("建立连接！！！！！");
 
let i = 0;
ws.send(i);
			setInterval(function(){
i++;
				ws.send(i);
			}, 1000);
 
	            };
	            ws.onmessage = function (evt) 
	            {
	               var received_msg = evt.data;
	               if(received_msg != ""){
			console.log("收到扫描数据！"+received_msg);
	            	   //window.location.href=received_msg;
	               }
	              
	            };
			
		}else{
			alert("浏览器不支持websocket，将导致二维码扫描功能无法使用！");
		}
</script>
 
</body>
</html>

运行效果图。

 

相关链接：https://www.w3cschool.cn/websocket_protocol/wav8jozt.html   websocket协议

WebSocket 协议

龙行天下01
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ WebSocket Demo
09-10
C++ 写的一个WebSocket Demo程序，学习WebSocket的同学可以作为参考
基于C++ socket编程实现的websocket服务器
12-28
利用C++ SOCKET编程，自我实现的一个websocket服务器，能够比较好的移植，没有使用开源库
嵌入式开发—C++使用websocketpp 创建WebSocket服务器，并向浏览器发送图片
最新发布
weixin_46999174的博客
06-03 1224
嵌入式开发—C++使用websocketpp 创建WebSocket服务器，并向浏览器发送图片 简单实现demo
C++ 实现WebSocket 服务器
12-07
利用C++实现了websocket server, 使用libuv作为实现tcp的基础，另外使用gbase作为工具
C++写一个http服务器/web服务器
热门推荐
dxgzg的博客
02-02 26万+
目录开篇废话正文 开篇废话 其实这篇文章一直想写，苦于没有时间，想一气呵成写完，在离回家前一天晚上，在上海的小宾馆里面异常兴奋，写一下如何用C++搭建一个简易的http服务器。 我相信大部分人都希望渴望一个自己的网站（哪怕在破在破也是自己做的），我当初是就是这么渴望的，记得那是2020年的8月，我查阅的各种资料终于学会了socket，于是迫不及待的写了一个聊天程序，一直在研究如何端口映射。那时候还很傻很天真，来了一个连接就开一根线程，离开就销毁这根线程，那会也知道线程创建和销毁的开销很大，但是一直没有想到其
HTTP协议详解 - 通过C++实现HTTP服务剖析HTTP协议
new9232的博客
12-31 6712
C/C++程序员一般很少会接触到HTTP服务端的东西，所以对HTTP的理解一般停留在理论。本文章实现通过C++实现了一个http服务，可以通过代码对HTTP协议有更深的理解，并且通过抓包工具对HTTP协议进行更为详细的分析。HTTP(hypertext transport protocol 超文本传输协议）：一种无状态的，以请求/应答方式运行的协议，它使用可扩展的语义和自描述消息格式，与基于网络的超文本信息系统灵活的互动。
C++下轻量化websocket客户端库——easywsclient的使用
a486259的博客
06-10 5253
easywsclient项目核心代码为"easywsclient.hpp"和"easywsclient.cpp"，仅需将这两个文件拷贝到自己项目下即可使用WebSocket客户端通信了。其关键接口函数有以下4个，send函数用于发送文本信息，sendBinary函数用于发送二进制信息，dispatch用于设置信息接收处理的函数ws->poll();
实现c++轻量级别websocket协议客户端
qianbo042311的博客
05-07 3627
c++ 实现websocket 客户端 协议，只包含一个头文件
C++实现websocket协议通讯
hnzwx888的专栏
11-13 1万+
一、websocket协议原理 （一）websocket 协议的官方文档 ： https://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-13#section-5 Linux 下c语言 实现 websocket  包含客户端 和服务器测试代码 ： http://blog.csdn.net/sguniver_22/arti...
c++websocket
weixin_39291964的博客
03-06 893
Boost.Beast库：这是一个C++头文件库，用于构建HTTP和WebSocket用户端和服务器端应用程序。Boost.Beast库提供了一套完整的API，可以用来建立和管理WebSocket连接，发送和接收消息。它是一个头文件库，不需要预编译。WebSocket++库提供了一套完整的API，可以用来建立和管理WebSocket连接，发送和接收消息。在C++中，可以使用各种库来实现WebSocket通信，其中最常用的是Boost.Beast库和WebSocket++库。
服务端使用C++实现非阻塞的websocket
秋雨 De Blog
11-22 1594
客户端有socket，但网页端有类似socket的websocekt，那么webscoekt到底是如何实现的，今天我们来研究一下。
基于C++ SOCKET编程的WebSocket服务器(linux)
05-19
在本项目中，我们将探讨如何在Linux环境下，利用C++的SOCKET编程技术来实现一个WebSocket服务器，而不依赖任何开源库。 首先，我们需要理解C++中的SOCKET编程基础。在C++中，SOCKET是网络编程的基本接口，它提供了...
websocket通信，python，c++实现
01-11
总的来说，WebSocket为实时通信提供了一种高效、低延迟的解决方案，Python和C++都有强大的库支持实现WebSocket服务器和客户端。理解其工作原理和使用这些库可以帮助开发者构建出高性能的实时应用。
使用QT进行c++实现socket文件传输
05-12
使用QT进行c++实现socket文件传输，应用编写语言使用的是c++，采用qt5.12.2编写，可以实现客户端和服务器进行通信连接，客户端上传文件至服务器端，可以用做计算机网络课程设计，项目开发基础示例，学习用途。
基于C++ SOCKET编程的WebSocket服务器(window)
05-19
本项目是基于C++的SOCKET编程实现的WebSocket服务器，特别适合于Windows平台上的开发和学习。 在C++中，SOCKET编程是通过Windows Socket API（Winsock）来实现的，这是一个低级别的网络编程接口。在创建WebSocket...
websocket++ （c++环境）
qq_39690016的博客
03-01 4229
一、简介 websocket官方网址：http://websocket.org/ websocket++官方网址：https://www.zaphoyd.com/websocketpp websocket++使用手册：https://www.zaphoyd.com/websocketpp/manual/
C++ libwebsockets搭建WebSocket服务端及Http客户端、服务端
fantasysolo的博客
03-30 2万+
websocket和webrtc笔记欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导...
C++实现Windows下服务端与客户端Socket通信（一）
abcdefz的博客
03-28 7525
C++实现Windows下服务端与客户端Socket通信，实现Socket传输结构体、类对象数据，以及应用Protobuf数据序列化。Socket+Protobuf+MFC.
vue和c++使用websocket通信代码
05-18
在Vue.js中，可以使用Vue-socket.io插件来实现WebSocket通信。首先，使用npm安装该插件： ``` npm install vue-socket.io ``` 然后在Vue组件中引入并使用该插件： ```javascript import VueSocketIO from 'vue-...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值