libhv tcp实战小项目

已于 2023-03-10 20:39:31 修改
阅读量708 收藏 5
点赞数 2
分类专栏： libhv 文章标签： tcp/ip 网络协议 网络
于 2023-03-10 17:05:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weijianjain/article/details/129446908
版权

libhv Tcp小项目实战

一、概述

1、包头

2、心跳

3、任务队列

二、包头

2字节2字节4字节4字节2字节1字节1字节
起始标志版本号(N)Command(命令ID)消息体长度(N)预留Crc校验位结束标志
  • 起始标志：0xef.
  • 版本号：0x0001。
  • Command:命令号，用于表示一个特定的命令。请求和响应成对出现。
  • 消息体长度：表示protobuf消息体的长度，该长度不能超过100*1024个字节。
  • 预留：留作他用，目前全部填0，
  • Crc校验位：将前面所有字节内容相加，如果内容之和超过1个字节，直接翻转即可。
  • 结束标志：“#”代表结束标志。
    注：在交互过程中，包头各字段在网络中以网络字节顺序传输。
// 自行扩展
enum SOCKET_MSG_TYPE
{
	SOCKET_MSG_TYPE_NULLPTR = 0,
	SOCKET_MSG_TYPE_HB = 1,
};

//  基础结构体、类
#pragma pack(1) //下面的结构体1字节对其
// 包头结构体
struct HeadData
{
	HeadData() :
		m_nBeginMark(0xef),
		m_cVersion(1),
		m_nCmdId(SOCKET_MSG_TYPE_NULLPTR),
		m_nLen(),
		m_arrResover(),
		m_cCrc(),
		m_cFinishMark(0x23)
	{}
	unsigned short			m_nBeginMark;			//起始标志
	unsigned short          m_cVersion;				//目前填0
	unsigned int            m_nCmdId;               // 消息类型         见枚举 SOCKET_MSG_TYPE
	unsigned int			m_nLen;					//负载数据长度，不包含头
	unsigned char			m_arrResover[2];		//预留位
	unsigned char			m_cCrc;					//私有数据头的校验字节
	unsigned char			m_cFinishMark;			//结束标志
};
#pragma pack()

三、心跳包

socket，以双方发送心跳确认对端是否关闭。
该项目心跳包只发送当前时间，其他业务根据自己需求扩展。

// 心跳结构体
struct SocketHB
{
	SocketHB() : m_strTimetemp() {}
	std::string m_strTimetemp;       // 时间戳 
};

四、任务队列

任务队列是在队列的基础上加锁，实现线程安全。

class SocketQueueMessage
{
public:
	SocketQueueMessage();
	~SocketQueueMessage();

	/**
	 * @brief 插入队列
	 * @param p_stMsg InviewSocketDataMessage数据
	 */
	void addMsg(InviewSocketDataMessage& p_stMsg);

	/**
	 * @brief 获取队列元素
	 * @param p_stMsg InviewSocketDataMessage数据
	 * @return true :成功  false ：失败
	 */
	bool getMsg(InviewSocketDataMessage& p_stMsg);

	/**
	 * @brief 清空队列元素
	 */
	void clearMsg();

private:
	std::list<SocketDataMessage> m_listDataMessage;    // 消息队列
	std::mutex m_mutexDataThread;                            // 消息线程锁
};

五、libhv 官方tcp简单小例子

项目地址：https://github.com/ithewei/libhv.git

码云镜像：https://gitee.com/libhv/libhv.git

#include "TcpServer.h"

using namespace hv;

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s port\n", argv[0]);
        return -10;
    }
    int port = atoi(argv[1]);

    TcpServer srv;
    int listenfd = srv.createsocket(port);
    if (listenfd < 0) {
        return -20;
    }
    printf("server listen on port %d, listenfd=%d ...\n", port, listenfd);
    srv.onConnection = [](const SocketChannelPtr& channel) {
        std::string peeraddr = channel->peeraddr();
        if (channel->isConnected()) {
            printf("%s connected! connfd=%d\n", peeraddr.c_str(), channel->fd());
        } else {
            printf("%s disconnected! connfd=%d\n", peeraddr.c_str(), channel->fd());
        }
    };
    srv.onMessage = [](const SocketChannelPtr& channel, Buffer* buf) {
        // echo
        printf("< %.*s\n", (int)buf->size(), (char*)buf->data());
        channel->write(buf);
    };
    srv.onWriteComplete = [](const SocketChannelPtr& channel, Buffer* buf) {
        printf("> %.*s\n", (int)buf->size(), (char*)buf->data());
    };
    srv.setThreadNum(4);
    srv.start();

    while (1) sleep(1);
    return 0;
}

