Germany/hunting
7
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 1 Releases Wiki Activity

Improve:TcpModule.

Browse Source
This commit is contained in:
Fancy code 2024-04-11 18:49:05 +08:00
parent a7fc63285c
commit 7ebd2e3aa7
4 changed files with 51 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
test/utils/TcpModule/src/TcpModule_Test.cpp
View File

@ -25,14 +25,23 @@ namespace TcpModuleTest
*/ */
TEST(TcpModuleTest, UNIT_TcpModule_EXAMPLE_AUTO_IllegalObject) TEST(TcpModuleTest, UNIT_TcpModule_EXAMPLE_AUTO_IllegalObject)
{ {
static void *tcpClientAccept = nullptr;
TcpServerParam tcpServerparam = { TcpServerParam tcpServerparam = {
.mIp = "127.0.0.1", .mIp = "127.0.0.1",
.mPort = 9876, .mPort = 9876,
.mAcceptClientFunc = [](void *object, const char *ip) -> void { .mAcceptClientFunc = [](void *object, const char *ip) -> bool {
LogInfo("accept client, peer ip: %s", ip); LogInfo("accept client, peer ip: %s\n", ip);
tcpClientAccept = object; if (nullptr != object) {
return; AcceptClientWrite(object, "client accept send data.", strlen("client accept send data."));
}
return true;
},
.mClientAcceptParam = {
.mReadFunc = [](const void *data, const ssize_t len, const void *object) -> void {
LogInfo("client accept read data: %s\n", (char *)data);
},
.mClosedFunc = [](const void *object) -> void {
LogInfo("client accept closed.\n");
},
}, },
}; };
TcpClientParam param = { TcpClientParam param = {
@ -42,6 +51,9 @@ TEST(TcpModuleTest, UNIT_TcpModule_EXAMPLE_AUTO_IllegalObject)
LogInfo("read data: %s", (char *)data); LogInfo("read data: %s", (char *)data);
return; return;
}, },
.mClosedFunc = [](const void *object) -> void {
LogInfo("tcp client closed.\n");
},
}; };
CreateLogModule(); CreateLogModule();
ILogInit(LOG_INSTANCE_TYPE_END); ILogInit(LOG_INSTANCE_TYPE_END);
@ -49,11 +61,7 @@ TEST(TcpModuleTest, UNIT_TcpModule_EXAMPLE_AUTO_IllegalObject)
std::this_thread::sleep_for(std::chrono::milliseconds(500)); std::this_thread::sleep_for(std::chrono::milliseconds(500));
void *tcpClient = CreateTcpClient(param); void *tcpClient = CreateTcpClient(param);
std::this_thread::sleep_for(std::chrono::milliseconds(100)); std::this_thread::sleep_for(std::chrono::milliseconds(100));
TcpClientWrite(tcpClient, "123456789", strlen("123456789")); TcpClientWrite(tcpClient, "client send data.", strlen("client send data."));
std::this_thread::sleep_for(std::chrono::milliseconds(100));
if (nullptr != tcpClientAccept) {
AcceptClientWrite(tcpClientAccept, "9876543210", strlen("9876543210"));
}
std::this_thread::sleep_for(std::chrono::milliseconds(1000)); std::this_thread::sleep_for(std::chrono::milliseconds(1000));
if (nullptr != tcpClient) { if (nullptr != tcpClient) {
FreeTcpClient(tcpClient); FreeTcpClient(tcpClient);

19
utils/TcpModule/include/TcpModule.h
View File

@ -21,26 +21,27 @@
extern "C" { extern "C" {
#endif #endif
typedef void (*TcpReadFunction)(const void *, const ssize_t, const void *); typedef void (*TcpReadFunction)(const void *, const ssize_t, const void *);
typedef void (*TcpAcceptClientFunction)(void *, const char *); typedef bool (*TcpAcceptClientFunction)(void *, const char *);
typedef void (*SocketClosedFunction)(const void *); typedef void (*SocketClosedFunction)(const void *);
typedef struct client_accept_parm
{
const TcpReadFunction mReadFunc;
const SocketClosedFunction mClosedFunc;
} ClientAcceptParam;
typedef struct tcp_server_parm typedef struct tcp_server_parm
{ {
const char *mIp; const char *mIp;
const int mPort; const int mPort;
TcpAcceptClientFunction mAcceptClientFunc; const TcpAcceptClientFunction mAcceptClientFunc;
const ClientAcceptParam mClientAcceptParam;
} TcpServerParam; } TcpServerParam;
typedef struct tcp_parm typedef struct tcp_parm
{ {
const char *mIp; const char *mIp;
const int mPort; const int mPort;
TcpReadFunction mReadFunc; const TcpReadFunction mReadFunc;
SocketClosedFunction mClosedFunc; const SocketClosedFunction mClosedFunc;
} TcpClientParam; } TcpClientParam;
typedef struct client_accept_parm
{
TcpReadFunction mReadFunc;
SocketClosedFunction mClosedFunc;
} ClientAcceptParam;
void *CreateTcpServer(const TcpServerParam param); void *CreateTcpServer(const TcpServerParam param);
void FreeTcpServer(void *object); void FreeTcpServer(void *object);
void AcceptClientSetParam(void *object, const ClientAcceptParam param); void AcceptClientSetParam(void *object, const ClientAcceptParam param);

34
utils/TcpModule/src/TcpServerImpl.cpp
View File

@ -45,24 +45,21 @@ static void on_accept(hio_t *io)
hio_setcb_close(io, on_close); hio_setcb_close(io, on_close);
hio_setcb_read(io, on_recv); hio_setcb_read(io, on_recv);
std::shared_ptr<ITcpClientAccept> *client = NewTcpClientAccept(io); // std::shared_ptr<ITcpClientAccept> *client = NewTcpClientAccept(io);
TcpServerImpl *server = (TcpServerImpl *)hevent_userdata(io); TcpServerImpl *server = (TcpServerImpl *)hevent_userdata(io);
server->AddClient(io, client); server->AddClient(io);
hio_read_start(io); hio_read_start(io);
} }
TcpClientAcceptImpl::TcpClientAcceptImpl(const hio_t *io, const void *object) : mIo(io), mObjectThis(object) TcpClientAcceptImpl::TcpClientAcceptImpl(const hio_t *io, const void *object, const ClientAcceptParam &param)
: mIo(io), mObjectThis(object), mParam(param)
{ {
mParam.mReadFunc = nullptr;
mParam.mClosedFunc = nullptr;
} }
void TcpClientAcceptImpl::SetParam(const ClientAcceptParam &param) void TcpClientAcceptImpl::SetParam(const ClientAcceptParam &param)
{ {
std::lock_guard<std::mutex> locker(mMutex); // mParam = param;
mParam = param;
} }
void TcpClientAcceptImpl::Readed(const void *data, size_t length) void TcpClientAcceptImpl::Readed(const void *data, size_t length)
{ {
std::lock_guard<std::mutex> locker(mMutex);
if (nullptr != mParam.mReadFunc) { if (nullptr != mParam.mReadFunc) {
mParam.mReadFunc(data, length, mObjectThis); mParam.mReadFunc(data, length, mObjectThis);
return; return;
@ -80,7 +77,6 @@ ssize_t TcpClientAcceptImpl::Write(const void *data, size_t length)
} }
void TcpClientAcceptImpl::Closed(void) void TcpClientAcceptImpl::Closed(void)
{ {
std::lock_guard<std::mutex> locker(mMutex);
if (nullptr != mParam.mClosedFunc) { if (nullptr != mParam.mClosedFunc) {
mParam.mClosedFunc(mObjectThis); mParam.mClosedFunc(mObjectThis);
return; return;
@ -138,19 +134,27 @@ void TcpServerImpl::Loop(void)
} }
hloop_run(mLoop); hloop_run(mLoop);
} }
void TcpServerImpl::AddClient(hio_t *io, std::shared_ptr<ITcpClientAccept> *client) void TcpServerImpl::AddClient(hio_t *io)
{ {
std::lock_guard<std::mutex> locker(mMutex); mMutex.lock();
char localaddrstr[SOCKADDR_STRLEN] = {0}; char localaddrstr[SOCKADDR_STRLEN] = {0};
char peeraddrstr[SOCKADDR_STRLEN] = {0}; char peeraddrstr[SOCKADDR_STRLEN] = {0};
LogInfo("accept connfd=%d [%s] <= [%s]\n", LogInfo("accept connfd=%d [%s] <= [%s]\n",
hio_fd(io), hio_fd(io),
SOCKADDR_STR(hio_localaddr(io), localaddrstr), SOCKADDR_STR(hio_localaddr(io), localaddrstr),
SOCKADDR_STR(hio_peeraddr(io), peeraddrstr)); SOCKADDR_STR(hio_peeraddr(io), peeraddrstr));
mClients[hio_fd(io)] = client; std::shared_ptr<ITcpClientAccept> *addClient = NewTcpClientAccept(io, mParam.mClientAcceptParam);
mClients[hio_fd(io)] = addClient;
if (mParam.mAcceptClientFunc) { if (mParam.mAcceptClientFunc) {
mParam.mAcceptClientFunc(client, peeraddrstr); if (mParam.mAcceptClientFunc(addClient, peeraddrstr) == true) {
mMutex.unlock();
return;
} }
LogWarning("User did not accept client.\n");
}
mMutex.unlock();
hio_close(io);
LogWarning("AddClient failed.\n");
} }
std::shared_ptr<ITcpClientAccept> *TcpServerImpl::GetClient(hio_t *io) std::shared_ptr<ITcpClientAccept> *TcpServerImpl::GetClient(hio_t *io)
{ {
@ -210,7 +214,7 @@ std::shared_ptr<ITcpServer> *NewTcpServer(const TcpServerParam &param)
impl->mTcpServer = std::make_shared<TcpServerImpl>(param); impl->mTcpServer = std::make_shared<TcpServerImpl>(param);
return (std::shared_ptr<ITcpServer> *)(((char *)impl) + sizeof(ITcpServerHeader)); return (std::shared_ptr<ITcpServer> *)(((char *)impl) + sizeof(ITcpServerHeader));
} }
std::shared_ptr<ITcpClientAccept> *NewTcpClientAccept(const hio_t *io) std::shared_ptr<ITcpClientAccept> *NewTcpClientAccept(const hio_t *io, const ClientAcceptParam &param)
{ {
LogInfo("Create tcp server object.\n"); LogInfo("Create tcp server object.\n");
TcpClientAccept *impl = (TcpClientAccept *)malloc(sizeof(TcpClientAccept)); TcpClientAccept *impl = (TcpClientAccept *)malloc(sizeof(TcpClientAccept));
@ -223,6 +227,6 @@ std::shared_ptr<ITcpClientAccept> *NewTcpClientAccept(const hio_t *io)
impl->mHeader.mCheckName = GetTcpClientAcceptName(); impl->mHeader.mCheckName = GetTcpClientAcceptName();
std::shared_ptr<ITcpClientAccept> *objectThis = std::shared_ptr<ITcpClientAccept> *objectThis =
(std::shared_ptr<ITcpClientAccept> *)(((char *)impl) + sizeof(ITcpServerHeader)); (std::shared_ptr<ITcpClientAccept> *)(((char *)impl) + sizeof(ITcpServerHeader));
impl->mTcpClientAccept = std::make_shared<TcpClientAcceptImpl>(io, objectThis); impl->mTcpClientAccept = std::make_shared<TcpClientAcceptImpl>(io, objectThis, param);
return objectThis; return objectThis;
} }

9
utils/TcpModule/src/TcpServerImpl.h
View File

@ -25,7 +25,7 @@
class TcpClientAcceptImpl : public ITcpClientAccept, public std::enable_shared_from_this<TcpClientAcceptImpl> class TcpClientAcceptImpl : public ITcpClientAccept, public std::enable_shared_from_this<TcpClientAcceptImpl>
{ {
public: public:
TcpClientAcceptImpl(const hio_t *io, const void *object); TcpClientAcceptImpl(const hio_t *io, const void *object, const ClientAcceptParam &param);
virtual ~TcpClientAcceptImpl() = default; virtual ~TcpClientAcceptImpl() = default;
void SetParam(const ClientAcceptParam &param) override; void SetParam(const ClientAcceptParam &param) override;
void Readed(const void *data, size_t length) override; void Readed(const void *data, size_t length) override;
@ -33,10 +33,9 @@ public:
void Closed(void) override; void Closed(void) override;
private: private:
std::mutex mMutex;
const hio_t *mIo; const hio_t *mIo;
ClientAcceptParam mParam;
const void *mObjectThis; const void *mObjectThis;
const ClientAcceptParam mParam;
}; };
class TcpServerImpl : public ITcpServer, public std::enable_shared_from_this<TcpServerImpl> class TcpServerImpl : public ITcpServer, public std::enable_shared_from_this<TcpServerImpl>
{ {
@ -46,7 +45,7 @@ public:
void Init(void) override; void Init(void) override;
void UnInit(void) override; void UnInit(void) override;
void Loop(void); void Loop(void);
void AddClient(hio_t *io, std::shared_ptr<ITcpClientAccept> *client); void AddClient(hio_t *io);
std::shared_ptr<ITcpClientAccept> *GetClient(hio_t *io); std::shared_ptr<ITcpClientAccept> *GetClient(hio_t *io);
void RemoveClient(hio_t *io); void RemoveClient(hio_t *io);
void FreeClients(void); void FreeClients(void);
@ -60,5 +59,5 @@ private:
std::map<int, std::shared_ptr<ITcpClientAccept> *> mClients; std::map<int, std::shared_ptr<ITcpClientAccept> *> mClients;
}; };
std::shared_ptr<ITcpServer> *NewTcpServer(const TcpServerParam &param); std::shared_ptr<ITcpServer> *NewTcpServer(const TcpServerParam &param);
std::shared_ptr<ITcpClientAccept> *NewTcpClientAccept(const hio_t *io); std::shared_ptr<ITcpClientAccept> *NewTcpClientAccept(const hio_t *io, const ClientAcceptParam &param);
#endif #endif