//------------------------------------------------------------------------------------- bool ClientObject::initCreate() { Network::EndPoint* pEndpoint = new Network::EndPoint(); pEndpoint->socket(SOCK_STREAM); if (!pEndpoint->good()) { ERROR_MSG("ClientObject::initNetwork: couldn't create a socket\n"); delete pEndpoint; error_ = C_ERROR_INIT_NETWORK_FAILED; return false; } ENGINE_COMPONENT_INFO& infos = g_kbeSrvConfig.getBots(); u_int32_t address; pEndpoint->convertAddress(infos.login_ip, address); if(pEndpoint->connect(htons(infos.login_port), address) == -1) { ERROR_MSG(fmt::format("ClientObject::initNetwork({1}): connect server({2}:{3}) is error({0})!\n", kbe_strerror(), name_, infos.login_ip, infos.login_port)); delete pEndpoint; // error_ = C_ERROR_INIT_NETWORK_FAILED; state_ = C_STATE_INIT; return false; } Network::Address addr(infos.login_ip, infos.login_port); pEndpoint->addr(addr); pServerChannel_->endpoint(pEndpoint); pEndpoint->setnonblocking(true); pEndpoint->setnodelay(true); pServerChannel_->pMsgHandlers(&ClientInterface::messageHandlers); Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(LoginappInterface::hello); (*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString(); if(Network::g_channelExternalEncryptType == 1) { pBlowfishFilter_ = new Network::BlowfishFilter(); (*pBundle).appendBlob(pBlowfishFilter_->key()); } else { std::string key = ""; (*pBundle).appendBlob(key); } pServerChannel_->pushBundle(pBundle); this->pEndpoint_ = pEndpoint; return true; }
//------------------------------------------------------------------------------------- bool ClientObject::initLoginGateWay() { Bots::getSingleton().pEventPoller()->deregisterForRead(*pServerChannel_->endpoint()); Network::EndPoint* pEndpoint = new Network::EndPoint(); pEndpoint->socket(SOCK_STREAM); if (!pEndpoint->good()) { ERROR_MSG("ClientObject::initLogin: couldn't create a socket\n"); delete pEndpoint; error_ = C_ERROR_INIT_NETWORK_FAILED; return false; } u_int32_t address; pEndpoint->convertAddress(ip_.c_str(), address); if(pEndpoint->connect(htons(port_), address) == -1) { ERROR_MSG(fmt::format("ClientObject::initLogin({}): connect server is error({})!\n", kbe_strerror(), name_)); delete pEndpoint; // error_ = C_ERROR_INIT_NETWORK_FAILED; state_ = C_STATE_LOGIN_GATEWAY_CREATE; return false; } Network::Address addr(ip_.c_str(), port_); pEndpoint->addr(addr); pServerChannel_->endpoint(pEndpoint); pEndpoint->setnonblocking(true); pEndpoint->setnodelay(true); Bots::getSingleton().pEventPoller()->registerForRead((*pEndpoint), this); connectedGateway_ = true; Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(BaseappInterface::hello); (*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString(); if(Network::g_channelExternalEncryptType == 1) { pBlowfishFilter_ = new Network::BlowfishFilter(); (*pBundle).appendBlob(pBlowfishFilter_->key()); pServerChannel_->pFilter(NULL); } else { std::string key = ""; (*pBundle).appendBlob(key); } pServerChannel_->pushBundle(pBundle); return true; }
//------------------------------------------------------------------------------------- int Components::connectComponent(COMPONENT_TYPE componentType, int32 uid, COMPONENT_ID componentID, bool printlog) { Components::ComponentInfos* pComponentInfos = findComponent(componentType, uid, componentID); if (pComponentInfos == NULL) { if (printlog) { ERROR_MSG(fmt::format("Components::connectComponent: not found componentType={}, uid={}, componentID={}!\n", COMPONENT_NAME_EX(componentType), uid, componentID)); } return -1; } Network::EndPoint * pEndpoint = Network::EndPoint::createPoolObject(); pEndpoint->socket(SOCK_STREAM); if (!pEndpoint->good()) { if (printlog) { ERROR_MSG("Components::connectComponent: couldn't create a socket\n"); } Network::EndPoint::reclaimPoolObject(pEndpoint); return -1; } pEndpoint->addr(*pComponentInfos->pIntAddr); int ret = pEndpoint->connect(pComponentInfos->pIntAddr->port, pComponentInfos->pIntAddr->ip); if(ret == 0) { Network::Channel* pChannel = Network::Channel::createPoolObject(); bool ret = pChannel->initialize(*_pNetworkInterface, pEndpoint, Network::Channel::INTERNAL); if(!ret) { if (printlog) { ERROR_MSG(fmt::format("Components::connectComponent: initialize({}) is failed!\n", pChannel->c_str())); } pChannel->destroy(); Network::Channel::reclaimPoolObject(pChannel); return -1; } pComponentInfos->pChannel = pChannel; pComponentInfos->pChannel->componentID(componentID); if(!_pNetworkInterface->registerChannel(pComponentInfos->pChannel)) { if (printlog) { ERROR_MSG(fmt::format("Components::connectComponent: registerChannel({}) is failed!\n", pComponentInfos->pChannel->c_str())); } pComponentInfos->pChannel->destroy(); Network::Channel::reclaimPoolObject(pComponentInfos->pChannel); // 此时不可强制释放内存,destroy中已经对其减引用 // SAFE_RELEASE(pComponentInfos->pChannel); pComponentInfos->pChannel = NULL; return -1; } else { Network::Bundle* pBundle = Network::Bundle::createPoolObject(); if(componentType == BASEAPPMGR_TYPE) { (*pBundle).newMessage(BaseappmgrInterface::onRegisterNewApp); BaseappmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else if(componentType == CELLAPPMGR_TYPE) { (*pBundle).newMessage(CellappmgrInterface::onRegisterNewApp); CellappmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else if(componentType == CELLAPP_TYPE) { (*pBundle).newMessage(CellappInterface::onRegisterNewApp); CellappInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else if(componentType == BASEAPP_TYPE) { (*pBundle).newMessage(BaseappInterface::onRegisterNewApp); BaseappInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else if(componentType == DBMGR_TYPE) { (*pBundle).newMessage(DbmgrInterface::onRegisterNewApp); DbmgrInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else if(componentType == LOGGER_TYPE) { (*pBundle).newMessage(LoggerInterface::onRegisterNewApp); LoggerInterface::onRegisterNewAppArgs11::staticAddToBundle((*pBundle), getUserUID(), getUsername(), componentType_, componentID_, g_componentGlobalOrder, g_componentGroupOrder, _pNetworkInterface->intaddr().ip, _pNetworkInterface->intaddr().port, _pNetworkInterface->extaddr().ip, _pNetworkInterface->extaddr().port, g_kbeSrvConfig.getConfig().externalAddress); } else { KBE_ASSERT(false && "invalid componentType.\n"); } pComponentInfos->pChannel->send(pBundle); } } else { if (printlog) { ERROR_MSG(fmt::format("Components::connectComponent: connect({}) is failed! {}.\n", pComponentInfos->pIntAddr->c_str(), kbe_strerror())); } Network::EndPoint::reclaimPoolObject(pEndpoint); return -1; } return ret; }
//------------------------------------------------------------------------------------- bool ClientObject::initLoginGateWay() { Bots::getSingleton().networkInterface().dispatcher().deregisterReadFileDescriptor(*pTCPPacketReceiverEx_->pEndPoint()); pServerChannel_->stopSend(); pServerChannel_->pPacketSender(NULL); SAFE_RELEASE(pTCPPacketSenderEx_); SAFE_RELEASE(pTCPPacketReceiverEx_); Network::EndPoint* pEndpoint = Network::EndPoint::ObjPool().createObject(); pEndpoint->socket(SOCK_STREAM); if (!pEndpoint->good()) { ERROR_MSG("ClientObject::initLogin: couldn't create a socket\n"); Network::EndPoint::ObjPool().reclaimObject(pEndpoint); error_ = C_ERROR_INIT_NETWORK_FAILED; return false; } u_int32_t address; Network::Address::string2ip(ip_.c_str(), address); if(pEndpoint->connect(htons(port_), address) == -1) { ERROR_MSG(fmt::format("ClientObject::initLogin({}): connect server is error({})!\n", kbe_strerror(), name_)); Network::EndPoint::ObjPool().reclaimObject(pEndpoint); // error_ = C_ERROR_INIT_NETWORK_FAILED; state_ = C_STATE_LOGIN_GATEWAY_CREATE; return false; } Network::Address addr(ip_.c_str(), port_); pEndpoint->addr(addr); pServerChannel_->pEndPoint(pEndpoint); pEndpoint->setnonblocking(true); pEndpoint->setnodelay(true); pTCPPacketSenderEx_ = new Network::TCPPacketSenderEx(*pEndpoint, this->networkInterface_, this); pTCPPacketReceiverEx_ = new Network::TCPPacketReceiverEx(*pEndpoint, this->networkInterface_, this); Bots::getSingleton().networkInterface().dispatcher().registerReadFileDescriptor((*pEndpoint), pTCPPacketReceiverEx_); //²»ÔÚÕâÀï×¢²á //Bots::getSingleton().networkInterface().dispatcher().registerWriteFileDescriptor((*pEndpoint), pTCPPacketSenderEx_); pServerChannel_->pPacketSender(pTCPPacketSenderEx_); connectedGateway_ = true; Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(BaseappInterface::hello); (*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString(); if(Network::g_channelExternalEncryptType == 1) { pBlowfishFilter_ = new Network::BlowfishFilter(); (*pBundle).appendBlob(pBlowfishFilter_->key()); pServerChannel_->pFilter(NULL); } else { std::string key = ""; (*pBundle).appendBlob(key); } pEndpoint->send(pBundle); Network::Bundle::ObjPool().reclaimObject(pBundle); return true; }
//------------------------------------------------------------------------------------- bool ClientObject::initCreate() { Network::EndPoint* pEndpoint = Network::EndPoint::ObjPool().createObject(); pEndpoint->socket(SOCK_STREAM); if (!pEndpoint->good()) { ERROR_MSG("ClientObject::initNetwork: couldn't create a socket\n"); Network::EndPoint::ObjPool().reclaimObject(pEndpoint); error_ = C_ERROR_INIT_NETWORK_FAILED; return false; } ENGINE_COMPONENT_INFO& infos = g_kbeSrvConfig.getBots(); u_int32_t address; Network::Address::string2ip(infos.login_ip, address); if(pEndpoint->connect(htons(infos.login_port), address) == -1) { ERROR_MSG(fmt::format("ClientObject::initNetwork({1}): connect server({2}:{3}) is error({0})!\n", kbe_strerror(), name_, infos.login_ip, infos.login_port)); Network::EndPoint::ObjPool().reclaimObject(pEndpoint); // error_ = C_ERROR_INIT_NETWORK_FAILED; state_ = C_STATE_INIT; return false; } Network::Address addr(infos.login_ip, infos.login_port); pEndpoint->addr(addr); pServerChannel_->pEndPoint(pEndpoint); pEndpoint->setnonblocking(true); pEndpoint->setnodelay(true); pServerChannel_->pMsgHandlers(&ClientInterface::messageHandlers); pTCPPacketSenderEx_ = new Network::TCPPacketSenderEx(*pEndpoint, this->networkInterface_, this); pTCPPacketReceiverEx_ = new Network::TCPPacketReceiverEx(*pEndpoint, this->networkInterface_, this); Bots::getSingleton().networkInterface().dispatcher().registerReadFileDescriptor((*pEndpoint), pTCPPacketReceiverEx_); //²»ÔÚÕâÀï×¢²á //Bots::getSingleton().networkInterface().dispatcher().registerWriteFileDescriptor((*pEndpoint), pTCPPacketSenderEx_); pServerChannel_->pPacketSender(pTCPPacketSenderEx_); Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject(); (*pBundle).newMessage(LoginappInterface::hello); (*pBundle) << KBEVersion::versionString() << KBEVersion::scriptVersionString(); if(Network::g_channelExternalEncryptType == 1) { pBlowfishFilter_ = new Network::BlowfishFilter(); (*pBundle).appendBlob(pBlowfishFilter_->key()); } else { std::string key = ""; (*pBundle).appendBlob(key); } pEndpoint->send(pBundle); Network::Bundle::ObjPool().reclaimObject(pBundle); return true; }
//------------------------------------------------------------------------------------- bool InterfacesHandler_Interfaces::reconnect() { Network::Channel* pInterfacesChannel = Dbmgr::getSingleton().networkInterface().findChannel(g_kbeSrvConfig.interfacesAddr()); if(pInterfacesChannel) { if(!pInterfacesChannel->isDestroyed()) Dbmgr::getSingleton().networkInterface().deregisterChannel(pInterfacesChannel); pInterfacesChannel->destroy(); Network::Channel::reclaimPoolObject(pInterfacesChannel); } Network::Address addr = g_kbeSrvConfig.interfacesAddr(); Network::EndPoint* pEndPoint = Network::EndPoint::createPoolObject(); pEndPoint->addr(addr); pEndPoint->socket(SOCK_STREAM); if (!pEndPoint->good()) { ERROR_MSG("InterfacesHandler_Interfaces::initialize: couldn't create a socket\n"); return true; } pEndPoint->setnonblocking(true); pEndPoint->setnodelay(true); pInterfacesChannel = Network::Channel::createPoolObject(); bool ret = pInterfacesChannel->initialize(Dbmgr::getSingleton().networkInterface(), pEndPoint, Network::Channel::INTERNAL); if(!ret) { ERROR_MSG(fmt::format("InterfacesHandler_Interfaces::initialize: initialize({}) is failed!\n", pInterfacesChannel->c_str())); pInterfacesChannel->destroy(); Network::Channel::reclaimPoolObject(pInterfacesChannel); return 0; } if(pInterfacesChannel->pEndPoint()->connect() == -1) { struct timeval tv = { 0, 1000000 }; // 1000ms fd_set fds; FD_ZERO(&fds); FD_SET((int)(*pInterfacesChannel->pEndPoint()), &fds); bool connected = false; int selgot = select((*pInterfacesChannel->pEndPoint())+1, &fds, &fds, NULL, &tv); if(selgot > 0) { int error; socklen_t len = sizeof(error); #if KBE_PLATFORM == PLATFORM_WIN32 getsockopt(int(*pInterfacesChannel->pEndPoint()), SOL_SOCKET, SO_ERROR, (char*)&error, &len); #else getsockopt(int(*pInterfacesChannel->pEndPoint()), SOL_SOCKET, SO_ERROR, &error, &len); #endif if(0 == error) connected = true; } if(!connected) { ERROR_MSG(fmt::format("InterfacesHandler_Interfaces::reconnect(): couldn't connect to:{}\n", pInterfacesChannel->pEndPoint()->addr().c_str())); pInterfacesChannel->destroy(); Network::Channel::reclaimPoolObject(pInterfacesChannel); return false; } } // 不检查超时 pInterfacesChannel->stopInactivityDetection(); Dbmgr::getSingleton().networkInterface().registerChannel(pInterfacesChannel); return true; }