ucnet.h
#ifndef UCODE_UCNET_H_
#define UCODE_UCNET_H_
#include "ucbase.h"
#include "ucconfig.h"
#include "uclogger.h"
namespace UCODE{
/**
* @brief UCNet组件模块版本
*/
static const SUCODEVersion UCNET_MODULE_VERSION = {1, 0, 0, 0};
/**
* @brief UCNet module name
*/
const char UCNET_MODULENAME[] = "UCNet";
/**
* @brief UCNet version
*/
const SUCODEVersion UCNET_VERSION = UCNET_MODULE_VERSION;
/**
* @brief Error code of UCNet
*/
enum ESDNetErrCode{
NET_BIND_FAIL = -7,
NET_CONNECT_FAIL = -6,
NET_SYSTEM_ERROR = -5,
NET_RECV_ERROR = -4,
NET_SEND_ERROR = -3,
NET_SEND_OVERFLOW = -2,
NET_PACKET_ERROR = -1,
NET_SUCCESS = 0
};
/**
* @brief 创建ISDConnector或ISDListener时,用户需要指定网络I/O模型。
*/
/**
* @brief 完成端口
*/
const UINT32 NETIO_COMPLETIONPORT = 0x0001;
/**
* @brief 完成端口,使用sdgate组件
*/
const UINT32 NETIO_COMPLETIONPORT_GATE = 0x0002;
/**
* @brief 每次收到数据时,在网络线程中回调给应用
*/
const UINT32 NET_THREADED = 0x0004;
/**
* @brief 每次收到数据时,将在主线程中回调给应用
*/
const UINT32 NET_NONETHREADED = 0x0008;
/**
* @brief 异步I/O的select网络模型,客户端用。
*/
const UINT32 NETIO_ASYNCSELECT = 2;
/**
* @brief linux下epoll网络模型
*/
const UINT32 NETIO_EPOLL = 0x0010;
/**
* @brief linux下epoll网络模型,选用sdgate组件
*/
const UINT32 NETIO_EPOLL_GATE = 0x0020;
const UINT32 INVALID_IO_TYPE = 0xFFFFFFFF;
const UINT32 UNKNOWN_SIZE = 0xFFFFFFFF;
class ISDPacketParser;
class ISDSession;
class ISDSessionFactory;
/**
* @brief An ISDConnection object represent an abstraction of a TCP connection
*/
class ISDConnection
{
public:
/**
* @brief Check if the connection is connected
* @return true means connected, otherwise, false
*/
virtual bool UCAPI IsConnected(void) = 0;
/**
* @brief Send data on the connection
* @param pBuf : data buffer need to send
* @param dwLen : data buffer length
*/
virtual void UCAPI Send(const char* pBuf,UINT32 dwLen) = 0;
/**
* @brief Set extension options
* @param dwType : option type
* @param pOpt : option value
*/
virtual void UCAPI SetOpt(UINT32 dwType, void* pOpt) = 0;
/**
* @brief Close the TCP connection
*/
virtual void UCAPI Disconnect(void) = 0;
/**
* @brief Retrieves remote IP address for the connection
* @return IP address four bytes unsigned integer
*/
virtual const UINT32 UCAPI GetRemoteIP(void) = 0;
/**
* @brief Retrieves remote IP address in text format for the connection
* @return IP address string
*/
virtual const char* UCAPI GetRemoteIPStr(void) = 0;
/**
* @brief Retrieves remote port number for the connection
* @return port number
*/
virtual UINT16 UCAPI GetRemotePort(void) = 0;
/**
* @brief Retrieves local IP address for the connection
* @return IP address four bytes unsigned integer
*/
virtual const UINT32 UCAPI GetLocalIP(void) = 0;
/**
* @brief Retrieves local IP address in text format for the connection
* @return IP address string
*/
virtual const char* UCAPI GetLocalIPStr(void) = 0;
/**
* @brief Retrieves local port number for the connection
* @return port number
*/
virtual UINT16 UCAPI GetLocalPort(void) = 0;
/**
* @brief Retrieves local send buffer's free size
* @return local send buffer's free size in bytes
*/
virtual UINT32 UCAPI GetSendBufFree(void) = 0;
};
/**
* @brief The interface provides functionality for TCP listening
*/
class ISDListener
{
public:
/**
* @brief Set an user implemented ISDPacketParser object, which process
* packet parse logic of the connection accepted by the ISDListener
* @param poPacketParser ISDPacketParser instance pointer
*/
virtual void UCAPI SetPacketParser(ISDPacketParser* poPacketParser) = 0;
/**
* @brief Set the user implemented ISDSessionFactory object to ISDListener
*
* When a TCP connection is accepted by ISDListener,
* ISDSessionFactory object will be asked to create a ISDSession
* @param poSessionFactory ISDSessionFactory instance factory
*/
virtual void UCAPI SetSessionFactory(ISDSessionFactory* poSessionFactory) = 0;
/**
* @brief Set the send and receive buffer size of the connection accepted by the ISDListener object
* @param dwRecvBufSize : receiving buffer size in bytes
* @param dwSendBufSize : sending buffer size in bytes
*/
virtual void UCAPI SetBufferSize(UINT32 dwRecvBufSize, UINT32 dwSendBufSize) = 0;
/**
* @brief Set extension options
* @param dwType : option type
* @param pOpt : option value
*/
virtual void UCAPI SetOpt(UINT32 dwType, void* pOpt) = 0;
/**
* @brief Listen at specified IP and port
* @param pszIP : IP string
* @param wPort : port number
* @param bReUseAddr : the flag for re-using same address
* @return true means success, false means failure
*/
virtual bool UCAPI Start(const char* pszIP, UINT16 wPort, bool bReUseAddr = true) = 0;
/**
* @brief Stop listening
* @return true means success, false means failure
*/
virtual bool UCAPI Stop(void) = 0;
/**
* @brief Release the ISDListener object
*/
virtual void UCAPI Release(void) = 0;
};
/**
* @brief The interface provides functionality for initiative TCP connection
*/
class ISDConnector
{
public:
/**
* @brief Set the user implemented ISDPacketParser object, which process
* packet parse logic of the connection connected by the ISDConnector
* object
* @param poPakcetParser ISDPacketParser instance pointer
*/
virtual void UCAPI SetPacketParser(ISDPacketParser* poPakcetParser) = 0;
/**
* @brief Set the user implemented ISDSession object, which will be bind
* to ISDConnection object when connection establishes
* @param poSession ISDSession instance pointer
*/
virtual void UCAPI SetSession(ISDSession* poSession) = 0;
/**
* @brief Set the send and receive buffer size for the connection connected
* by the ISDConnector object
* @param dwRecvBufSize : receiving buffer size in bytes
* @param dwSendBufSize : sending buffer size in bytes
*/
virtual void UCAPI SetBufferSize(UINT32 dwRecvBufSize, UINT32 dwSendBufSize) = 0;
/**
* @brief Connect to the specified address
* @param pszIP : IP string
* @param wPort : port number
* @return true means success, false means failure
*/
virtual bool UCAPI Connect(const char* pszIP, UINT16 wPort) = 0;
/**
* @brief Reconnect to the address which is specified by the last Connect call
* @return true means success, false means failure
*/
virtual bool UCAPI ReConnect(void) = 0;
/**
* @brief Release the ISDConnector object
*/
virtual void UCAPI Release(void) = 0;
/**
* @brief Set extension options
* @param dwType : option type
* @param pOpt : option value
*/
virtual void UCAPI SetOpt(UINT32 dwType, void* pOpt) = 0;
};
/**
* @brief Interface of SDNet module
*/
class IUCNet : public ISDBase
{
public:
/**
* @brief Create an ISDConnector object
* @param dwNetIOType : Network I/O type
* @return ISDConnector instance pointer
*/
virtual ISDConnector* UCAPI CreateConnector(UINT32 dwNetIOType) = 0;
/**
* @brief Create an ISDListener object
* @param dwNetIOType : Network I/O type
* @return ISDListener instance pointer
*/
virtual ISDListener* UCAPI CreateListener(UINT32 dwNetIOType) = 0;
/**
* @brief Process network event
* @param nCount : the count of loop
* @return true means success, false means failure
*/
virtual bool UCAPI Run(INT32 nCount = -1) = 0;
};
/**
* @brief Break packet from TCP data stream. The interface need to be implemented by user
*/
class ISDPacketParser
{
public:
/**
* @brief Return the length in bytes of the packet in TCP data stream
* @param pBuf : the data buffer need to parse
* @param dwLen : the data buffer length
*/
virtual INT32 UCAPI ParsePacket(const char* pBuf, UINT32 dwLen) = 0;
};
/**
* @brief When network event happens, the related function of ISDSession
* will be callback. User need to implement ISDSession
*/
class ISDSession
{
public:
/**
* @brief Set the ISDConnection object to the ISDSession object
* @param poConnection : ISDConnection instance pointer
*/
virtual void UCAPI SetConnection(ISDConnection* poConnection) = 0;
/**
* @brief Callback when the connection is established
*/
virtual void UCAPI OnEstablish(void) = 0;
/**
* @brief Callback when the connection is closed
*/
virtual void UCAPI OnTerminate(void) = 0;
/**
* @brief Callback when TCP connection has error
*/
virtual bool UCAPI OnError(INT32 nModuleErr, INT32 nSysErr) = 0;
/**
* @brief Callback when receive a packet, which is parsed by ISDPacketParser
* @param pBuf : data buffer pointer which hold data
* @param dwLen : buffer length
*/
virtual void UCAPI OnRecv(const char* pBuf, UINT32 dwLen) = 0;
#ifdef SDNET_HAS_SEND_REPORT
/**
* @brief Callback when send success, used in asynch mode
* @param pBuf : left data in buffer
* @param left : data length in buffer
* @warning don't send the data again
*/
virtual void UCAPI OnSend(const char* pBuf, UINT32 dwLen)
{
}
#endif
/**
* @brief Release ISDSession object
*/
virtual void UCAPI Release(void) = 0;
};
/**
* @brief Create user implemented ISDSession object. This interface need to be implemented by user too
*/
class ISDSessionFactory
{
public:
/**
* @brief Create an user implemented ISDSession object
* @param poConnection : ISDConnection instance pointer
* @return ISDSession instance pointer
*/
virtual ISDSession* UCAPI CreateSession(ISDConnection* poConnection) = 0;
};
/**
* @brief Get an SDNet object
* @param pstVersion : the version of SDNet
* @return IUCNet instance pointer
*/
UCODE_NET_FUN IUCNet* UCAPI SDNetGetModule(const SUCODEVersion* pstVersion);
/**
* @brief Function pointer definition of SDNetGetModule
*/
typedef IUCNet* (UCAPI *PFN_SDNetGetModule)(const SUCODEVersion* pstVersion);
/**
* @brief Set ISDLogger object to the SDNet. The log of SDNet will export to the ISDLogger object
* @param poLogger : ISDLogger instance pointer
* @param dwLevel : log level
* @return true means success, false means failure
*/
UCODE_NET_FUN bool UCAPI SDNetSetLogger(ISDLogger* poLogger, UINT32 dwLevel);
/**
* @brief Function pointer definition of SDNetSetLogger
*/
typedef bool (UCAPI *PFN_SDNetSetLogger)(ISDLogger* poLogger, UINT32 dwLevel);
/**
* @brief Set extension options
* @param dwType : option type
* @param pOpt : option value
*/
UCODE_NET_FUN void UCAPI SDNetSetOpt(UINT32 dwType, void* pOpt);
}
#endif
INetSession.h
class INetSession : public ISDSession
{
public:
INetSession();
virtual ~INetSession();
public:
UINT32 GetID() { return mID; }
void SetID(UINT32 id) { mID=id; }
UINT32 GetLogicID() { return mLogicID; }
void SetLogicID(UINT32 logicId) { mLogicID = logicId; }
UINT32 GetType() { return mType; }
void SetType(UINT32 type) { mType = type; }
void SetSendBufferMaxSize(UINT32 maxsize) { mSendBufferMaxSize = maxsize; }
void Close();
void DelayClose(UINT32 error_code,UINT32 delayCount=10);
bool IsConned() { if(mConnection && mConnection->IsConnected()) return true; return false; }
const char* GetRemoteIp() { return mConnection!=NULL?mConnection->GetRemoteIPStr():""; }
UINT32 GetRemoteIpEx() { return mConnection!=NULL?mConnection->GetRemoteIP():0; }
UINT32 GetRemotePort() { return mConnection!=NULL?mConnection->GetRemotePort():0; }
bool IsClosed() { return mCloseTime>0; }
void SetInited(bool isInited,bool isTrigger=false);//call this func will trigger any logic.
bool Send(const char* pBuf,UINT32 dwLen);
void SetMsgHandle(IMsgHandle* pMsgHandle) { mMsgHandle = pMsgHandle; }
virtual void Update();
protected:
bool IsHadRecon() { return mReconFlag; }
void ResetRecon() { mReconFlag = false; }
bool IsInited() { return mIsInited; }
bool IsRemoteInited() { return mIsRemoteInited; }
void SetRemoteInited(bool isInited) { mIsRemoteInited = isInited; }
protected:
virtual void SendInitData() = 0;
virtual void OnRealEstablish() = 0;
virtual void OnClose() = 0;
public:
virtual void UCAPI SetConnection(ISDConnection* poConnection);
virtual void UCAPI OnEstablish(void);
virtual void UCAPI OnTerminate(void);
virtual bool UCAPI OnError(INT32 nModuleErr, INT32 nSysErr);
virtual void UCAPI OnRecv(const char* pBuf, UINT32 dwLen);
virtual void UCAPI Release(void) {}
protected:
bool mIsInited;
bool mIsRemoteInited;
bool mReconFlag;
bool mIsUseBuffer;
bool mIsSrvCli;
volatile bool mIsLogicClosed;
UINT32 mType;
UINT32 mLogicID;
UINT32 mID;
static UINT32 mMaxID;
ISDConnection* mConnection;
UINT32 mStartTime;
UINT32 mCloseTime;
vector<char> mBuffers;
IMsgHandle* mMsgHandle;
volatile UINT32 mCloseDelayCount;
UINT32 mSendBufferMaxSize;//send buffer max size//
};
ICliSession.h
class ICliSession : public INetSession
{
public:
ICliSession();
virtual ~ICliSession();
public:
bool Reconnect();
bool Reconnect(const char* ip, UINT32 port);
void SetConnector(ISDConnector* connector) { m_poConnector=connector; }
void SetRemoteEndPointer(const char* ip,UINT32 port);
virtual void Update();
void SetCanReconnectTag(bool can){mReconnectTag = can;}
bool GetCanReconnectTag(){return mReconnectTag;}
public:
virtual void UCAPI OnEstablish(void);
virtual void UCAPI Release(void) {/触发重连,不释放该对象/}
private:
ISDConnector* m_poConnector;
UINT32 mReconTime;
string mRemoteEndPointer;
bool mReconnectTag;
};
ISrvCliSession .h
class ISrvCliSession : public INetSession
{
public:
ISrvCliSession();
virtual ~ISrvCliSession();
public:
virtual void UCAPI Release(void) {delete this;/*释放该对象*/}
};
class ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* poConnection) = 0;
};
class CGateSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
下面是BSNetSessionMgr.cpp
#include "../stdafx.h"
#include "BSNetSessionMgr.h"
#include "B2LSession.h"
#include "GateSession.h"
#include "ClientSession.h"
CGateSessionFactory gGateSessionFactory;
CClientSessionFactory gClientSessionFactory;
CBSNetSessionMgr::CBSNetSessionMgr()
{
}
CBSNetSessionMgr::~CBSNetSessionMgr()
{
}
ICliSession* UCAPI CBSNetSessionMgr::CreateConnectorSession(SESSION_TYPE type)
{
ICliSession* pSession = NULL;
if (type==ST_CLIENT_B2L)
{
pSession = new CB2LSession();
pSession->SetType(ST_CLIENT_B2L);
pSession->SetMsgHandle(&CB2LSession::mHandles);
}
return pSession;
}
ISDSession* UCAPI CGateSessionFactory::CreateSession( ISDConnection* pConnection )
{
CGateSession* pSession = new CGateSession();
pSession->SetType(ST_SERVER_BS_OnlyGS);
pSession->SetMsgHandle(&CGateSession::mHandles);
return pSession;
}
ISDSession* UCAPI CClientSessionFactory::CreateSession( ISDConnection* pConnection )
{
CClientSession* pSession = new CClientSession();
pSession->SetType(ST_SERVER_BS_OnlyGC);
pSession->SetMsgHandle(&CClientSession::mHandles);
return pSession;
}
下面是BSNetSessionMgr.h
#pragma once
#include "../../../Share/Net/INetSessionMgr.h"
class CBSNetSessionMgr : public INetSessionMgr
{
public:
CBSNetSessionMgr();
virtual ~CBSNetSessionMgr();
public:
bool getnetip(string& ipaddr,int pos)
{
char host_name[255];
if (gethostname(host_name, sizeof(host_name)) == SOCKET_ERROR) {
return false;
}
struct hostent *phe = gethostbyname(host_name);
if (phe == 0) {
return false;
}
for (int i = 0; phe->h_addr_list[i] != 0; ++i)
{
if (pos==i)
{
struct in_addr addr;
memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
ipaddr = inet_ntoa(addr);
return true;
}
}
return false;
}
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection) { return NULL; /*重写*/}
virtual ICliSession* UCAPI CreateConnectorSession(SESSION_TYPE type);
};
class CGateSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
class CClientSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
extern CGateSessionFactory gGateSessionFactory;
extern CClientSessionFactory gClientSessionFactory;
下面是CSNetSessionMgr.cpp
#include "../stdafx.h"
#include "CSNetSessionMgr.h"
#include "GateSession.h"
#include "SceneSession.h"
#include "RemoteConsoleSession.h"
#include "CSLogSession.h"
#include "RedisSession.h"
#include "LogicRedisSession.h"
CGateSessionFactory gGateSessionFactory;
CSceneSessionFactory gSceneSessionFactory;
CRemoteConsoleSessionFactory gRemoteConsoleFactory;
CSNetSessionMgr::CSNetSessionMgr()
{
}
CSNetSessionMgr::~CSNetSessionMgr()
{
}
ICliSession* UCAPI CSNetSessionMgr::CreateConnectorSession(SESSION_TYPE type){
ICliSession* pSession = NULL;
if (type==ST_CLIENT_C2R)
{
pSession = new CRedisSession();
pSession->SetType(ST_CLIENT_C2R);
pSession->SetMsgHandle(&CRedisSession::mHandles);
}
else if (type==ST_CLIENT_C2LogicRedis){
pSession = new CLogicRedisSession();
pSession->SetType(ST_CLIENT_C2LogicRedis);
}
else if (type == ST_CLIENT_C2Log){
pSession = new CCSLogSession();
pSession->SetType(ST_CLIENT_C2Log);
pSession->SetMsgHandle(&CCSLogSession::mHandles);
}
return pSession;
}
bool CSNetSessionMgr::CreateConnector(SESSION_TYPE type, const char* ip, int port, int recvsize, int sendsize, int logicId)
{
ISDConnector* pConnector = mNetModule->CreateConnector(NETIO_COMPLETIONPORT);
ICliSession* pSession = CreateConnectorSession(type);
UINT32 sId = AddSession(pSession);
Assert(sId!=PP_INVALID);
pSession->SetID(sId);
pSession->SetLogicID(logicId);
pSession->SetConnector(pConnector);
pSession->SetRemoteEndPointer(ip,port);
pConnector->SetSession(pSession);
if (type == ST_CLIENT_C2R || type == ST_CLIENT_C2LogicRedis)
pConnector->SetPacketParser(&m_CSParser);
else
pConnector->SetPacketParser(this);
pConnector->SetBufferSize(recvsize,sendsize);
return pConnector->Connect(ip,port);
}
ISDSession* UCAPI CGateSessionFactory::CreateSession( ISDConnection* pConnection )
{
CGateSession* pSession = new CGateSession();
pSession->SetType(ST_SERVER_CS_OnlyGS);
pSession->SetMsgHandle(&CGateSession::mHandles);
return pSession;
}
ISDSession* UCAPI CSceneSessionFactory::CreateSession( ISDConnection* pConnection )
{
CSceneSession* pSession = new CSceneSession();
pSession->SetType(ST_SERVER_CS_OnlySS);
pSession->SetMsgHandle(&CSceneSession::mHandles);
return pSession;
}
ISDSession* UCAPI CRemoteConsoleSessionFactory::CreateSession( ISDConnection* pConnection )
{
CRemoteConsoleSession* pSession = new CRemoteConsoleSession();
pSession->SetType(ST_SERVER_CS_OnlyRC);
pSession->SetMsgHandle(&CRemoteConsoleSession::mHandles);
return pSession;
}
下面是CSNetSessionMgr.h
#pragma once
#include "../../Share/Net/INetSessionMgr.h"
#include "ParsePacket.h"
class CSNetSessionMgr : public INetSessionMgr
{
public:
CSNetSessionMgr();
virtual ~CSNetSessionMgr();
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection) { return NULL; /*重写*/}
virtual ICliSession* UCAPI CreateConnectorSession(SESSION_TYPE type);
virtual bool CreateConnector(SESSION_TYPE type, const char* ip, int port, int recvsize, int sendsize, int logicId);
private:
CSParser m_CSParser;
};
class CGateSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
class CSceneSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
class CRemoteConsoleSessionFactory : public ISDSessionFactory
{
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
};
extern CGateSessionFactory gGateSessionFactory;
extern CSceneSessionFactory gSceneSessionFactory;
extern CRemoteConsoleSessionFactory gRemoteConsoleFactory;
下面是GSNetSessionMgr.cpp
#include "stdafx.h"
#include "GSNetSessionMgr.h"
#include "ClientSession.h"
#include "M2CSession.h"
#include "M2SSession.h"
#include "M2BSession.h"
SProfileNet gProfileNet = {0};
GSNetSessionMgr::GSNetSessionMgr()
{
}
GSNetSessionMgr::~GSNetSessionMgr()
{
}
ISDSession* UCAPI GSNetSessionMgr::CreateSession( ISDConnection* pConnection )
{
CClientSession* pSession = new CClientSession();
pSession->SetType(ST_SERVER_GS);
pSession->SetMsgHandle(&CClientSession::mHandles);
return pSession;
}
ICliSession* UCAPI GSNetSessionMgr::CreateConnectorSession( SESSION_TYPE type )
{
ICliSession* pSession = NULL;
if (type==ST_CLIENT_G2C)
{
pSession = new CM2CSession();
pSession->SetType(ST_CLIENT_G2C);
pSession->SetMsgHandle(&CM2CSession::mHandles);
}
else if (type==ST_CLIENT_G2S)
{
pSession = new CM2SSession();
pSession->SetType(ST_CLIENT_G2S);
pSession->SetMsgHandle(&CM2SSession::mHandles);
}
else if (type==ST_CLIENT_G2B)
{
pSession = new CM2BSession();
pSession->SetType(ST_CLIENT_G2B);
pSession->SetMsgHandle(&CM2BSession::mHandles);
}
return pSession;
}
下面是GSNetSessionMgr .h
#pragma once
#include "../../Share/Net/INetSessionMgr.h"
#include "ClientSession.h"
struct SProfileNet
{
UINT32 mClientCount;
UINT32 mTimeForDealWithMsg;//处理消息时间//
UINT32 mTimeForDealWithOther;//其他网络时间//
std::map<UINT32,UINT32> mMessageCount;//消息数量//
};
extern SProfileNet gProfileNet;
class GSNetSessionMgr : public INetSessionMgr
{
public:
GSNetSessionMgr();
virtual ~GSNetSessionMgr();
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
virtual ICliSession* UCAPI CreateConnectorSession(SESSION_TYPE type);
};
下面是SSBattleNetSessionMgr.h
#pragma once
#include "../../Share/Net/INetSessionMgr.h"
class SSBattleNetSessionMgr : public INetSessionMgr
{
public:
SSBattleNetSessionMgr();
virtual ~SSBattleNetSessionMgr();
public:
virtual ISDSession* UCAPI CreateSession(ISDConnection* pConnection);
virtual ICliSession* UCAPI CreateConnectorSession(SESSION_TYPE type);
};
SSBattleNetSessionMgr.cpp
#include "../stdafx.h"
#include "SSBattleNetSessionMgr.h"
#include "GateSession.h"
#include "CentralSession.h"
#include "SSLogSession.h"
SSBattleNetSessionMgr::SSBattleNetSessionMgr()
{
mIsUnSafeSend = true;
}
SSBattleNetSessionMgr::~SSBattleNetSessionMgr()
{
}
ISDSession* UCAPI SSBattleNetSessionMgr::CreateSession( ISDConnection* pConnection )
{
CGateSession* pSession = new CGateSession();
pSession->SetType(ST_SERVER_SS);
pSession->SetMsgHandle(&CGateSession::mHandles);
return pSession;
}
ICliSession* UCAPI SSBattleNetSessionMgr::CreateConnectorSession( SESSION_TYPE type )
{
ICliSession* pSession = NULL;
if (type==ST_CLIENT_S2C)
{
pSession = new CCentralSession();
pSession->SetType(ST_CLIENT_S2C);
pSession->SetMsgHandle(&CCentralSession::mHandles);
}
else if (type == ST_CLIENT_S2Log){
pSession = new CSSLogSession();
pSession->SetType(ST_CLIENT_S2Log);
pSession->SetMsgHandle(&CSSLogSession::mHandles);
}
return pSession;
}
下面是ucnet.h
class ISDSessionFactory
{
public:
/**
* @brief Create an user implemented ISDSession object
* @param poConnection : ISDConnection instance pointer
* @return ISDSession instance pointer
*/
virtual ISDSession* UCAPI CreateSession(ISDConnection* poConnection) = 0;
};
FR:海涛高软(hunk Xu) QQ技术交流群:386476712