基于开源的libwebsocket实现websocket服务端和客户端

已于 2024-07-17 17:05:53 修改
阅读量952 收藏 16
点赞数 25
文章标签： 开源 websocket 网络协议
于 2024-07-17 16:55:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46543392/article/details/140497707
版权

最近在做一个项目，项目中需要服务端后端和web端进行websocket通信，需要后端给web端不断地发送数据，之前程序已经写好，功能测试没有问题，代码如下：

#include "web_socket_server.h" 
extern std::mutex radar_obj_mutex_;
extern std::map<std::string,std::string> g_map_obj_list_;
#define SERVICE_RADARWEBSOCKET	"radarwebsocket"
struct per_session_data__http {
	int fd;
};
#define MAX_PAYLOAD_SIZE  10 * 1024
struct session_data {
    int msg_count;
    unsigned char buf[LWS_PRE + MAX_PAYLOAD_SIZE];
    int len;
};
static int callback_http(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len)
{
    return 0;
}
int CallBackFunc(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len)
{
    // char message[] = "Hello, client!";
    int mRet = 0;
    //for write msg to client
	InfoItem_t	info;
    uint64_t delSessionID = 0;
    switch (reason) {
        case LWS_CALLBACK_CLIENT_ESTABLISHED:
            std::cout << "client connected to server" << std::endl;
            break;
            
        case LWS_CALLBACK_CLOSED:
		    break;
		    
        case LWS_CALLBACK_SERVER_WRITEABLE:
            if(!g_map_obj_list_.empty())
            {
				size_t sendLen = sizeof(RADAR_OBJ_INFO);
				sendLen = 1024 * 16;
				if (recvBuf == NULL)
				{
					HKLOG_write(HKLOG_LEVEL_ERROR, "malloc count*****************!");
					recvBuf = (unsigned char *)malloc(sendLen * sizeof(char));
				}
				if (!recvBuf)
				{   free(recvBuf);
					break;
				}
				memset(recvBuf,0,sendLen);
				//memcpy(recvBuf,&package_head,sizeof(package_head));
				//memcpy(recvBuf + sizeof(package_head),pDataBuffer,16);
				std::lock_guard<std::mutex> lock(radar_obj_mutex_);
				auto it = g_map_obj_list_.begin();
				std::string key = it->first;
				std::string strBody = it->second;
				g_map_obj_list_.erase(it);
				//char* buffer = reinterpret_cast<char*>(&strBody);
				//memcpy(recvBuf + sizeof(package_head),strBody.c_str(),strBody.length());
				//memcpy(recvBuf, strBody.c_str(), sendLen); // 使用memcpy进行复制
				//recvBuf[sendLen] = '\0'; // 添加结尾的空字符
				memcpy(recvBuf, strBody.c_str(), std::min((int)sendLen, (int)strBody.length())); // 使用memcpy进行复制
                recvBuf[std::min((int)sendLen, (int)strBody.length())] = '\0'; // 添加结尾的空字符
				//strcpy(recvBuf, (unsigned char*)strBody.c_str());
				// HKLOG_write(HKLOG_LEVEL_INFO, "sendLen %d,bodylen %d!",sendLen,strBody.length());
				mRet = lws_write(wsi, recvBuf, strlen(strBody.c_str()), LWS_WRITE_TEXT);
				if (mRet < 0)
				{
					HKLOG_write(HKLOG_LEVEL_ERROR, " LWS_CALLBACK_SERVER_WRITEABLE error %d!",mRet);
				}
            }
            break;
        case LWS_CALLBACK_CLIENT_RECEIVE:
            // 处理接收到的数据
            lwsl_notice( "LWS_CALLBACK_CLIENT_RECEIVE\n" );
            break;
        default:
            break;
    }

    return 0;
}

static struct lws_protocols protocols[] = {
	/* first protocol must always be HTTP handler */
	