六、实战小项目

项目以上面tcp框架小例子为主

1、tcpServer

  • SocketManager.h
#pragma once
#include <iostream>
#include <list>
#include <sstream>
#include <iomanip>
#include "hv/TcpServer.h"           // tcp

using namespace std;
using namespace hv;

#define TEST_TLS        0


// 自行扩展
enum SOCKET_MSG_TYPE
{
	SOCKET_MSG_TYPE_NULLPTR = 0,
	SOCKET_MSG_TYPE_HB = 1,
};

//  基础结构体、类
#pragma pack(1) //下面的结构体1字节对其
// 包头结构体
struct HeadData
{
	HeadData() :
		m_nBeginMark(0xef),
		m_cVersion(1),
		m_nCmdId(SOCKET_MSG_TYPE_NULLPTR),
		m_nLen(),
		m_arrResover(),
		m_cCrc(),
		m_cFinishMark(0x23)
	{}
	unsigned short			m_nBeginMark;			//起始标志
	unsigned short          m_cVersion;				//目前填0
	unsigned int            m_nCmdId;               //消息类型         见枚举 SOCKET_MSG_TYPE
	unsigned int			m_nLen;					//负载数据长度，不包含头
	unsigned char			m_arrResover[2];		//预留位
	unsigned char			m_cCrc;					//私有数据头的校验字节
	unsigned char			m_cFinishMark;			//结束标志
};
#pragma pack()


// 消息队列结构体
struct SocketDataMessage
{
	SocketDataMessage() : m_stIo(nullptr), m_strSendData() {}
	hio_t* m_stIo;              // socket id
	std::string m_strSendData;  // 收到的数据
};

// 心跳结构体
struct SocketHB
{
	SocketHB() : m_strTimetemp() {}
	std::string m_strTimetemp;       // 时间戳 
};

class SocketQueueMessage
{
public:
	SocketQueueMessage();
	~SocketQueueMessage();

	/**
     * @brief 插入队列
     * @param p_stMsg SocketDataMessage数据
     */      
	void addMsg(SocketDataMessage& p_stMsg);

	/**
     * @brief 获取队列元素
     * @param p_stMsg SocketDataMessage数据
     * @return true :成功  false ：失败
     */      
	bool getMsg(SocketDataMessage& p_stMsg);

	/**
     * @brief 清空队列元素
     */     
	void clearMsg();

private:
	std::list<SocketDataMessage> m_listDataMessage;    // 消息队列
	std::mutex m_mutexDataThread;                      // 消息线程锁
};

class SocketManager
{
public:
	SocketManager();
	~SocketManager();

	/**
     * @brief 初始化
     */     
	bool Init();

	/**
     * @brief tcp初始化
     */   
	bool TcpInit();

	/**
     * @brief 运行
     */    
	void Start();

private:
	/**
     * @brief 解包头
     * @param p_pszBuf 传入参，接收数据字符串
     * @param p_nBufLen 传入参，接收数据字符串长度
     * @param p_stResData 传出参，包头结构体
     * @return 0 ：成功   -1：失败
     */
	int PraseHeadMessage(char* p_pszBuf, unsigned int p_nBufLen, HeadData& p_stResData);

 	/**
     * @brief 组包头
     * @param p_strResMessage 传入参，发送数据字符串
     * @param p_strRes 传出参，组包结果返回
     * @param p_stResData 传出参，包头结构体
     * @return 0 ：成功   -1：失败
     */   
	int TobufHeadMessage(const std::string p_strResMessage, std::string& p_strRes, HeadData& p_stResData);

	/**
	 * @brief tcp工作线程
	 */
	void tcpWork();

	/**
	 * @brief tcp发送函数
	 * @param p_ioIo libhv IO
	 * @param p_strSend 发送字符串
	 */
    void SendMsg(hio_t* p_ioIo, std::string p_strSend);

