bool LocalNode::_connect( NodePtr node, ConnectionPtr connection )
{
EQASSERT( connection.isValid( ));
EQASSERT( node->getNodeID() != getNodeID( ));
if( !node.isValid() || _state != STATE_LISTENING ||
!connection->isConnected() || node->_state != STATE_CLOSED )
{
return false;
}
_addConnection( connection );
// send connect packet to peer
NodeConnectPacket packet;
packet.requestID = registerRequest( node.get( ));
packet.nodeID = _id;
packet.nodeType = getType();
connection->send( packet, serialize( ));
bool connected = false;
if( !waitRequest( packet.requestID, connected, 10000 /*ms*/ ))
{
EQWARN << "Node connection handshake timeout - peer not a Collage node?"
<< std::endl;
return false;
}
if( !connected )
return false;
EQASSERT( node->_id != NodeID::ZERO );
EQASSERTINFO( node->_id != _id, _id );
EQINFO << node << " connected to " << *(Node*)this << std::endl;
return true;
}
bool Server::_cmdReleaseConfig( co::ICommand& command )
{
UUID configID = command.get< UUID >();
uint32_t requestID = command.get< uint32_t >();
LBVERB << "Handle release config " << command << " config " << configID
<< std::endl;
co::NodePtr node = command.getNode();
Config* config = 0;
const Configs& configs = getConfigs();
for( Configs::const_iterator i = configs.begin();
i != configs.end() && !config; ++i )
{
Config* candidate = *i;
if( candidate->getID() == configID )
config = candidate;
}
if( !config )
{
LBWARN << "Release request for unknown config" << std::endl;
node->send( fabric::CMD_SERVER_RELEASE_CONFIG_REPLY ) << requestID;
return true;
}
if( config->isRunning( ))
{
LBWARN << "Release of running configuration" << std::endl;
config->exit(); // Make sure config is exited
}
const uint32_t destroyRequestID = registerRequest();
node->send( fabric::CMD_SERVER_DESTROY_CONFIG )
<< config->getID() << destroyRequestID;
waitRequest( destroyRequestID );
#ifdef EQUALIZER_USE_HWSD
if( config->isAutoConfig( ))
{
LBASSERT( _admins.empty( ));
config->deregister();
config::Server::release( config );
}
else
#endif
{
ConfigRestoreVisitor restore;
config->accept( restore );
config->commit();
}
node->send( fabric::CMD_SERVER_RELEASE_CONFIG_REPLY ) << requestID;
LBLOG( lunchbox::LOG_ANY ) << "----- Released Config -----" << std::endl;
return true;
}
Player::Player(const GenericSocket &sock, int id) : myid(id)
{
myrelay = new Analyzer(sock, id);
lockCount = 0;
battleSearch() = false;
myip = relay().ip();
rating() = -1;
waiting_team = NULL;
server_pass_sent = false;
m_state = NotLoggedIn;
myauth = 0;
connect(&relay(), SIGNAL(disconnected()), SLOT(disconnected()));
connect(&relay(), SIGNAL(loggedIn(TeamInfo&,bool,bool,QColor)), SLOT(loggedIn(TeamInfo&,bool,bool,QColor)));
connect(&relay(), SIGNAL(serverPasswordSent(const QString&)), SLOT(serverPasswordSent(const QString&)));
connect(&relay(), SIGNAL(messageReceived(int, QString)), SLOT(recvMessage(int, QString)));
connect(&relay(), SIGNAL(teamReceived(TeamInfo&)), SLOT(recvTeam(TeamInfo&)));
connect(&relay(), SIGNAL(challengeStuff(ChallengeInfo)), SLOT(challengeStuff(ChallengeInfo)));
connect(&relay(), SIGNAL(forfeitBattle(int)), SLOT(battleForfeited(int)));
connect(&relay(), SIGNAL(battleMessage(int,BattleChoice)), SLOT(battleMessage(int,BattleChoice)));
connect(&relay(), SIGNAL(battleChat(int,QString)), SLOT(battleChat(int,QString)));
connect(&relay(), SIGNAL(sentHash(QString)), SLOT(hashReceived(QString)));
connect(&relay(), SIGNAL(wannaRegister()), SLOT(registerRequest()));
connect(&relay(), SIGNAL(kick(int)), SLOT(playerKick(int)));
connect(&relay(), SIGNAL(ban(int)), SLOT(playerBan(int)));
connect(&relay(), SIGNAL(banRequested(QString)), SLOT(CPBan(QString)));
connect(&relay(), SIGNAL(tempBanRequested(QString,int)), SLOT(CPTBan(QString,int)));
connect(&relay(), SIGNAL(unbanRequested(QString)), SLOT(CPUnban(QString)));
connect(&relay(), SIGNAL(PMsent(int,QString)), SLOT(receivePM(int,QString)));
connect(&relay(), SIGNAL(getUserInfo(QString)), SLOT(userInfoAsked(QString)));
connect(&relay(), SIGNAL(tbanListRequested()), SLOT(giveTBanList()));
connect(&relay(), SIGNAL(banListRequested()), SLOT(giveBanList()));
connect(&relay(), SIGNAL(awayChange(bool)), SLOT(awayChange(bool)));
connect(&relay(), SIGNAL(battleSpectateRequested(int)), SLOT(spectatingRequested(int)));
connect(&relay(), SIGNAL(battleSpectateEnded(int)), SLOT(quitSpectating(int)));
connect(&relay(), SIGNAL(battleSpectateChat(int,QString)), SLOT(spectatingChat(int,QString)));
connect(&relay(), SIGNAL(ladderChange(bool)), SLOT(ladderChange(bool)));
connect(&relay(), SIGNAL(showTeamChange(bool)), SLOT(showTeamChange(bool)));
connect(&relay(), SIGNAL(tierChanged(QString)), SLOT(changeTier(QString)));
connect(&relay(), SIGNAL(findBattle(FindBattleData)), SLOT(findBattle(FindBattleData)));
connect(&relay(), SIGNAL(showRankings(QString,int)), SLOT(getRankingsByPage(QString, int)));
connect(&relay(), SIGNAL(showRankings(QString,QString)), SLOT(getRankingsByName(QString, QString)));
connect(&relay(), SIGNAL(joinRequested(QString)), SLOT(joinRequested(QString)));
connect(&relay(), SIGNAL(leaveChannel(int)), SLOT(leaveRequested(int)));
connect(&relay(), SIGNAL(ipChangeRequested(QString)), SLOT(ipChangeRequested(QString)));
/* To avoid threading / simulateneous calls problems, it's queued */
connect(this, SIGNAL(unlocked()), &relay(), SLOT(undelay()),Qt::QueuedConnection);
/* Autokick after 3 minutes if still not logged in */
QTimer::singleShot(1000*180, this, SLOT(autoKick()));
}
uint32_t LocalNode::removeListenerNB( ConnectionPtr connection )
{
EQASSERT( isListening( ));
EQASSERT( connection->isListening( ));
connection->ref( CO_REFERENCED_PARAM );
NodeRemoveListenerPacket packet( connection, registerRequest( ));
Nodes nodes;
getNodes( nodes );
for( Nodes::iterator i = nodes.begin(); i != nodes.end(); ++i )
{
(*i)->send( packet, connection->getDescription()->toString( ));
}
return packet.requestID;
}
void Player::doConnections()
{
/* The reason for Queued Connection is that for example a disconnect signal could be received when
a script sends a message to the client.
If that happens we want the disconnect signal to happen after the script function*/
connect(&relay(), SIGNAL(disconnected()), SLOT(disconnected()), Qt::QueuedConnection);
connect(&relay(), SIGNAL(loggedIn(LoginInfo*)), SLOT(loggedIn(LoginInfo*)));
connect(&relay(), SIGNAL(logout()), SLOT(logout()));
connect(&relay(), SIGNAL(serverPasswordSent(const QByteArray&)), SLOT(serverPasswordSent(const QByteArray&)));
connect(&relay(), SIGNAL(messageReceived(int, QString)), SLOT(recvMessage(int, QString)));
connect(&relay(), SIGNAL(playerDataRequested(int)), SLOT(recvPlayerDataRequest(int)));
connect(&relay(), SIGNAL(teamChanged(const ChangeTeamInfo&)), SLOT(recvTeam(const ChangeTeamInfo&)));
connect(&relay(), SIGNAL(challengeStuff(ChallengeInfo)), SLOT(challengeStuff(ChallengeInfo)));
connect(&relay(), SIGNAL(forfeitBattle(int)), SLOT(battleForfeited(int)));
connect(&relay(), SIGNAL(battleMessage(int,BattleChoice)), SLOT(battleMessage(int,BattleChoice)));
connect(&relay(), SIGNAL(battleChat(int,QString)), SLOT(battleChat(int,QString)));
connect(&relay(), SIGNAL(sentHash(QByteArray)), SLOT(hashReceived(QByteArray)));
connect(&relay(), SIGNAL(wannaRegister()), SLOT(registerRequest()));
connect(&relay(), SIGNAL(kick(int)), SLOT(playerKick(int)));
connect(&relay(), SIGNAL(ban(int)), SLOT(playerBan(int)));
connect(&relay(), SIGNAL(tempBan(int,int)), SLOT(playerTempBan(int,int)));
connect(&relay(), SIGNAL(banRequested(QString,int)), SLOT(CPBan(QString,int)));
connect(&relay(), SIGNAL(unbanRequested(QString)), SLOT(CPUnban(QString)));
connect(&relay(), SIGNAL(PMsent(int,QString)), SLOT(receivePM(int,QString)));
connect(&relay(), SIGNAL(getUserInfo(QString)), SLOT(userInfoAsked(QString)));
connect(&relay(), SIGNAL(banListRequested()), SLOT(giveBanList()));
connect(&relay(), SIGNAL(awayChange(bool)), SLOT(awayChange(bool)));
connect(&relay(), SIGNAL(battleSpectateRequested(int)), SLOT(spectatingRequested(int)));
connect(&relay(), SIGNAL(battleSpectateEnded(int)), SLOT(quitSpectating(int)));
connect(&relay(), SIGNAL(battleSpectateChat(int,QString)), SLOT(spectatingChat(int,QString)));
connect(&relay(), SIGNAL(ladderChange(bool)), SLOT(ladderChange(bool)));
connect(&relay(), SIGNAL(tierChanged(quint8,QString)), SLOT(changeTier(quint8,QString)));
connect(&relay(), SIGNAL(findBattle(FindBattleData)), SLOT(findBattle(FindBattleData)));
connect(&relay(), SIGNAL(showRankings(QString,int)), SLOT(getRankingsByPage(QString, int)));
connect(&relay(), SIGNAL(showRankings(QString,QString)), SLOT(getRankingsByName(QString, QString)));
connect(&relay(), SIGNAL(showRankings(int)), SLOT(getRankingsForPlayer(int)));
connect(&relay(), SIGNAL(joinRequested(QString)), SLOT(joinRequested(QString)));
connect(&relay(), SIGNAL(leaveChannel(int)), SLOT(leaveRequested(int)));
connect(&relay(), SIGNAL(ipChangeRequested(QString)), SLOT(ipChangeRequested(QString)));
connect(&relay(), SIGNAL(endCommand()), SLOT(sendUpdatedIfNeeded()));
connect(&relay(), SIGNAL(reconnect(int,QByteArray)), SLOT(onReconnect(int,QByteArray)));
connect(&relay(), SIGNAL(showRankings(int)), SLOT(getRankingsForPlayer(int)));
/* To avoid threading / simulateneous calls problems, it's queued */
connect(this, SIGNAL(unlocked()), &relay(), SLOT(undelay()),Qt::QueuedConnection);
}
LocalNode::SendToken LocalNode::acquireSendToken( NodePtr node )
{
EQASSERT( !inCommandThread( ));
EQASSERT( !_inReceiverThread( ));
NodeAcquireSendTokenPacket packet;
packet.requestID = registerRequest();
node->send( packet );
bool ret = false;
if( waitRequest( packet.requestID, ret, Global::getTimeout( )))
return node;
EQERROR << "Timeout while acquiring send token " << packet.requestID
<< std::endl;
return 0;
}
bool Server::_cmdReleaseConfig( co::Command& command )
{
const ServerReleaseConfigPacket* packet =
command.get<ServerReleaseConfigPacket>();
EQINFO << "Handle release config " << packet << std::endl;
ServerReleaseConfigReplyPacket reply( packet );
co::NodePtr node = command.getNode();
Config* config = 0;
const Configs& configs = getConfigs();
for( Configs::const_iterator i = configs.begin();
i != configs.end() && !config; ++i )
{
Config* candidate = *i;
if( candidate->getID() == packet->configID )
config = candidate;
}
if( !config )
{
EQWARN << "Release request for unknown config" << std::endl;
node->send( reply );
return true;
}
if( config->isRunning( ))
{
EQWARN << "Release of running configuration" << std::endl;
config->exit(); // Make sure config is exited
}
fabric::ServerDestroyConfigPacket destroyConfigPacket;
destroyConfigPacket.requestID = registerRequest();
destroyConfigPacket.configID = config->getID();
node->send( destroyConfigPacket );
waitRequest( destroyConfigPacket.requestID );
ConfigRestoreVisitor restore;
config->accept( restore );
node->send( reply );
EQLOG( co::base::LOG_ANY ) << "----- Released Config -----" << std::endl;
return true;
}
bool LocalNode::disconnect( NodePtr node )
{
if( !node || _state != STATE_LISTENING )
return false;
if( node->_state != STATE_CONNECTED )
return true;
EQASSERT( !inCommandThread( ));
NodeDisconnectPacket packet;
packet.requestID = registerRequest( node.get( ));
send( packet );
waitRequest( packet.requestID );
_objectStore->removeNode( node );
return true;
}
void
add_prog_1(char *host)
{
CLIENT *clnt;
outData *result_1;
inData register_1_arg;
outData *result_2;
//inData login_1_arg;
#ifndef DEBUG
clnt = clnt_create (host, ADD_PROG, ADD_VERS, "udp");
if (clnt == NULL) {
clnt_pcreateerror (host);
exit (1);
}
#endif /* DEBUG */
// Neeraj Start
int value = 1;
char* userName;
char* password;
char str[20],c=' ';
int i = 0;
printf("\n1. Register\n2. Login");
printf("\nPlease provide your choice: ");
scanf("%d", ®ister_1_arg.mode);
if(register_1_arg.mode != 1 && register_1_arg.mode != 2) {
printf("\nSorry, you have choosen wrong input.\n");
}
else {
printf("Enter the username: "******"%s", ®ister_1_arg.user);
printf("Enter the password: "******"%s", ®ister_1_arg.pass);
if(register_1_arg.mode == 1) {
result_1 = registerRequest(®ister_1_arg, clnt);
if (result_1 == (outData *) NULL) {
clnt_perror (clnt, "call failed");
}
else {
if(result_1->rCode == 1){
char input;
printf("\nDo you want to login[y/n]?");
scanf(" %c", &input);
if(input == 'y') {
result_2 = loginRequest(®ister_1_arg, clnt);
}
}
}
}
else if(register_1_arg.mode == 2) {
result_2 = loginRequest(®ister_1_arg, clnt);
if (result_2 == (outData *) NULL) {
clnt_perror (clnt, "call failed");
}
}
}
#ifndef DEBUG
clnt_destroy (clnt);
#endif /* DEBUG */
}
void CLogInPage::setConnections()
{
QObject::connect( m_pRegister, SIGNAL( registerClicked() ), this, SIGNAL( registerRequest() ) );
QObject::connect( m_pRegisterModeButton, SIGNAL( clicked() ), this, SLOT( registerClicled() ) );
QObject::connect( m_pLogin, SIGNAL( loginClicked() ), this, SIGNAL( loginRequest() ) );
}
NodePtr LocalNode::_connect( const NodeID& nodeID, NodePtr peer )
{
EQASSERT( nodeID != NodeID::ZERO );
NodePtr node;
// Make sure that only one connection request based on the node identifier
// is pending at a given time. Otherwise a node with the same id might be
// instantiated twice in _cmdGetNodeDataReply(). The alternative to this
// mutex is to register connecting nodes with this local node, and handle
// all cases correctly, which is far more complex. Node connections only
// happen a lot during initialization, and are therefore not time-critical.
base::ScopedMutex<> mutex( _connectMutex );
{
base::ScopedMutex< base::SpinLock > mutexNodes( _nodes );
NodeHash::const_iterator i = _nodes->find( nodeID );
if( i != _nodes->end( ))
node = i->second;
}
if( node.isValid( ))
{
EQASSERT( node->isConnected( ));
if( !node->isConnected( ))
connect( node );
return node->isConnected() ? node : 0;
}
EQINFO << "Connecting node " << nodeID << std::endl;
EQASSERT( _id != nodeID );
NodeGetNodeDataPacket packet;
packet.requestID = registerRequest();
packet.nodeID = nodeID;
peer->send( packet );
void* result = 0;
waitRequest( packet.requestID, result );
if( !result )
{
EQINFO << "Node " << nodeID << " not found on " << peer->getNodeID()
<< std::endl;
return 0;
}
EQASSERT( dynamic_cast< Node* >( (Dispatcher*)result ));
node = static_cast< Node* >( result );
node->unref( CO_REFERENCED_PARAM ); // ref'd before serveRequest()
if( node->isConnected( ))
return node;
if( connect( node ))
return node;
{
base::ScopedMutex< base::SpinLock > mutexNodes( _nodes );
// connect failed - maybe simultaneous connect from peer?
NodeHash::const_iterator i = _nodes->find( nodeID );
if( i != _nodes->end( ))
{
node = i->second;
if( !node->isConnected( ))
connect( node );
}
}
return node->isConnected() ? node : 0;
}