	{
	
		"http-only",		/* name */
		callback_http,		/* callback */
		sizeof (struct per_session_data__http),	/* per_session_data_size */
		0,			/* max frame size / rx buffer */
	},
	{
		SERVICE_RADARWEBSOCKET,
		CallBackFunc,
		sizeof (struct session_data),	/* per_session_data_size */
		0,
	},
	
	{ NULL, NULL, 0, 0 } /* terminator */
};

void websocketProc()
{

	prctl(PR_SET_NAME, "websocketProc");
	struct lws_context_creation_info info;
	memset(&info, 0, sizeof(lws_context_creation_info));
	info.protocols = protocols;
	info.gid = -1;
	info.uid = -1;
	info.port = 8081;	
	//设置websocket的keepalive参数
	//info.ka_time = 10;				// 10s
	//info.ka_probes = 10;		
	//info.ka_interval = 3;			// 3次
	struct lws_context *pContext = lws_create_context(&info);
	if (pContext == NULL) 
	{
        HKLOG_write(HKLOG_LEVEL_ERROR, "libwebsocket init failed!");
		return;
	}

    HKLOG_write(HKLOG_LEVEL_INFO, "libwebsocket create finish %p\n!",pContext);

	while (true)
	{
        lws_service(pContext, 10); // 10毫秒的服务循环
        // 向客户端发送消息
        lws_callback_on_writable_all_protocol(pContext, &protocols[1]);
	}

    HKLOG_write(HKLOG_LEVEL_INFO, "libwebsocket destroy %p\n!",pContext);
	lws_context_destroy(pContext);

	return;
}

但是当web界面刷新的时候，会在 lws_service处崩溃，怀疑是在调用 lws_callback_on_writable_all_protocol(pContext, &protocols[1]);的时候没有连接的客户端有效性做校验，后来代码对连接的客户端进行了sessionid的管理。
如下图：