	/**
	 * @brief 获取当前时间字符串
	 * @return 当前时间字符串
	 */
	std::string getCurrentTime();

private:
	/**
	 * @brief 组装心跳包
	 * @param p_strRes 传出参，组装好的心跳数据
	 */    
	void testHb(std::string& p_strRes);

private:
	std::thread* m_threadTcpWork;            // tcp工作线程
	std::mutex m_mutexTcpWork;               // tcp工作线程锁
	bool m_bTcpWorkFlag;                     // tcp工作线程标识
	TcpServer* m_tcpServer;                  // tcp连接管理
	SocketQueueMessage m_tcpQueue;			 // tcp消息队列 									   
};
  • SocketManager.cpp
#include "SocketManager.h"

/******************************************SocketQueueMessage*************************************/
SocketQueueMessage::SocketQueueMessage()
{
	std::list<SocketDataMessage>().swap(m_listDataMessage);
}

SocketQueueMessage::~SocketQueueMessage()
{
	std::list<SocketDataMessage>().swap(m_listDataMessage);
}

void SocketQueueMessage::addMsg(SocketDataMessage& p_stMsg)
{
	std::lock_guard<std::mutex> lock(m_mutexDataThread);
	m_listDataMessage.push_back(p_stMsg);
}

bool SocketQueueMessage::getMsg(SocketDataMessage& p_stMsg)
{
	if (m_listDataMessage.empty())
	{
		return false;
	}
	std::lock_guard<std::mutex> lock(m_mutexDataThread);
	p_stMsg = m_listDataMessage.front();
	m_listDataMessage.pop_front();
	return true;
}

void SocketQueueMessage::clearMsg()
{
	std::lock_guard<std::mutex> lock(m_mutexDataThread);
	m_listDataMessage.clear();
}


SocketManager::SocketManager()
{
	m_threadTcpWork = nullptr;
	m_bTcpWorkFlag = false;
	m_tcpServer = nullptr;
}

SocketManager::~SocketManager()
{
	m_bTcpWorkFlag = true;
	if (m_threadTcpWork->joinable())
	{
		m_threadTcpWork->join();
		delete m_threadTcpWork;
		m_threadTcpWork = nullptr;
	}
	delete m_tcpServer;
}

// 初始化
bool SocketManager::Init()
{
	if (TcpInit())
	{
		std::cout << "tcp init success." << std::endl;
		return true;
	}
	return false;
}

// tcp
bool SocketManager::TcpInit()
{
	if (m_tcpServer != nullptr)
		return false;
	m_tcpServer = new TcpServer;

	int listenfd = m_tcpServer->createsocket(8888);
	if (listenfd < 0)
	{
		return false;
	}

	m_tcpServer->getChannelById(listenfd);
	printf("server listen on port 8888, listenfd=%d ...\n", listenfd);
	// 新连接接入
	m_tcpServer->onConnection = [this](const SocketChannelPtr& channel)
	{
		std::string peeraddr = channel->peeraddr();
		if (channel->isConnected())
		{
			// 心跳包
			channel->setHeartbeat(3000, [this, channel]()
				{
                    // 组装心跳包
					std::string strRes;
					testHb(strRes);
					SendMsg(channel->io(), strRes);
				});
			printf("%s connected! connfd=%d id=%d tid=%ld\n", peeraddr.c_str(), channel->fd(), channel->id(), currentThreadEventLoop->tid());
		}
		else
		{
			printf("%s disconnected! connfd=%d id=%d tid=%ld\n", peeraddr.c_str(), channel->fd(), channel->id(), currentThreadEventLoop->tid());
		}
	};
	// 接收数据处理
	m_tcpServer->onMessage = [this](const SocketChannelPtr& channel, Buffer* buf)
	{
        // 从客户端接收到的数据，发送到消息队列处理
		SocketDataMessage stMsg;
		stMsg.m_stIo = channel->io();
		stMsg.m_strSendData = std::string((char*)buf->data(), buf->size());
		m_tcpQueue.addMsg(stMsg);
	};

	m_tcpServer->setThreadNum(4);
	m_tcpServer->setLoadBalance(LB_LeastConnections);

#if TEST_TLS
	hssl_ctx_opt_t ssl_opt;
	memset(&ssl_opt, 0, sizeof(hssl_ctx_opt_t));
	ssl_opt.crt_file = "cert/server.crt";
	ssl_opt.key_file = "cert/server.key";
	ssl_opt.verify_peer = 0;
	m_tcpServer->withTLS(&ssl_opt);
#endif

	m_tcpServer->start();

	return true;
}

