c++ socket实现http及websocket通信

最新推荐文章于 2024-07-25 09:47:19 发布
最新推荐文章于 2024-07-25 09:47:19 发布
阅读量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
    评论
专栏目录
Socket 与 Websocket通信交互 Linux/C++/epoll网络模型
07-03 912
Socket 与 Websocket通信交互 Linux/C++/epoll网络模型 简要：Websocket是基于http协议实现的，而Socket是基于TCP/IP协议实现的。所以要想使Socket与Websocket进行数据交互，就必须在网络层手动解析http协议，大致分为两个步骤：握手连接 拆分协议帧。本实例使用Linux网络库，C++开发语言，epoll网络模型(不熟悉的童鞋可以百度，两者网络数据通信和epoll网络模型没有联系) 示例代码： 1.main...
基于C++ socket编程实现的websocket服务器
12-28
6. **帧处理**：WebSocket通信的核心在于帧，每个数据包由帧组成，包括头部和数据部分。服务器需要解析接收到的帧，并生成发送给客户端的帧。 7. **数据传输**：使用`send()`和`recv()`函数进行数据的发送和接收，...
发现WebSocket的精华：轻量级C++库，构建高效实时应用
gitblog_00010的博客
06-14 399
发现WebSocket的精华：轻量级C++库，构建高效实时应用 项目地址:https://gitcode.com/MengRao/websocket 在当今快速发展的网络时代，即时通讯和数据交换的需求日益增长。对于开发者来说，选择一个高效、简洁的Websocket库成为连接前端与后端的关键。今天，我们为您推荐一款宝藏开源项目——C++ WebSocket库，它是一个专为Linux设计的单头文件库，...
C++与JS实现WebSocket通信（C++服务端JS客户端）
分享式获得也是一种学习的态度
09-14 1042
java实现websocket（java客户端java服务端）js实现websocket（html客户端js服务端）c++实现websocket（c++服务端c++客户端）
C/C++ 创建Socket实现双工通信
CSDN
06-09 8596
Socket通信是一种用于在计算机网络中进行进程间通信的方法。它提供了一种简单而强大的通信机制，使得运行在不同计算机上的进程可以相互传递数据。
服务端使用C++实现非阻塞的websocket
秋雨 De Blog
11-22 1603
客户端有socket，但网页端有类似socket的websocekt，那么webscoekt到底是如何实现的，今天我们来研究一下。
C++实现简单Socket通信
qq_39295095的博客
03-31 3524
参考学习：C++:实现socket通信（TCP/IP）实例 1. 一对一 server.cpp // server.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 /* 服务端：建立socket，申明自身port和IP，并绑定到socket，使用listen监听， 然后不断用accept查看是否有连接。如果有，捕获socket，并通过recv获取消息内容， 通信完成后调用closeSocket关闭accept捕获到的socket。如果不需要等待任何客户端连接， 直接用closeSo
C++实现websocket单server单client全双工通信(基于boost！！！)
gls_nuaa的博客
07-02 1502
C++实现websocket单server单client全双工通信(基于boost！！！)
C++实现WebSocket通信（服务端和客户端）
分享式获得也是一种学习的态度
09-13 4337
这里单纯是个人总结，如需更官方更准确的websocket介绍可百度websocket是一种即时通讯协议，你可以把他想像成http的变种http是一次请求一次回应，而websocket是一次请求建立之后就可以持续互通业务需求诸如持续实时的消息收发场景时使用因为并没有C++语言基础，所以只是参考网上的一些文章来整合代码实现自己需要的功能如果你和我一样是没有语言基础但有需要使用这个C++的websocket通信功能，那就需要安装C++的环境才能跑这个代码C++环境配置（下载安装MinGW）
探索http原理，使用C++基于socket自实现http
lkun2002的博客
09-07 2636
基于socket自实现http
C++下轻量化websocket客户端库——easywsclient的使用
a486259的博客
06-10 5369
easywsclient项目核心代码为"easywsclient.hpp"和"easywsclient.cpp"，仅需将这两个文件拷贝到自己项目下即可使用WebSocket客户端通信了。其关键接口函数有以下4个，send函数用于发送文本信息，sendBinary函数用于发送二进制信息，dispatch用于设置信息接收处理的函数ws->poll();
基于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...
【C++】C++中的find方法介绍
最新发布
qq_35902025的博客
07-25 407
find 函数是 std::string 类中非常有用的成员函数之一，它提供了灵活的方式来查找子字符串或字符。使用 npos 可以检查查找操作是否成功。
背单词工具(C++)
zeyeqianli的博客
07-24 3418
【代码】背单词工具(C++)
C：图案打印
2401_85010100的博客
07-23 954
空心正方形，空心三角形，X形，沙漏图案打印
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、付费专栏及课程。

余额充值