int CWebSocketProtocol::callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len)
{
	int m = 0;
	bool bRet = false;
	Json::Reader reader;
	Json::Value value = Json::Value::null;

	//for write msg to client
	InfoItem_t	info;
	std::shared_ptr<MsgItem_t> item(nullptr);
	std::string str;
	std::string send;
	Json::FastWriter writer;
	char *pBuffer = NULL;
	//uint clienttype = 0;
	//char szUserName[32] = {0};
	//char szPassword[32] = {0};
	//buffer for close
	char closebuffer[LWS_SEND_BUFFER_PRE_PADDING + LWS_SEND_BUFFER_POST_PADDING] = {0};

	//for get the sessionID from client
	uint64_t sessionID = 0;
	uint64_t delSessionID = 0;
	//for fragment
	struct per_session_data *psd = (struct per_session_data *)user;
	size_t ran = 0;
	int write_mode = LWS_WRITE_TEXT;
	//struct lws *last_wsi = nullptr;

	switch (reason) {

	case LWS_CALLBACK_ESTABLISHED:
		info.session = 0;
		info.timestamp = getCurElapseMSecLinux();
		psd->left_message = 0;
		psd->total_message = 0;
		psd->pBuffer = nullptr;
		psd->state = FRAGSTATE_START_MESSAGE;
		psd->last_flag = 0;

		if(!m_pWebSockSessionManager->checkIfArriveMaxSession())
		{
			printf("%s : %p LWS_CALLBACK_ESTABLISHED\n", m_ProtocolName.c_str(), wsi);
			AddClient2Queue(wsi, info);
		}
		else
		{
			printf("%s: %p Reach Max Session, LWS_WRITE_CLOSE\n", m_ProtocolName.c_str(), wsi);
            lws_close_reason(wsi,LWS_CLOSE_STATUS_INVALID_PAYLOAD, (unsigned char*)closebuffer, 0);
		}
		break;

	case LWS_CALLBACK_CLOSED:
		printf("%s : %p LWS_WRITE_CLOSE\n", m_ProtocolName.c_str(), wsi);
		if(psd->pBuffer) {
			delete[] psd->pBuffer;
			psd->pBuffer = nullptr;
		}
		delSessionID = RemoveClientFromQueue(wsi);
		RemoveWebClientFromProtocol(wsi);
		m_pWebSockSessionManager->deleteSessionById(delSessionID);
		break;

	case LWS_CALLBACK_SERVER_WRITEABLE:
		break;
	case LWS_CALLBACK_RECEIVE:
		sessionID = 0;
		bRet = false;
		str.assign((const char *)in, len);
		printf("%s : %p %s, LWS_CALLBACK_RECEIVE\n", m_ProtocolName.c_str(), wsi, str.c_str());

		/*{
			"method" : { "service" : "Subscribe", "protocol" : "radarwebsocket" }
		 }*/

		if(reader.parse(str, value)) {
			// 
			if (value.isMember("method") && value["method"].isMember("service") && value["method"]["service"].isString()) {

				std::string method = value["method"]["service"].asString();
			
				if("Subscribe" == method && value["method"]["protocol"].isString() && m_ProtocolName == value["method"]["protocol"].asString()) 
				{	
					if (1)//verifyUser(userName, passWordDigestBase, nonce,created))
					{
						sessionID = m_pWebSockSessionManager->getSessionIdBysessionFd(lws_get_socket_fd(wsi));
						if(0 == sessionID)
						{
							sessionID = m_pWebSockSessionManager->createNewSession(lws_get_socket_fd(wsi));
							printf("new sessionId:%llu\n",(unsigned long long)sessionID);
						}
						else
						{
							printf("sdk websocket had sessionId:%llu\n",(unsigned long long)sessionID);
						}
						bRet = true;
					}
					if (sessionID != 0)
					{
						bRet = parseProtocol(value, wsi);
						value["session"] = (Json::UInt64)sessionID;
					}
				}
			}
		}

		if(!bRet) {
            lws_close_reason(wsi,LWS_CLOSE_STATUS_INVALID_PAYLOAD, (unsigned char*)closebuffer, 0);
			RemoveClientFromQueue(wsi);
			RemoveWebClientFromProtocol(wsi);
			m_pWebSockSessionManager->deleteSessionById(sessionID);
			printf("%s : %p LWS_WRITE_CLOSE\n", m_ProtocolName.c_str(), wsi);
		} 
		else 
		{
			SetClientSessionID(wsi, sessionID, WS_CLIENT_TYPE_SDK);
			printf("%s : %p client new in\n",m_ProtocolName.c_str(), wsi);
		}
		//here you can receive data from client
		break;
	/*
	 * this just demonstrates how to use the protocol filter. If you won't
	 * study and reject connections based on header content, you don't need
	 * to handle this callback
	 */
	case LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION:
		dump_handshake_info(wsi);
		/* you could return non-zero here and kill the connection */
		break;

	default:
		break;
	}

	return 0;
}

实现的客户端的代码如下：

#include "libwebsockets.h"
#include <signal.h>
#include "json/json.h"

using namespace std;
 
static volatile int exit_sig = 0;
#define MAX_PAYLOAD_SIZE  10 * 1024
uint8_t g_curLogLevel = HKLOG_LEVEL_INFO;
 
void sighdl( int sig ) {
    lwsl_notice( "%d traped", sig );
    exit_sig = 1;
}
 
/**
 * 会话上下文对象，结构根据需要自定义
 */
struct session_data {
    int msg_count;
    unsigned char buf[LWS_PRE + MAX_PAYLOAD_SIZE];
    int len;
};
 
  /**
 * 某个协议下的连接发生事件时，执行的回调函数
 * wsi：指向WebSocket实例的指针
 * reason：导致回调的事件
 * user 库为每个WebSocket会话分配的内存空间
 * in 某些事件使用此参数，作为传入数据的指针
 * len 某些事件使用此参数，说明传入数据的长度
 */
 