void InviewSocketManager::SendMsg(hio_t* p_ioIo, std::string p_strSend)
{
	hio_write(p_ioIo, p_strSend.c_str(), p_strSend.size());
}

void SocketManager::tcpWork()
{
	if (m_threadTcpWork != nullptr)
		return;
	m_threadTcpWork = new std::thread([this]()
		{
			SocketDataMessage stMsg;
			while (!m_bTcpWorkFlag)
			{
                // 从消息队列获取数据
				if (m_tcpQueue.getMsg(stMsg))
				{
					if (stMsg.m_strSendData.empty())
					{
						// TODO 返回错误给tools
						std::cout << "PraseHeadMessage send data is empty.\n";
						continue;
					}

					// 1、解包
					HeadData stHeadData;
					int nRet = PraseHeadMessage((char*)stMsg.m_strSendData.c_str(), stMsg.m_strSendData.size(), stHeadData);
					if (nRet < 0)
					{
						std::cout << "PraseHeadMessage error! nRet = [" << nRet << "]";
						continue;
					}

					// 2、消息处理
					std::string strProtobufData;
					switch (stHeadData.m_nCmdId)
					{
					case SOCKET_MSG_TYPE_HB:
					{
						std::cout << "Recv client hb.\n";
						strProtobufData = getCurrentTime();
						break;
					}
					}

					// 3、组包
					std::string strResData;
					nRet = TobufHeadMessage(strProtobufData, strResData, stHeadData);
					if (nRet < 0)
					{
						std::cout << "TobufHeadMessage error! nRet = [" << nRet << "]\n";
					}

                    // 4、发送
					hio_write(stMsg.m_stIo, strResData.c_str(), strResData.size());
				}
				std::this_thread::sleep_for(std::chrono::milliseconds(50));
			}
		});
}

// 运行
void SocketManager::Start()
{
	tcpWork();
}


// 解包头
int SocketManager::PraseHeadMessage(char* p_pszBuf, unsigned int p_nBufLen, HeadData& p_stResData)
{
	if (nullptr == p_pszBuf || p_nBufLen == 0)
	{
		std::cout << "PraseHeadMessage nullptr == p_pszBuf || p_nBufLen == 0\n";
		return -1;
	}

	//开始解析私有头
	int headLen = 0;
	HeadData* privateHeader = (HeadData*)(p_pszBuf + headLen);

	//用其他字段做简单校验，消息是否正常
	if (!(privateHeader->m_cVersion <= 0x0f && privateHeader->m_nBeginMark <= 0xef && privateHeader->m_cFinishMark == char('#')))
	{
		std::cout << "message version or beginmark or finismark error! privateHeader->m_cVersion = [" << privateHeader->m_cVersion
			<< "], privateHeader->m_nBeginMark = [ " << privateHeader->m_nBeginMark << "], privateHeader->m_cFinishMark = ["
			<< privateHeader->m_cFinishMark << "]\n";
		return -1;
	}
	p_stResData = *privateHeader;
	return 0;
}

// 组包头
int SocketManager::TobufHeadMessage(const std::string p_strResMessage, std::string& p_strRes, HeadData& p_stResData)
{
	// 组包
	p_stResData.m_nLen = p_strResMessage.size();

	char szBuf[sizeof(HeadData)] = { 0 };
	memcpy(szBuf, &p_stResData, sizeof(HeadData));

	p_strRes = std::string(szBuf, sizeof(HeadData)) + p_strResMessage;
	return 0;
}

std::string SocketManager::getCurrentTime()
{
	auto t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
	std::stringstream ss;
	ss << std::put_time(std::localtime(&t), "%F %T");
	return ss.str();
}

// 组装心跳包
void SocketManager::testHb(std::string& p_strRes)
{
	// 组转心跳包
	char cbuf[256] = { 0 };
	SocketHB stHb;
	stHb.m_strTimetemp = getCurrentTime();
	memcpy(cbuf, &stHb, sizeof(SocketHB));
	std::string nHbData = std::string(cbuf);

	HeadData stHeadData;
	stHeadData.m_nCmdId = SOCKET_MSG_TYPE_HB;
	TobufHeadMessage(nHbData, p_strRes, stHeadData);
}
  • main.cpp
#include <iostream>
#include "SocketManager.h"
using namespace std;

int main()
{
	SocketManager stMsg;
	stMsg.Init();
	stMsg.Start();
	while (1)
		Sleep(1);
}

2、tcpClient

