2013-07-12 19:12:31 -04:00
|
|
|
//
|
|
|
|
// SuperTuxKart - a fun racing game with go-kart
|
2015-03-29 20:31:42 -04:00
|
|
|
// Copyright (C) 2013-2015 Glenn De Jonghe
|
2013-07-12 19:12:31 -04:00
|
|
|
//
|
|
|
|
// This program is free software; you can redistribute it and/or
|
|
|
|
// modify it under the terms of the GNU General Public License
|
|
|
|
// as published by the Free Software Foundation; either version 3
|
|
|
|
// of the License, or (at your option) any later version.
|
|
|
|
//
|
|
|
|
// This program is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
//
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with this program; if not, write to the Free Software
|
|
|
|
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
|
2015-11-12 01:52:04 -05:00
|
|
|
#include "network/servers_manager.hpp"
|
|
|
|
|
2013-07-12 19:12:31 -04:00
|
|
|
#include "config/user_config.hpp"
|
2015-11-11 17:53:12 -05:00
|
|
|
#include "network/network.hpp"
|
|
|
|
#include "network/network_config.hpp"
|
|
|
|
#include "network/network_string.hpp"
|
2015-11-12 01:52:04 -05:00
|
|
|
#include "online/xml_request.hpp"
|
2013-07-12 19:12:31 -04:00
|
|
|
#include "utils/translation.hpp"
|
2013-07-21 13:41:02 -04:00
|
|
|
#include "utils/time.hpp"
|
|
|
|
|
2015-10-09 01:47:18 -04:00
|
|
|
#include <assert.h>
|
|
|
|
#include <irrString.h>
|
|
|
|
#include <string>
|
|
|
|
|
2013-07-21 13:41:02 -04:00
|
|
|
#define SERVER_REFRESH_INTERVAL 5.0f
|
2013-07-12 19:12:31 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
static ServersManager* manager_singleton(NULL);
|
2013-07-12 19:12:31 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
ServersManager* ServersManager::get()
|
|
|
|
{
|
|
|
|
if (manager_singleton == NULL)
|
|
|
|
manager_singleton = new ServersManager();
|
2014-08-04 11:41:47 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
return manager_singleton;
|
|
|
|
} // get
|
2013-07-12 19:12:31 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
void ServersManager::deallocate()
|
|
|
|
{
|
|
|
|
delete manager_singleton;
|
|
|
|
manager_singleton = NULL;
|
|
|
|
} // deallocate
|
2013-07-12 19:12:31 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
// ===========================================================-=============
|
|
|
|
ServersManager::ServersManager()
|
|
|
|
{
|
|
|
|
m_last_load_time.setAtomic(0.0f);
|
|
|
|
m_joined_server.setAtomic(NULL);
|
|
|
|
} // ServersManager
|
2013-07-22 16:00:08 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
ServersManager::~ServersManager()
|
|
|
|
{
|
|
|
|
cleanUpServers();
|
|
|
|
} // ~ServersManager
|
2013-07-12 19:12:31 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
// ------------------------------------------------------------------------
|
2015-11-09 16:31:07 -05:00
|
|
|
/** Removes all stored server information. After this call the list of
|
|
|
|
* servers can be refreshed.
|
|
|
|
*/
|
2015-11-06 00:50:58 -05:00
|
|
|
void ServersManager::cleanUpServers()
|
|
|
|
{
|
2015-11-09 16:31:07 -05:00
|
|
|
if(m_joined_server.getAtomic()!=NULL)
|
|
|
|
{
|
|
|
|
// m_joinsed_server is a pointer into the m_server structure,
|
|
|
|
// we can not modify this data structure while this pointer exists.
|
|
|
|
Log::warn("ServersManager", "Server cleanUp while being already "
|
|
|
|
"connected to a server.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
m_sorted_servers.lock();
|
|
|
|
m_sorted_servers.getData().clearAndDeleteAll();
|
|
|
|
m_sorted_servers.unlock();
|
|
|
|
m_mapped_servers.lock();
|
|
|
|
m_mapped_servers.getData().clear();
|
|
|
|
m_mapped_servers.unlock();
|
|
|
|
} // cleanUpServers
|
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-09 04:51:00 -05:00
|
|
|
/** Returns a WAN update-list-of-servers request. It queries the
|
|
|
|
* STK server for an up-to-date list of servers.
|
|
|
|
*/
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::XMLRequest* ServersManager::getWANRefreshRequest() const
|
2015-11-06 00:50:58 -05:00
|
|
|
{
|
2015-11-09 04:51:00 -05:00
|
|
|
// ========================================================================
|
|
|
|
/** A small local class that triggers an update of the ServersManager
|
|
|
|
* when the request is finished. */
|
2015-11-12 01:52:04 -05:00
|
|
|
class WANRefreshRequest : public Online::XMLRequest
|
2013-07-21 13:41:02 -04:00
|
|
|
{
|
2015-11-09 04:51:00 -05:00
|
|
|
public:
|
2015-11-12 01:52:04 -05:00
|
|
|
WANRefreshRequest() : Online::XMLRequest(/*manage_memory*/false,
|
|
|
|
/*priority*/100) {}
|
2015-11-09 04:51:00 -05:00
|
|
|
// --------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
virtual void callback()
|
2013-07-12 19:12:31 -04:00
|
|
|
{
|
2015-11-06 00:50:58 -05:00
|
|
|
ServersManager::get()->refresh(isSuccess(), getXMLData());
|
|
|
|
} // callback
|
2015-11-09 04:51:00 -05:00
|
|
|
// --------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
}; // RefreshRequest
|
2015-11-09 04:51:00 -05:00
|
|
|
// ========================================================================
|
2015-11-06 00:50:58 -05:00
|
|
|
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::XMLRequest *request = new WANRefreshRequest();
|
|
|
|
request->setApiURL(Online::API::SERVER_PATH, "get-all");
|
2015-11-06 00:50:58 -05:00
|
|
|
|
2015-11-09 04:51:00 -05:00
|
|
|
return request;
|
|
|
|
} // getWANRefreshRequest
|
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-09 04:51:00 -05:00
|
|
|
/** Returns a LAN update-list-of-servers request. It uses UDP broadcasts
|
|
|
|
* to find LAN servers, and waits for a certain amount of time fr
|
|
|
|
* answers.
|
|
|
|
*/
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::XMLRequest* ServersManager::getLANRefreshRequest() const
|
2015-11-09 04:51:00 -05:00
|
|
|
{
|
|
|
|
/** A simple class that uses LAN broadcasts to find local servers.
|
|
|
|
* It is based on XML request, but actually does not use any of the
|
|
|
|
* XML/HTTP based infrastructure, but implements the same interface.
|
|
|
|
* This way the already existing request thread can be used.
|
|
|
|
*/
|
2015-11-12 01:52:04 -05:00
|
|
|
class LANRefreshRequest : public Online::XMLRequest
|
2015-11-09 04:51:00 -05:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
|
|
|
|
/** High priority for this request. */
|
|
|
|
LANRefreshRequest() : XMLRequest(false, 100) {m_success = false;}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
virtual ~LANRefreshRequest() {}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
/** Get the downloaded XML tree.
|
|
|
|
* \pre request has to be executed.
|
|
|
|
* \return get the complete result from the request reply. */
|
|
|
|
virtual const XMLNode * getXMLData() const
|
|
|
|
{
|
|
|
|
assert(hasBeenExecuted());
|
|
|
|
return NULL;
|
|
|
|
} // getXMLData
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
virtual void prepareOperation() OVERRIDE
|
|
|
|
{
|
|
|
|
} // prepareOperation
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
virtual void operation()
|
|
|
|
{
|
|
|
|
Network *broadcast = new Network(1, 1, 0, 0);
|
|
|
|
|
2016-02-24 04:32:11 -05:00
|
|
|
BareNetworkString s(std::string("stk-server"));
|
2015-11-09 04:51:00 -05:00
|
|
|
TransportAddress broadcast_address(-1, 2757);
|
2016-02-24 04:32:11 -05:00
|
|
|
broadcast->sendRawPacket(s, broadcast_address);
|
2015-11-09 04:51:00 -05:00
|
|
|
|
|
|
|
Log::info("ServersManager", "Sent broadcast message.");
|
|
|
|
|
|
|
|
const int LEN=2048;
|
|
|
|
char buffer[LEN];
|
|
|
|
// Wait for up to 0.5 seconds to receive an answer from
|
|
|
|
// any local servers.
|
|
|
|
double start_time = StkTime::getRealTime();
|
|
|
|
const double DURATION = 1.0;
|
|
|
|
while(StkTime::getRealTime() - start_time < DURATION)
|
|
|
|
{
|
|
|
|
TransportAddress sender;
|
|
|
|
int len = broadcast->receiveRawPacket(buffer, LEN, &sender, 1);
|
|
|
|
if(len>0)
|
|
|
|
{
|
2016-02-24 04:32:11 -05:00
|
|
|
NewNetworkString s((uint8_t*)buffer, len);
|
2015-11-26 16:55:21 -05:00
|
|
|
irr::core::stringw name;
|
|
|
|
// name_len is the number of bytes read
|
|
|
|
uint8_t bytes_read = s.decodeStringW(0, &name);
|
2015-11-30 15:57:42 -05:00
|
|
|
uint8_t max_players = s.getUInt8(bytes_read );
|
|
|
|
uint8_t players = s.getUInt8(bytes_read+1);
|
|
|
|
uint32_t my_ip = s.getUInt32(bytes_read+2);
|
|
|
|
uint32_t my_port = s.getUInt16(bytes_read+6);
|
2015-11-09 04:51:00 -05:00
|
|
|
ServersManager::get()
|
2015-11-26 16:55:21 -05:00
|
|
|
->addServer(new Server(name, /*lan*/true,
|
2015-11-09 16:31:07 -05:00
|
|
|
max_players, players,
|
|
|
|
sender) );
|
2015-11-11 17:53:12 -05:00
|
|
|
TransportAddress me(my_ip, my_port);
|
|
|
|
NetworkConfig::get()->setMyAddress(me);
|
2015-11-09 04:51:00 -05:00
|
|
|
m_success = true;
|
|
|
|
} // if received_data
|
|
|
|
} // while still waiting
|
|
|
|
} // operation
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
/** This function is necessary, otherwise the XML- and HTTP-Request
|
|
|
|
* functions are called, which will cause a crash. */
|
|
|
|
virtual void afterOperation() OVERRIDE {}
|
|
|
|
// --------------------------------------------------------------------
|
|
|
|
}; // LANRefreshRequest
|
|
|
|
// ========================================================================
|
|
|
|
|
|
|
|
return new LANRefreshRequest();
|
|
|
|
|
|
|
|
} // getLANRefreshRequest
|
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-09 04:51:00 -05:00
|
|
|
/** Factory function to create either a LAN or a WAN update-of-server
|
|
|
|
* requests. The current list of servers is also cleared/
|
|
|
|
*/
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::XMLRequest* ServersManager::getRefreshRequest(bool request_now)
|
2015-11-09 04:51:00 -05:00
|
|
|
{
|
|
|
|
if (StkTime::getRealTime() - m_last_load_time.getAtomic()
|
|
|
|
< SERVER_REFRESH_INTERVAL)
|
|
|
|
{
|
|
|
|
// Avoid too frequent refreshing
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
if(m_joined_server.getAtomic()!=NULL)
|
|
|
|
{
|
|
|
|
// m_joinsed_server is a pointer into the m_server structure,
|
|
|
|
// we can not modify this data structure while this pointer exists.
|
|
|
|
Log::warn("ServersManager", "Server refresh while being already "
|
|
|
|
"connected to a server.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-09 04:51:00 -05:00
|
|
|
cleanUpServers();
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::XMLRequest *request =
|
|
|
|
NetworkConfig::get()->isWAN() ? getWANRefreshRequest()
|
|
|
|
: getLANRefreshRequest();
|
2015-11-09 04:51:00 -05:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
if (request_now)
|
2015-11-12 01:52:04 -05:00
|
|
|
Online::RequestManager::get()->addRequest(request);
|
2015-11-06 00:50:58 -05:00
|
|
|
|
|
|
|
return request;
|
2015-11-09 16:09:05 -05:00
|
|
|
} // getRefreshRequest
|
2015-11-06 00:50:58 -05:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
/** Callback from the refresh request.
|
|
|
|
* \param success If the refresh was successful.
|
|
|
|
* \param input The XML data describing the server.
|
|
|
|
*/
|
|
|
|
void ServersManager::refresh(bool success, const XMLNode *input)
|
|
|
|
{
|
|
|
|
if (!success)
|
|
|
|
{
|
|
|
|
Log::error("Server Manager", "Could not refresh server list");
|
|
|
|
return;
|
|
|
|
}
|
2013-07-14 20:25:56 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
const XMLNode *servers_xml = input->getNode("servers");
|
|
|
|
for (unsigned int i = 0; i < servers_xml->getNumNodes(); i++)
|
2013-07-18 19:02:18 -04:00
|
|
|
{
|
2015-11-06 00:50:58 -05:00
|
|
|
addServer(new Server(*servers_xml->getNode(i), /*is_lan*/false));
|
|
|
|
}
|
|
|
|
m_last_load_time.setAtomic((float)StkTime::getRealTime());
|
|
|
|
} // refresh
|
2013-07-31 14:03:11 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
const Server* ServersManager::getQuickPlay() const
|
|
|
|
{
|
|
|
|
if (m_sorted_servers.getData().size() > 0)
|
|
|
|
return getServerBySort(0);
|
2013-07-23 12:34:38 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
return NULL;
|
|
|
|
} // getQuickPlay
|
2014-08-04 11:41:47 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/** Sets a pointer to the server to which this client is connected. From now
|
|
|
|
* on the list of servers must not be modified (else this pointer might
|
|
|
|
* become invalid).
|
|
|
|
*/
|
2015-11-06 00:50:58 -05:00
|
|
|
void ServersManager::setJoinedServer(uint32_t id)
|
|
|
|
{
|
2015-11-27 20:45:03 -05:00
|
|
|
MutexLocker(m_mapped_servers);
|
|
|
|
m_joined_server.getData() = m_mapped_servers.getData().at(id);
|
2015-11-06 00:50:58 -05:00
|
|
|
} // setJoinedServer
|
2013-07-23 12:34:38 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
/** Unsets the server to which this client is connected.
|
|
|
|
*/
|
2015-11-06 00:50:58 -05:00
|
|
|
void ServersManager::unsetJoinedServer()
|
|
|
|
{
|
|
|
|
MutexLocker(m_joined_server);
|
|
|
|
m_joined_server.getData() = NULL;
|
|
|
|
} // unsetJoinedServer
|
2014-08-04 11:41:47 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-09 16:34:45 -05:00
|
|
|
/** Adds a server to the list of known servers.
|
|
|
|
* \param server The server to add.
|
|
|
|
*/
|
2015-11-06 00:50:58 -05:00
|
|
|
void ServersManager::addServer(Server *server)
|
|
|
|
{
|
|
|
|
m_sorted_servers.lock();
|
|
|
|
m_sorted_servers.getData().push_back(server);
|
|
|
|
m_sorted_servers.unlock();
|
2013-07-23 12:34:38 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
m_mapped_servers.lock();
|
|
|
|
m_mapped_servers.getData()[server->getServerId()] = server;
|
|
|
|
m_mapped_servers.unlock();
|
|
|
|
} // addServer
|
2013-07-23 12:34:38 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
int ServersManager::getNumServers() const
|
|
|
|
{
|
|
|
|
MutexLocker(m_sorted_servers);
|
|
|
|
return m_sorted_servers.getData().size();
|
|
|
|
} // getNumServers
|
2013-07-23 12:34:38 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
const Server* ServersManager::getServerBySort(int index) const
|
|
|
|
{
|
|
|
|
MutexLocker(m_sorted_servers);
|
|
|
|
return m_sorted_servers.getData().get(index);
|
|
|
|
} // getServerBySort
|
2013-07-24 22:22:53 -04:00
|
|
|
|
2015-11-06 00:50:58 -05:00
|
|
|
// ------------------------------------------------------------------------
|
|
|
|
const Server* ServersManager::getServerByID(uint32_t id) const
|
|
|
|
{
|
|
|
|
MutexLocker(m_mapped_servers);
|
|
|
|
return m_mapped_servers.getData().at(id);
|
|
|
|
} // getServerByID
|
2013-07-24 22:22:53 -04:00
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
Server* ServersManager::getJoinedServer() const
|
|
|
|
{
|
|
|
|
return m_joined_server.getAtomic();
|
|
|
|
} // getJoinedServer
|
|
|
|
|
2015-11-09 16:31:07 -05:00
|
|
|
// ----------------------------------------------------------------------------
|
2015-11-06 00:50:58 -05:00
|
|
|
void ServersManager::sort(bool sort_desc)
|
|
|
|
{
|
|
|
|
MutexLocker(m_sorted_servers);
|
|
|
|
m_sorted_servers.getData().insertionSort(0, sort_desc);
|
|
|
|
} // sort
|
2013-07-24 22:22:53 -04:00
|
|
|
|