int callback( struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len )
 {
 
    struct session_data *data = (struct session_data *) user;
    
    std::string strBody;
    int isize = 0;
    bool parsingSuccessful = false;
    char const* begin = nullptr;
    char const* end = nullptr;
    Json::Value root;
    Json::CharReaderBuilder readerBuilder;
    Json::CharReader* reader = nullptr;
    std::string errors;
    std::string strrecv;
    char* received_data = nullptr;
    switch ( reason ) {
        case LWS_CALLBACK_CLIENT_ESTABLISHED:   // 连接到服务器后的回调
            lwsl_notice( "Connected to server\n" );
            break;
 
        case LWS_CALLBACK_CLIENT_RECEIVE:       // 接收到服务器数据后的回调，数据为in，其长度为len
            isize = sizeof(RADAR_OBJ_INFO);
            //lwsl_notice( "RxBody: %s,len: %d,isize: %d\n", (char *) in,len,isize);
            received_data = static_cast<char*>(in);
            strrecv = received_data;
            strBody.assign((const char *)in, len);
            std::cout << "client Received: " << static_cast<char*>(in) << std::endl;
            std::cout << "strrecv: " << strrecv.c_str() << std::endl;
            printf("Read bodyinfo: [ %s ]\n", strBody.c_str());
            strBody = HKCodingConv::AnsiToUtf8(strBody);
            HKLOG_write(HKLOG_LEVEL_INFO, " LWS_CALLBACK_SERVER_WRITEABLE body %s!",strBody.c_str());
            begin = strBody.data();
            end = begin + strBody.size();
            reader = readerBuilder.newCharReader();
            parsingSuccessful = reader->parse(begin, end, &root, &errors);
            if (!parsingSuccessful) {
                //  解析失败，输出错误信息
                std::cout << "Error parsing JSON: " << errors << std::endl;
            } 
            break;

        case LWS_CALLBACK_CLIENT_WRITEABLE:     // 当此客户端可以发送数据时的回调
            if ( data->msg_count < 1 ) {
                // 前面LWS_PRE个字节必须留给LWS
                //"method" : { "service" : "Subscribe", "protocol" : "radarwebsocket" }
                memset( data->buf, 0, sizeof( data->buf ));
                char *msg = (char *) &data->buf[ LWS_PRE ];

                Json::Value eventInfo;
                eventInfo["service"] = "Subscribe";
                eventInfo["protocol"] = "radarwebsocket";
                Json::Value parent;
                parent["method"] = eventInfo;
                Json::FastWriter writer;
                std::string strresponse = writer.write(parent);

                data->len = sprintf( msg, "%s %d",strresponse.c_str(),++data->msg_count );
                lwsl_notice( "Tx: %s\n", msg );
                // 通过WebSocket发送文本消息
                lws_write( wsi, &data->buf[ LWS_PRE ], data->len, LWS_WRITE_TEXT );
            }
            break;
    }
    return 0;
}
 
/**
 * 支持的WebSocket子协议数组
 * 子协议即JavaScript客户端WebSocket(url, protocols)第2参数数组的元素
 * 你需要为每种协议提供回调函数
 */
struct lws_protocols protocols[] = {
    {
        //协议名称，协议回调，接收缓冲区大小
        "radarwebsocket", callback, sizeof( struct session_data ), 4*1024*1024,
    },
    { 
        NULL, NULL, 0, 0 
    } // 结束标识
};
 