#include <iostream>
#include <sstream>
#include <iomanip>

#include "hv/TcpClient.h"
#include "hv/htime.h"

#define TEST_RECONNECT  1
#define TEST_TLS        0

using namespace hv;

// 自行扩展
enum SOCKET_MSG_TYPE
{
    SOCKET_MSG_TYPE_NULLPTR = 0,
    SOCKET_MSG_TYPE_HB = 1,
};

//  基础结构体、类
#pragma pack(1) //下面的结构体1字节对其
// 包头结构体
struct HeadData
{
    HeadData() :
        m_nBeginMark(0xef),
        m_cVersion(1),
        m_nCmdId(SOCKET_MSG_TYPE_NULLPTR),
        m_nLen(),
        m_arrResover(),
        m_cCrc(),
        m_cFinishMark(0x23)
    {}
    unsigned short			m_nBeginMark;			//起始标志
    unsigned short          m_cVersion;				//目前填0
    unsigned int            m_nCmdId;               // 消息类型         见枚举 SOCKET_MSG_TYPE
    unsigned int			m_nLen;					//负载数据长度，不包含头
    unsigned char			m_arrResover[2];		//预留位
    unsigned char			m_cCrc;					//私有数据头的校验字节
    unsigned char			m_cFinishMark;			//结束标志
};
#pragma pack()

// 心跳结构体
struct SocketHB
{
    SocketHB() : m_strTimetemp() {}
    std::string m_strTimetemp;       // 时间戳 
};


// 解包头
int PraseHeadMessage(char* p_pszBuf, unsigned int p_nBufLen, HeadData& p_stResData)
{
    if (nullptr == p_pszBuf || p_nBufLen == 0)
    {
        std::cout << "PraseHeadMessage nullptr == p_pszBuf || p_nBufLen == 0\n";
        return -1;
    }

    //开始解析私有头
    int headLen = 0;
    HeadData* privateHeader = (HeadData*)(p_pszBuf + headLen);

    //用其他字段做简单校验，消息是否正常
    if (!(privateHeader->m_cVersion <= 0x0f && privateHeader->m_nBeginMark <= 0xef && privateHeader->m_cFinishMark == char('#')))
    {
        std::cout << "message version or beginmark or finismark error! privateHeader->m_cVersion = [" << privateHeader->m_cVersion
            << "], privateHeader->m_nBeginMark = [ " << privateHeader->m_nBeginMark << "], privateHeader->m_cFinishMark = ["
            << privateHeader->m_cFinishMark << "]\n";
        return -1;
    }
    p_stResData = *privateHeader;
    return 0;
}

// 组包头
int TobufHeadMessage(const std::string p_strResMessage, std::string& p_strRes, HeadData& p_stResData)
{
    // 组包
    p_stResData.m_nLen = p_strResMessage.size();

    char szBuf[sizeof(HeadData)] = { 0 };
    memcpy(szBuf, &p_stResData, sizeof(HeadData));

    p_strRes = std::string(szBuf, sizeof(HeadData)) + p_strResMessage;
    return 0;
}

std::string getCurrentTime()
{
    auto t = std::chrono::system_clock::to_time_t(std::chrono::system_clock::now());
    std::stringstream ss;
    ss << std::put_time(std::localtime(&t), "%F %T");
    return ss.str();
}

