void UT_CIceConnectionHandler::UT_CNATFWConnectionHandler_IncomingMessageLL( )
{
TInetAddr localAddr( KLocalAddr );
TInetAddr fromAddr( KRemoteAddr );
TInetAddr peerAddr( KRemoteAddr );
_LIT8( KDummyContent, "dummycontent" );
TBool consumed( EFalse );
// no connection
EUNIT_ASSERT_LEAVE( iConnectionHandler->IncomingMessageL(
iStreamId, KDummyContent, localAddr, fromAddr, peerAddr, consumed ) );
TUint stunConnection = iConnectionHandler->CreateConnectionL( *iPairs[0] );
// unknown sream
EUNIT_ASSERT_NO_LEAVE( iConnectionHandler->IncomingMessageL(
iStreamId + 1, KDummyContent,
localAddr, fromAddr, peerAddr, consumed ) );
EUNIT_ASSERT( !consumed );
// known stream
TUint stunConnection2 = iConnectionHandler->CreateConnectionL( *iPairs[0] );
EUNIT_ASSERT_NO_LEAVE( iConnectionHandler->IncomingMessageL(
iStreamId, KDummyContent, localAddr, fromAddr, peerAddr, consumed ) );
iConnectionHandler->RemoveConnection( iStreamId, stunConnection );
iConnectionHandler->RemoveConnection( iStreamId, stunConnection2 );
}
void UT_CIceValidList::UT_CICEValidList_HasPairL()
{
CNATFWCandidate* localCand = CNATFWCandidate::NewLC();
localCand->SetComponentId( KComponentIdRtp );
TInetAddr localAddr( KInetAddrAny );
localAddr.SetFamily( KAfInet );
localCand->SetTransportAddrL( localAddr );
CNATFWCandidate* remoteCand = CNATFWCandidate::NewLC();
remoteCand->SetComponentId( KComponentIdRtp );
TInetAddr remoteAddr( KInetAddrAny );
remoteAddr.SetFamily( KAfInet );
remoteCand->SetTransportAddrL( remoteAddr );
CNATFWCandidatePair* pair
= CNATFWCandidatePair::NewLC( *localCand, *remoteCand );
EUNIT_ASSERT( !iValidList->HasPair( *pair ) );
iValidList->AddValidPairL( *pair );
EUNIT_ASSERT( iValidList->iValidList.Count() == 1 );
EUNIT_ASSERT( iValidList->HasPair( *pair ) );
CleanupStack::PopAndDestroy( pair );
CleanupStack::PopAndDestroy( remoteCand );
CleanupStack::PopAndDestroy( localCand );
}
void TcpServer::newConnection(int sockfd, const InetAddress& peerAddr)
{
loop_->assertInLoopThread();
EventLoop* ioLoop = threadPool_->getNextLoop();
char buf[64];
snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_);
++nextConnId_;
std::string connName = name_ + buf;
LOG_PRINT(LogType_Info, "TcpServer::newConnection [%s] - new connection [%s] from %s",
name_.c_str(), connName.c_str(), peerAddr.toIpPort().c_str());
InetAddress localAddr(SocketOps::getLocalAddr(sockfd));
// FIXME poll with zero timeout to double confirm the new connection
// FIXME use make_shared if necessary
TcpConnectionPtr conn(new TcpConnection(ioLoop,
connName,
sockfd,
localAddr,
peerAddr));
connections_[connName] = conn;
conn->setConnectionCallback(connectionCallback_);
conn->setMessageCallback(messageCallback_);
conn->setWriteCompleteCallback(writeCompleteCallback_);
conn->setCloseCallback(
std::bind(&TcpServer::removeConnection, this, std::placeholders::_1)); // FIXME: unsafe
ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn));
}
Service::Service(istring& localIP) : m_connectedToMaster(false)
{
currentService = this;
m_net = new Networking::NetworkingSystem(true);
m_net->Initialize();
Address mCastAddr(226, 0, 0, 1, 8000);
TODO("Don't hard-code this");
Address localAddr(inet_addr(localIP.c_str()), 8000);
m_net->Multicast(localAddr, mCastAddr);
}
Link* Connector::createLink(socket_t newfd, NetAddress &peerAddr)
{
NetModel *net = m_netNetFactory->nextNet();
LinkPool &linkPool = net->getLinkPool();
NetAddress localAddr(socktool::getLocalAddr(newfd));
Link *link = linkPool.alloc(newfd, localAddr, peerAddr, net, m_pNetReactor);
if (NULL == link) {
return NULL;
}
link->m_isAutoReconnect = true;
return link;
}
void TcpServer::onNewConnectionCallback(int fd, const InetAddr& addr)
{
char buf[32];
bzero((void*)buf, 32);
std::string name = snprintf(buf, 32, "%s:%d",addr.getIpPortStr(),connectId_);
logger::console->info("NewConnection:{}",name);
++connectId_;
InetAddr localAddr(serverAddr_);
TcpConnection* tcpConnection= new TcpConnection(name, eventloop_, fd, serverAddr_, addr);
connectionMap_[name] = tcpConnection;
tcpConnection->setCloseCallback(boost::bind(&TcpServer::removeConnection, this,_1));
tcpConnection->setMessageCallback(messageCallback_);
tcpConnection->setWriteCompleteCallback(writeCompleteCallback_);
}
void BaseSvr::MsgLoop()
{
typedef std::deque<Buffer*> MsgQueue;
MsgQueue msgQueue;
{
MutexLockGuard lock(m_msgQueue.m_mutex);
if(m_msgQueue.m_queue.empty())
{
return;
}
msgQueue.swap(m_msgQueue.m_queue);
m_msgQueue.m_queue.clear();
}
for(MsgQueue::iterator itr = msgQueue.begin(); itr != msgQueue.end(); ++itr)
{
Buffer *pMsg = *itr;
uint16_t msgType = endian::networkToHost16(pMsg->peekInt16());
if(msgType == 20)
{
LoginReq loginReq;
loginReq.ParseFromArray(pMsg->peek() + sizeof(uint16_t), pMsg->readableBytes());
LOG_INFO << "LoginReq loginReq :" << loginReq.DebugString();
m_loop->quit();
}
if(-1 == msgType)
{
InetAddress localAddr(0);
string name = "@@@@";
TcpConnectionPtr conn(new TcpConnection(m_loop, name, 0, localAddr, localAddr));
conn->send("Bad Request!\r\n");
conn->shutdown();
}
delete pMsg;
}
}
/**
* UDPGenerator::open
*
* @param localport
* @param remoteport
*
* @return
*/
int
UDPGenerator::open(const ACE_TCHAR *remotehost,
u_short localport,
u_short remoteport)
{
ACE_DEBUG ((LM_DEBUG, "%N:%l:UDPGenerator::open_addr called\n"));
// Create a local UDP socket to receive datagrams.
ACE_INET_Addr localAddr(localport);
if (this->sockDgram_.open (localAddr) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_SOCK_Dgram::open"), -1);
// Initialize the asynchronous read.
if (this->rd_.open (
*this,
this->sockDgram_.get_handle (),
this->completion_key_,
ACE_Proactor::instance ()) == -1
)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Read_Dgram::open"), -1);
// Initialize the asynchronous read.
if (this->wd_.open (
*this,
this->sockDgram_.get_handle (),
this->completion_key_,
ACE_Proactor::instance ()) == -1)
ACE_ERROR_RETURN ((LM_ERROR, "%p\n", "ACE_Asynch_Write_Dgram::open"), -1);
int res = 0;
//res = readdatagram(4);
//DataGloveData glove_data;
//glove_data.initialize();
//res = writedatagram(remotehost, remoteport);
res = rescuerHandSake(remotehost, remoteport);
//res = gloveDgramWrite(remotehost, remoteport, glove_data);
res = readdatagram(4);
return res;
}
void RealmList::UpdateRealms(bool init)
{
TC_LOG_INFO(LOG_FILTER_AUTHSERVER, "Updating Realm List...");
PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_REALMLIST);
PreparedQueryResult result = LoginDatabase.Query(stmt);
// Circle through results and add them to the realm map
if (result)
{
do
{
Field* fields = result->Fetch();
uint32 realmId = fields[0].GetUInt32();
std::string name = fields[1].GetString();
std::string externalAddress = fields[2].GetString();
std::string localAddress = fields[3].GetString();
std::string localSubmask = fields[4].GetString();
uint16 port = fields[5].GetUInt16();
uint8 icon = fields[6].GetUInt8();
RealmFlags flag = RealmFlags(fields[7].GetUInt8());
uint8 timezone = fields[8].GetUInt8();
uint8 allowedSecurityLevel = fields[9].GetUInt8();
float pop = fields[10].GetFloat();
uint32 build = fields[11].GetUInt32();
ACE_INET_Addr externalAddr(port, externalAddress.c_str(), AF_INET);
ACE_INET_Addr localAddr(port, localAddress.c_str(), AF_INET);
ACE_INET_Addr submask(0, localSubmask.c_str(), AF_INET);
UpdateRealm(realmId, name, externalAddr, localAddr, submask, icon, flag, timezone, (allowedSecurityLevel <= SEC_ADMINISTRATOR ? AccountTypes(allowedSecurityLevel) : SEC_ADMINISTRATOR), pop, build);
if (init)
TC_LOG_INFO(LOG_FILTER_AUTHSERVER, "Added realm \"%s\" at %s:%u.", name.c_str(), m_realms[name].ExternalAddress.get_host_addr(), port);
}
while (result->NextRow());
}
}
void TcpServer::NewConnection(socket_t fd, const InternetAddress& peerAddr)
{
loop_->AssertInLoopThreadOrDie();
EventLoop* ioLoop = threadGroup_->GetNextLoop();
InternetAddress localAddr(SocketsApi::GetLocalAddr(fd));
std::stringstream connNameSs;
connNameSs << name_ << hostIpPort_ << "#" << nextConnId_;
nextConnId_++;
std::string connName = connNameSs.str();
std::cout << "[" << name_
<< "] - new connection [" << connName
<< "] from " << peerAddr.GetIpAndPort()
<< std::endl;
TcpConnectionPtr conn(new TcpConnection(loop_, connName, fd, localAddr, peerAddr));
//Save the new TcpConnection to this map, because life cycle is manage by shared_ptr
allConnections_[connNameSs.str()] = conn;
conn->SetConnectionCallBack(connCallBack_);
conn->SetMessageCallBack(msgCallBack_);
conn->SetCloseCallBack(std::bind(&TcpServer::RemoveConnection, this, std::placeholders::_1));
ioLoop->RunInLoop(std::bind(&TcpConnection::ConnectionEstablished, conn));
}
int main() {
#ifdef OS_WIN32
WSAData wsaData;
int nCode;
assert( WSAStartup(MAKEWORD(2, 2), &wsaData) == 0);
#endif
int sock = socket(AF_INET, SOCK_STREAM, 0);
TCPServerSocket server (sock);
TCPSocketAddress localAddr("127.0.0.1", 10001);
if (server.bind(&localAddr)) {
std::cout << server.getLastError().getErrorString() << std::endl;
return -1;
}
if (server.listen(10)) {
perror("While listening");
return -2;
}
TCPSocketAddress *addr = 0;
server.poll(IODevice::POLL_READ,-1);
TCPSocket *socket = (TCPSocket *)(server.accept((SocketAddress **)&addr));
if (socket == NULL) {
std::cout << server.getLastError() << std::endl;
return -3;
}
std::cout << "Get remote "<<socket->getPeerAddress()->getReadable()<<std::endl;
socket->close();
server.close();
return 0;
}
void WinSockets::parseSocketTable(WinSockTableType sockType,
QueryData& results) {
unsigned int numEntries;
switch (sockType) {
case WinSockTableType::tcp:
numEntries = tcpTable_->dwNumEntries;
break;
case WinSockTableType::tcp6:
numEntries = tcp6Table_->dwNumEntries;
break;
case WinSockTableType::udp:
numEntries = udpTable_->dwNumEntries;
break;
case WinSockTableType::udp6:
numEntries = udp6Table_->dwNumEntries;
break;
default:
numEntries = 0;
break;
}
for (size_t i = 0; i < numEntries; i++) {
Row r;
std::vector<char> localAddr(128, 0x0);
std::vector<char> remoteAddr(128, 0x0);
switch (sockType) {
case WinSockTableType::tcp: {
r["protocol"] = INTEGER(IPPROTO_TCP);
auto tcpLocalAddr = tcpTable_->table[i].dwLocalAddr;
auto retVal =
InetNtopA(AF_INET, &tcpLocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] =
INTEGER(ntohs(static_cast<u_short>(tcpTable_->table[i].dwLocalPort)));
auto tcpRemoteAddr = tcpTable_->table[i].dwRemoteAddr;
retVal = InetNtopA(
AF_INET, &tcpRemoteAddr, remoteAddr.data(), remoteAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network remote address to string: "
<< WSAGetLastError();
}
r["remote_address"] = remoteAddr.data();
r["remote_port"] = INTEGER(
ntohs(static_cast<u_short>(tcpTable_->table[i].dwRemotePort)));
r["pid"] = INTEGER(tcpTable_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET);
break;
}
case WinSockTableType::tcp6: {
r["protocol"] = INTEGER(IPPROTO_TCP);
auto tcp6LocalAddr = tcp6Table_->table[i].ucLocalAddr;
auto retVal = InetNtopA(
AF_INET6, tcp6LocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] = INTEGER(
ntohs(static_cast<u_short>(tcp6Table_->table[i].dwLocalPort)));
auto tcp6RemoteAddr = tcp6Table_->table[i].ucRemoteAddr;
retVal = InetNtopA(
AF_INET6, tcp6RemoteAddr, remoteAddr.data(), remoteAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network remote address to string: "
<< WSAGetLastError();
}
r["remote_address"] = remoteAddr.data();
r["remote_port"] = INTEGER(
ntohs(static_cast<u_short>(tcp6Table_->table[i].dwRemotePort)));
r["pid"] = INTEGER(tcp6Table_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET6);
break;
}
case WinSockTableType::udp: {
r["protocol"] = INTEGER(IPPROTO_UDP);
auto udpLocalAddr = udpTable_->table[i].dwLocalAddr;
auto retVal =
InetNtopA(AF_INET, &udpLocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] =
INTEGER(ntohs(static_cast<u_short>(udpTable_->table[i].dwLocalPort)));
r["remote_address"] = "0";
r["remote_port"] = INTEGER(0);
r["pid"] = INTEGER(udpTable_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET);
break;
}
case WinSockTableType::udp6: {
r["protocol"] = INTEGER(IPPROTO_UDP);
auto udp6LocalAddr = udp6Table_->table[i].ucLocalAddr;
auto retVal = InetNtopA(
AF_INET6, udp6LocalAddr, localAddr.data(), localAddr.size());
if (retVal == nullptr) {
TLOG << "Error converting network local address to string: "
<< WSAGetLastError();
}
r["local_port"] = INTEGER(
ntohs(static_cast<u_short>(udp6Table_->table[i].dwLocalPort)));
r["remote_address"] = "0";
r["remote_port"] = INTEGER(0);
r["pid"] = INTEGER(udp6Table_->table[i].dwOwningPid);
r["family"] = INTEGER(AF_INET6);
break;
}
default:
break;
}
r["local_address"] = localAddr.data();
results.push_back(r);
}
}
BOOLEAN _netEventHandler::isLocalConnection() const
{
return localAddr() == remoteAddr() ? TRUE : FALSE ;
}