int main() {

    HKLOG_init("TEST");
    HKLOG_set_level(g_curLogLevel);

    // 信号处理函数
    signal( SIGTERM, sighdl );
 
    // 用于创建vhost或者context的参数
    struct lws_context_creation_info ctx_info = { 0 };
    ctx_info.port = CONTEXT_PORT_NO_LISTEN;
    ctx_info.protocols = protocols;
    ctx_info.gid = -1;
    ctx_info.uid = -1;
 
    // 创建一个WebSocket处理器
    struct lws_context *context = lws_create_context( &ctx_info );
 
    char *address = "172.0.0.1";
    int port = 8085;
    char addr_port[256] = { 0 };
    sprintf( addr_port, "%s:%u", address, port & 65535 );
 
    // 客户端连接参数
    struct lws_client_connect_info conn_info = { 0 };
    conn_info.context = context;
    conn_info.address = address;
    conn_info.port = port;
    conn_info.ssl_connection = 0;
    conn_info.path = "/";
    conn_info.host = addr_port;
    conn_info.origin = addr_port;
    conn_info.protocol = protocols[ 0 ].name;
 
    // 下面的调用触发LWS_CALLBACK_PROTOCOL_INIT事件
    // 创建一个客户端连接
    struct lws *wsi = lws_client_connect_via_info( &conn_info );
    while ( !exit_sig ) {
        // 执行一次事件循环（Poll），最长等待1000毫秒
        lws_service(context,20);
        /**
         * 下面的调用的意义是：当连接可以接受新数据时，触发一次WRITEABLE事件回调
         * 当连接正在后台发送数据时，它不能接受新的数据写入请求，所有WRITEABLE事件回调不会执行
         */
        lws_callback_on_writable( wsi );
    }
    // 销毁上下文对象
    lws_context_destroy( context );
 
    return 0;
}