int main(int argc, char* argv[])
{
    int port = 8888;

    TcpClient cli;
    int connfd = cli.createsocket(port);
    if (connfd < 0) {
        return -20;
    }
    printf("client connect to port %d, connfd=%d ...\n", port, connfd);
    cli.onConnection = [&cli](const SocketChannelPtr& channel) {
        std::string peeraddr = channel->peeraddr();
        if (channel->isConnected()) {
            printf("connected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
            // 心跳包
            channel->setHeartbeat(3000, [channel]()
                {
                    std::string strRes;
                    // 组转心跳包
                    char cbuf[256] = { 0 };
                    SocketHB stHb;
                    stHb.m_strTimetemp = getCurrentTime();
                    memcpy(cbuf, &stHb, sizeof(SocketHB));
                    std::string nHbData = std::string(cbuf);

                    HeadData stHeadData;
                    stHeadData.m_nCmdId = SOCKET_MSG_TYPE_HB;
                    TobufHeadMessage(nHbData, strRes, stHeadData);

                    hio_write(channel->io(), strRes.c_str(), strRes.size());
                });
        }
        else {
            printf("disconnected to %s! connfd=%d\n", peeraddr.c_str(), channel->fd());
        }
        if (cli.isReconnect()) {
            printf("reconnect cnt=%d, delay=%d\n", cli.reconn_setting->cur_retry_cnt, cli.reconn_setting->cur_delay);
        }
    };
    cli.onMessage = [](const SocketChannelPtr& channel, Buffer* buf) 
    {
        // TODO
        // 解析
        printf("< %.*s\n", (int)buf->size(), (char*)buf->data());
    };

#if TEST_RECONNECT
    // reconnect: 1,2,4,8,10,10,10...
    reconn_setting_t reconn;
    reconn_setting_init(&reconn);
    reconn.min_delay = 1000;
    reconn.max_delay = 10000;
    reconn.delay_policy = 2;
    cli.setReconnect(&reconn);
#endif

#if TEST_TLS
    cli.withTLS();
#endif

    cli.start();

    std::string str;
    while (std::getline(std::cin, str)) {
        if (str == "close") {
            cli.closesocket();
        }
        else if (str == "start") {
            cli.start();
        }
        else if (str == "stop") {
            cli.stop();
            break;
        }
        else {
            if (!cli.isConnected()) break;
            cli.send(str);
        }
    }

    return 0;
}
牛马不分
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
json-rpc-client:JSON RPC 2.0 客户端实现，可用于任意传输
06-05
json rpc 客户端 客户端实现，可用于任意传输。 对应的服务器实现见 。 Client 被定义为 Request 对象的来源和 Response 对象的处理程序。 用法 使用任意传输创建请求函数。 传输对象必须具有发送字符串消息的send方法，并且必须具有用于添加message事件侦听器的on方法。 如果消息在同一个事件循环中发送，则消息会被批处理。 例子 // Channel "interface" var channel = { // Sends the specified string over the wire. send : function ( json ) { // ... } , // This method will be called with the string `message` as event and a // call
C/C++高性能服务器网络库框架libhv源码解读
weixin_40355471的博客
03-17 1292
信号处理，日志，资源池，线程池错误，命令行参数，配置文件，堆，缓存，链表，队列，红黑树，MultiMap，JSON，tcp，udp，http，WebSocket事件循环，事件循环线程，事件循环线程池，定时器，网络IO，异步自定义事件，epoll，poll，select，iocp(win)，kqueue(OS_BSD/OS_MAC)，evport(OS_SOLARIS)。 6、协议编码：gRPC，rudp，kcp，ssl，tls，mqtt，dns，ftp，icmp，smtp，base64，md5，sha1。
c++使用libhv实现TCP客户端服务端长连接(带有心跳包回复)
Pailugou的博客
12-16 3742
【代码】c++使用libhv实现TCP客户端服务端长连接(带有心跳包回复)
libhv教程06--创建一个简单的TCP服务端
HW的博客
02-07 1万+
下文以TCP echo server为例，使用libhv创建TCP服务端。 - `setThreadNum`：设置IO线程数 - `setMaxConnectionNum`：设置最大连接数 - `setLoadBalance`: 设置负载均衡策略（轮询、随机、最少连接数） - `setUnpack`：设置拆包规则（固定包长、分界符、头部长度字段） - `withTLS`：SSL/TLS加密通信
tcpServer_test学习
xiangxiang2017的博客
03-06 705
本博文是对开源网络库libhv中的示例程序tcpServer_test的学习记录。1.打开TcpServer_test.cpp文件，看到main()//运行程序时需要指定端口return -10;//创建TcpServer//创建socket,调用了socket()、bind()、listen()return -20;//设置连接回调函数} else {// echo//设置线程数量//设置负载均衡模式//开启服务srv.stop();break;
libhv学习路线 之 TCP服务器
qq_40115163的博客
03-21 5588
对于libhv TCP端的服务器实现,基本上也已经被libhv封装完成了,所以我们只需要研究以下libhv内部是如何实现TCP连接建立,以及收发数据的. 一 基于libhv的TCP服务器内部实现原理 A..我们需要建立一个事件回环loop变量,具体代码如下所示: hloop_t* loop = hloop_new(0); B.调用hloop_create_tcp_server()函数建立TCP连接,具体代码如下所示,IP地址设置的是0.0.0.0的主...
libhv源码学习 -- base模块 -- hbase.h
TW2938384958的博客
06-30 533
hbase.h 注： 阅读源码时最新代码为 2021年6月更新   按照官方推荐的源码阅读顺序，就先来看看base模块。 base模块主要目录结构如下： . ├── array.h 动态数组 ├── hatomic.h 原子操作 ├── hbase.h 基础函数 ├── hbuf.h 缓存 ├── hdef.h 常见宏定义 ├── heap.h 堆 ├── hendian.h 大小端 ├── her
libhv教程10--创建一个简单的HTTP服务端
热门推荐
HW的博客
02-23 1万+
简单的HTTP服务端示例 完整的HTTP服务端示例 压力测试
libhv教程07--创建一个简单的TCP客户端
HW的博客
02-07 6326
创建一个简单的TCP客户端 文章目录c版本c++版本 c版本 #include "hv/hloop.h" #include "hv/htime.h" void on_timer(htimer_t* timer) { char str[DATETIME_FMT_BUFLEN] = {0}; datetime_t dt = datetime_now(); datetime_fmt(&dt, str); printf("> %s\n", str); hio
LIBHV 实现TCP服务
xiaoning132的专栏
03-17 2784
最近的项目上，用到了LIBHV，特此预研了一下，接下来在项目上把它利用起来。 git clone https://github.com/ithewei/libhv.git cd libhv ./configure make 编译很简单，在ubuntu上很快就编译好啦。
libhv::fire: 比libevent、libuv更易用的国产网络库。A network library for developing TCPUDPHTTPWebSocket clientserver
05-10
English | libhv 像libevent, libev, and libuv ， libhv提供具有非阻塞IO和计时器的事件循环，但具有更简单的api和更丰富的协议。 :sparkles: 特征 跨平台（Linux，Windows，Mac，Solaris） EventLoop（IO，计时器，空闲） TCP / UDP客户端/服务器/代理 SSL / TLS支持：WITH_OPENSSL或WITH_MBEDTLS HTTP客户端/服务器（包括https http1 / x http2 grpc） HTTP文件服务，索引服务，API服务（支持RESTful） WebSocket客户端/服务器 :hourglass_done: 建造 见 生成文件： ./configure make sudo make install 或cmake： mkdir build cd build cmake .. cmake -
CMake 实战管理TcpServer项目
01-15
CMake 实战管理TcpServer项目
TCP/IP高效编程，项目实战
08-01
本文所用类库NetWorkHelper.dll
Qt_tcp实战.rar
07-19
这个是Qt的tcp通信的程序，有服务器和客户端，可以来回收发程序
LabVIEW Arduino TCP/IP远程智能家居系统实战项目
06-25
项目详情请参见：...基于TCP/IP网络的远程智能家居系统，采用Arduino Uno控制器作为下位机，采用LabVIEW作为远程监控软件，两者通过网络实现通信。 项目可直接运行~
真实com2tcp小工具
12-27
真实com2tcp小工具
LTD271次升级 | 网站/小程序可设访问IP的黑白名单 • 官微中心支持PDF等办公文件预览与并分享 • 订单退款显示更详尽明细
最新发布
LTD_SaaS的博客
04-23 717
IP网段可以用来描述一个 IP 区间，例如 127.0.0.1/24，其中 24 表示采用子网掩码中的前 24 位为有效位，即 2 进制的 IP 地址中，前 32 位有效，后 8 位表达了该网段的范围。在部分机型中，当调起文件分享面板时，会出现面板宽度过窄导致遮挡控件的问题。在升级前，文件详情页只能将当前文件以网页链接的方式进行分享，如果要分享文件本身，则需要在文件列表中，点击右侧菜单按钮调起文件分享面板。在分享文件时，所分享出去的文件名，从原本下载链接的数字形式的文件名优化为文件内容本身的文件名。
TCP/IP协议（二）
借风拥你
04-22 1058
TCP滑动窗口是TCP协议中的一种流量控制机制，用于调节发送方和接收方之间的数据传输速率，以避免网络拥塞和提高传输效率。滑动窗口机制允许发送方在不等待确认应答的情况下连续发送多个数据段。
开发TCP网络通信项目
05-27
好的，开发TCP网络通信项目需要一些基础的知识和技能，以下是我建议的开发流程： 1. 确定项目需求：确定项目的需求和功能，包括通信协议、数据传输格式、数据加密等。 2. 设计网络架构：设计网络架构，包括服务器...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值