//-------------------------------------------------------------------------------------
int TelnetServer::handleInputNotification(int fd)
{
KBE_ASSERT(listener_ == fd);
int tickcount = 0;
while(tickcount ++ < 1024)
{
Network::EndPoint* pNewEndPoint = listener_.accept();
if(pNewEndPoint == NULL){
if(tickcount == 1)
{
WARNING_MSG(fmt::format("TelnetServer::handleInputNotification: accept endpoint({}) {}!\n",
fd, kbe_strerror()));
}
break;
}
else
{
TelnetHandler* pTelnetHandler = new TelnetHandler(pNewEndPoint, this, pNetworkInterface_, passwd_.size() > 0 ?
TelnetHandler::TELNET_STATE_PASSWD : (TelnetHandler::TELNET_STATE)this->deflayer());
if(!pDispatcher_->registerReadFileDescriptor((*pNewEndPoint), pTelnetHandler))
{
ERROR_MSG(fmt::format("TelnetServer::start:: registerReadFileDescriptor(pTelnetHandler) is failed! addr={}\n",
pNewEndPoint->c_str()));
delete pTelnetHandler;
continue;
}
INFO_MSG(fmt::format("TelnetServer::handleInputNotification: new handler({})!\n",
pNewEndPoint->c_str()));
handlers_[(*pNewEndPoint)].reset(pTelnetHandler);
std::string s;
if(passwd_.size() > 0)
{
s = "password:";
}
else
{
s = pTelnetHandler->getWelcome();
}
pNewEndPoint->send(s.c_str(), (int)s.size());
}
}
return 0;
}
//-------------------------------------------------------------------------------------
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;
}
//-------------------------------------------------------------------------------------
bool Components::updateComponentInfos(const Components::ComponentInfos* info)
{
// 不对其他machine做处理
if(info->componentType == MACHINE_TYPE)
{
return true;
}
if (!lookupLocalComponentRunning(info->pid))
return false;
Network::EndPoint epListen;
epListen.socket(SOCK_STREAM);
if (!epListen.good())
{
ERROR_MSG("Components::updateComponentInfos: couldn't create a socket\n");
return true;
}
epListen.setnonblocking(true);
while(true)
{
fd_set frds, fwds;
struct timeval tv = { 0, 300000 }; // 100ms
FD_ZERO( &frds );
FD_ZERO( &fwds );
FD_SET((int)epListen, &frds);
FD_SET((int)epListen, &fwds);
if(epListen.connect(info->pIntAddr->port, info->pIntAddr->ip) == -1)
{
int selgot = select(epListen+1, &frds, &fwds, NULL, &tv);
if(selgot > 0)
{
break;
}
WARNING_MSG(fmt::format("Components::updateComponentInfos: couldn't connect to:{}\n",
info->pIntAddr->c_str()));
return false;
}
}
epListen.setnodelay(true);
Network::Bundle* pBundle = Network::Bundle::createPoolObject();
// 由于COMMON_NETWORK_MESSAGE不包含client， 如果是bots， 我们需要单独处理
if(info->componentType != BOTS_TYPE)
{
COMMON_NETWORK_MESSAGE(info->componentType, (*pBundle), lookApp);
}
else
{
(*pBundle).newMessage(BotsInterface::lookApp);
}
epListen.send(pBundle->pCurrPacket()->data(), pBundle->pCurrPacket()->wpos());
Network::Bundle::reclaimPoolObject(pBundle);
fd_set fds;
struct timeval tv = { 0, 300000 }; // 100ms
FD_ZERO( &fds );
FD_SET((int)epListen, &fds);
int selgot = select(epListen+1, &fds, NULL, NULL, &tv);
if(selgot == 0)
{
// 超时, 可能对方繁忙
return true;
}
else if(selgot == -1)
{
return true;
}
else
{
COMPONENT_TYPE ctype;
COMPONENT_ID cid;
int8 istate = 0;
ArraySize entitySize = 0, cellSize = 0;
int32 clientsSize = 0, proxicesSize = 0;
uint32 telnet_port = 0;
Network::TCPPacket packet;
packet.resize(255);
int recvsize = sizeof(ctype) + sizeof(cid) + sizeof(istate);
if(info->componentType == CELLAPP_TYPE)
{
recvsize += sizeof(entitySize) + sizeof(cellSize) + sizeof(telnet_port);
}
if(info->componentType == BASEAPP_TYPE)
{
recvsize += sizeof(entitySize) + sizeof(clientsSize) + sizeof(proxicesSize) + sizeof(telnet_port);
}
int len = epListen.recv(packet.data(), recvsize);
packet.wpos(len);
if(recvsize != len)
{
WARNING_MSG(fmt::format("Components::updateComponentInfos: packet invalid(recvsize({}) != ctype_cid_len({}).\n"
, len, recvsize));
if(len == 0)
return false;
return true;
}
packet >> ctype >> cid >> istate;
if(ctype == CELLAPP_TYPE)
{
packet >> entitySize >> cellSize >> telnet_port;
}
if(ctype == BASEAPP_TYPE)
{
packet >> entitySize >> clientsSize >> proxicesSize >> telnet_port;
}
//-------------------------------------------------------------------------------------
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;
}
//-------------------------------------------------------------------------------------
int HTTPCBHandler::handleInputNotification(int fd)
{
if(fd == *pEndPoint_)
{
u_int16_t port;
u_int32_t addr;
Network::EndPoint* newclient = pEndPoint_->accept(&port, &addr);
if(newclient == NULL)
{
ERROR_MSG(fmt::format("HTTPCBHandler::handleInputNotification: accept is error:{}.\n", kbe_strerror()));
return 0;
}
INFO_MSG(fmt::format("HTTPCBHandler:handleInputNotification: newclient = {}\n",
newclient->c_str()));
newclient->setnonblocking(true);
CLIENT& client = clients_[*newclient];
client.endpoint = KBEShared_ptr< Network::EndPoint >(newclient);
client.state = 0;
Loginapp::getSingleton().networkInterface().dispatcher().registerReadFileDescriptor(*newclient, this);
}
else
{
std::map< int, CLIENT >::iterator iter = clients_.find(fd);
if(iter == clients_.end())
{
ERROR_MSG(fmt::format("HTTPCBHandler:handleInputNotification: fd({}) not found!\n",
fd));
return 0;
}
CLIENT& client = iter->second;
Network::EndPoint* newclient = iter->second.endpoint.get();
char buffer[1024];
int len = newclient->recv(&buffer, 1024);
if(len <= 0)
{
ERROR_MSG(fmt::format("HTTPCBHandler:handleInputNotification: recv error, newclient = {}, recv={}.\n",
newclient->c_str(), len));
if(len == 0)
{
Loginapp::getSingleton().networkInterface().dispatcher().deregisterReadFileDescriptor(*newclient);
clients_.erase(iter);
}
return 0;
}
if(client.state == 1)
{
Loginapp::getSingleton().networkInterface().dispatcher().deregisterReadFileDescriptor(*newclient);
clients_.erase(iter);
}
int type = 0;
std::string s = buffer;
std::string keys = "<policy-file-request/>";
std::string::size_type fi0 = s.find(keys);
if(fi0 != std::string::npos)
{
if(client.state != 1)
{
std::string response = "<?xml version='1.0'?><cross-domain-policy><allow-access-from domain=""*"" to-ports=""*"" /></cross-domain-policy>";
iter->second.endpoint->send(response.c_str(), response.size());
Loginapp::getSingleton().networkInterface().dispatcher().deregisterReadFileDescriptor(*newclient);
clients_.erase(iter);
}
return 0;
}
keys = "accountactivate_";
std::string::size_type fi1 = s.find(keys);
if(fi1 == std::string::npos)
{
keys = "resetpassword_";
fi1 = s.find(keys);
if(fi1 == std::string::npos)
{
keys = "bindmail_";
fi1 = s.find(keys);
if(fi1 != std::string::npos)
{
type = 3;
}
}
else
{
type = 2;
}
}
else
{
type = 1;
}
std::string::size_type fi2 = s.find("?");
std::string::size_type fi3 = s.find(" HTTP/");
if(fi2 == std::string::npos || fi2 > fi3)
fi2 = fi3;
if(fi2 <= fi1)
{
return 0;
}
std::string code;
if(fi1 != std::string::npos && fi2 != std::string::npos)
{
int ilen = keys.size();
code.assign(s.c_str() + fi1 + ilen, fi2 - (fi1 + ilen));
}
client.state = 1;
code = KBEngine::strutil::kbe_trim(code);
if(code.size() > 0)
{
INFO_MSG(fmt::format("HTTPCBHandler:handleInputNotification: code = {}\n",
code.c_str()));
client.code = code;
Components::COMPONENTS& cts = Components::getSingleton().getComponents(DBMGR_TYPE);
Components::ComponentInfos* dbmgrinfos = NULL;
if(cts.size() > 0)
dbmgrinfos = &(*cts.begin());
if(dbmgrinfos == NULL || dbmgrinfos->pChannel == NULL || dbmgrinfos->cid == 0)
{
return 0;
}
std::string hellomessage;
if(type == 1)
{
// Ïòdbmgr¼¤»îÕ˺Å
Network::Bundle* pBundle = Network::Bundle::ObjPool().createObject();
(*pBundle).newMessage(DbmgrInterface::accountActivate);
(*pBundle) << code;
dbmgrinfos->pChannel->send(pBundle);
hellomessage = g_kbeSrvConfig.emailAtivationInfo_.backlink_hello_message;
}
else if(type == 2)
{
std::string::size_type fi1 = s.find("password="******"&", fi1);
std::string password;
if(fi1 != std::string::npos && fi2 != std::string::npos)
{
client.state = 2;
if(fi1 < fi2)
{
int ilen = strlen("password="******"username="******"&", fi1);
std::string username;
if(fi1 != std::string::npos && fi2 != std::string::npos)
{
if(fi1 < fi2)
{
int ilen = strlen("username="******"username="******" HTTP/");
if(fi1 != std::string::npos && fi2 != std::string::npos)
{
if(fi1 < fi2)
{
int ilen = strlen("username="******"${backlink}", fmt::format("http://{}:{}/{}{}",
Loginapp::getSingleton().networkInterface().extaddr().ipAsString(),
g_kbeSrvConfig.getLoginApp().http_cbport,
keys,
code));
KBEngine::strutil::kbe_replace(hellomessage, "${code}", code);
std::string response = fmt::format("HTTP/1.1 200 OK\r\nContent-Type: text/html\r\nContent-Length: {}\r\n\r\n{}",
hellomessage.size(), hellomessage);
newclient->send(response.c_str(), response.size());
}
client.state = 2;
}
else
{
if(client.state != 2)
{
Loginapp::getSingleton().networkInterface().dispatcher().deregisterReadFileDescriptor(*newclient);
clients_.erase(iter);
}
}
}
return 0;
}
//-------------------------------------------------------------------------------------
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;
}
//-------------------------------------------------------------------------------------
bool BillingHandler_ThirdParty::reconnect()
{
if(pBillingChannel_)
{
if(!pBillingChannel_->isDestroyed())
Dbmgr::getSingleton().networkInterface().deregisterChannel(pBillingChannel_);
pBillingChannel_->decRef();
}
Network::Address addr = g_kbeSrvConfig.billingSystemAddr();
Network::EndPoint* pEndPoint = new Network::EndPoint(addr);
pEndPoint->socket(SOCK_STREAM);
if (!pEndPoint->good())
{
ERROR_MSG("BillingHandler_ThirdParty::initialize: couldn't create a socket\n");
return true;
}
pEndPoint->setnonblocking(true);
pEndPoint->setnodelay(true);
pBillingChannel_ = new Network::Channel(Dbmgr::getSingleton().networkInterface(), pEndPoint, Network::Channel::INTERNAL);
pBillingChannel_->incRef();
int trycount = 0;
while(true)
{
fd_set frds, fwds;
struct timeval tv = { 0, 100000 }; // 100ms
FD_ZERO( &frds );
FD_ZERO( &fwds );
FD_SET((int)(*pBillingChannel_->endpoint()), &frds);
FD_SET((int)(*pBillingChannel_->endpoint()), &fwds);
if(pBillingChannel_->endpoint()->connect() == -1)
{
int selgot = select((*pBillingChannel_->endpoint())+1, &frds, &fwds, NULL, &tv);
if(selgot > 0)
{
break;
}
trycount++;
if(trycount > 3)
{
ERROR_MSG(fmt::format("BillingHandler_ThirdParty::reconnect(): couldn't connect to:{}\n",
pBillingChannel_->endpoint()->addr().c_str()));
pBillingChannel_->destroy();
return false;
}
}
}
// 不检查超时
pBillingChannel_->stopInactivityDetection();
Dbmgr::getSingleton().networkInterface().registerChannel(pBillingChannel_);
return true;
}