亲测服务端和客户端是可以通信的，完整的代码连接如下
想年薪百万的it小小鸟
关注
  • 25
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c、c++实现websocket服务器及客户端
10-17
这个代码例子使用了c c++实现了websocket 开发 包含了websocket服务器和websocket客户端,拥有详细的解释 这个库比libwebsocket更加简单方便,比libsocket更加高效便捷.
封装利用libwebsockets写出的客户端、服务端程序为客户端服务端类
逍遥游的博客
01-31 8351
封装利用libwebsockets写出的客户端、服务端程序为客户端服务端类 文章目录封装利用libwebsockets写出的客户端、服务端程序为客户端服务端类1.封装2.封装后写wss客户端、服务端3.测试结果4.客户端、服务端类程序 1.封装 我们后续将使用c++来开发程序，因此有必要将用c写成的wss客户端、服务端程序作进一步封装，使其成为wss客户端类和服务端类，这样更便于调用。封装后的程...
20190503(cmake安装，利用libwebsockets库去实现http服务器，websocket服务器，虚拟机安装)
xiaotian_muzi的博客
05-06 6441
目录 1.libwebsockets简介安装 2.libwebsockets实现简易http服务器 3.实现简易websocket服务器 4.websocket介绍 5.虚拟机安装 1.libwebsockets简介安装 https://blog.csdn.net/u013780605/article/details/79489183 (完全抄录原作者，抄录的目的是一为了一字不差看...
libwebsockets使用记录
guolisong的专栏
04-12 485
后来变成多个客户端访问后，又出现了crash的问题，而且问题看上去和第一次高频通讯，发生trunc后crash一样。网上查了资料后，感觉方向可能是堆栈太小导致的，后来讲堆栈放大一点（放大了10倍，100K字节），问题就再也没有发生过。原因在于，一开始在callback外面，直接调用lws_write去发送数据。之前基于libwebsockets做了实时的web socket通讯，多个客户端访问，报文按照50ms传输。1. 高频通讯过程中，写数据发生trunc错误，导致程序崩溃。2. 多个客户端访问。
【C++】libwebsockets库的简易教程（附源码）
bigger_belief的博客
06-08 9113
【C++】libwebsockets库的简易教程
C# 开发 websocket 服务端和客户端
03-04
在C#中开发WebSocket服务端和客户端，可以实现双向通信，即服务器和客户端都能主动发送数据，这对于实时性要求高的应用，如在线聊天、游戏、股票交易等场景非常适用。 WebSocketSharp是C#中的一个开源库，它为C#...
C# 实现的WebSocket服务端和客户端
12-16
在本文中，我们将深入探讨如何使用C#语言实现WebSocket服务端和客户端，尤其是在Windows Forms环境下。 首先，我们需要理解C#中的WebSocket基础。WebSocket API在.NET Framework 4.5及以上版本中得到支持，可以通过...
WebSocket 服务端及客户端 DEMO.rar
08-20
在本DEMO中，我们看到的是使用C#语言实现的WebSocket服务端和客户端的源码，特别的是，它还支持微信小程序通过WS（WebSocket）协议进行通信。 首先，让我们详细了解一下WebSocket协议。WebSocket协议是HTML5的一个...
基于springboot实现websocket客户端和服务端
最新发布
04-29
环境配置 开发环境配置为： JDK 8 IntelliJ IDEA 2020.1.2 x64 Springboot集成的Websocket ...在Spring内，WebSocket实例以WebSocketSession形式存在，每个session都代表了一个服务端与客户端的会话。
c++ websocket服务器和html客户端
12-04
websocket服务器和客户端，服务器C++，客户端html
利用libwebsockets写ws、wss服务端和客户端
热门推荐
逍遥游的博客
01-31 2万+
利用libwebsockets写ws、wss服务端和客户端 文章目录利用libwebsockets写ws、wss服务端和客户端服务端：客户端 服务端： server.c #include "libwebsockets.h" #include &lt;signal.h&gt; #include &lt;string.h&gt; static volatile int exit_sig = 0; ...
C++ libwebsockets搭建WebSocket服务端及Http客户端、服务端
fantasysolo的博客
03-30 2万+
websocket和webrtc笔记欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导...
【Websocket编程】基于libwebsockets实现客户端数据通信
菠萝菠萝哒X
03-20 2245
0、序   基于libwebsockets所实现的客户端数据上传demo，源码来源于libwebsockets中minimal-example中的实例。本篇章仅利用client端实例进行数据通信，Server端已由其他后台的小伙子搭好服务器了。 ★★★仅修改以下三部分： vhd->i.port = ; vhd->i.address = " "; vhd->i.path = "/ws"; 1、Client端实现 1.1、minimal_ws_client.c #include "min
libwebsocket入门分享
weixin_64170069的博客
10-31 1462
WebSocket 是一种网络传输协议，可在单个 TCP 连接上进行全双工通信，位于 OSI 模型的应用层。WebSocket 协议在 2011 年由 IETF 标准化为RFC 6455，后由RFC 7936补充规范。WebSocket 使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在 WebSocket API 中，浏览器和服务器只需要完成一次握手，两者之间就可以创建持久性的连接，并进行双向数据传输。
C++实现WebSocket通信（服务端和客户端）
分享式获得也是一种学习的态度
09-13 4316
这里单纯是个人总结，如需更官方更准确的websocket介绍可百度websocket是一种即时通讯协议，你可以把他想像成http的变种http是一次请求一次回应，而websocket是一次请求建立之后就可以持续互通业务需求诸如持续实时的消息收发场景时使用因为并没有C++语言基础，所以只是参考网上的一些文章来整合代码实现自己需要的功能如果你和我一样是没有语言基础但有需要使用这个C++的websocket通信功能，那就需要安装C++的环境才能跑这个代码C++环境配置（下载安装MinGW）
用 C 语言实现 WebSocket
c232040337的专栏
03-29 1729
libwebsockets 是一个 C语言 编写的跨平台的 WebSocket 库，可用于创建协议相关的服务器和客户端。它是一个灵活且易于使用的库，可以快速构建一个高性能的 WebSocket 应用程序。由于其简单、轻量级的设计，它非常适合构建基于嵌入式系统或处理大量连接的高负载服务器应用。我们需要创建一个index.html在 index.html 右键，并打开此文件：启动页面可以看到后端先接收到前端的信息，open 建立成功。然后建立连接后，后端一直在为前端输出信息。查看效果。
libwebsockets常用接口及客户端基本流程
weixin_42336465的博客
03-26 1225
由于项目的需要，要使用libwebsockets实现客户端固件与服务端的通讯，因此整理了libwebsockets常用的一些接口。并站在客户端的角度，提供了基本流程和代码示例
使用libwebsockets搭建一个简单的websocket服务器
北雨南萍
08-06 1613
libwebsocket实现的ws服务器
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值