network_config.hpp

Go to the documentation of this file.

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2015 Joerg Henrichs
//
//  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.
 
#ifndef HEADER_NETWORK_CONFIG
#define HEADER_NETWORK_CONFIG
 
#include "race/race_manager.hpp"
#include "utils/stk_process.hpp"
#include "utils/no_copy.hpp"
 
#include "irrString.h"
#include <array>
#include <atomic>
#include <cstring>
#include <memory>
#include <set>
#include <tuple>
#include <vector>
#include <utility>
 
namespace Online
{
    class XMLRequest;
}
 
namespace GUIEngine
{
    class Screen;
}
 
class InputDevice;
class PlayerProfile;
 
class NetworkConfig : public NoCopy
{
public:
    enum IPType : int
    {
        IP_NONE, IP_V4, IP_V6, IP_V6_NAT64, IP_DUAL_STACK
    };
private:
    static NetworkConfig *m_network_config[PT_COUNT];
 
    static bool m_system_ipv4;
 
    static bool m_system_ipv6;
 
    enum NetworkType : int
    {
        NETWORK_NONE, NETWORK_WAN, NETWORK_LAN
    };
 
    std::atomic<IPType> m_ip_type;
 
    std::atomic<NetworkType> m_network_type;
 
    bool m_is_public_server;
 
    std::atomic_bool m_is_server;
 
    bool m_auto_connect;
 
    bool m_done_adding_network_players;
 
    bool m_network_ai_instance;
 
    bool m_tux_hitbox_addon;
 
    unsigned m_num_fixed_ai;
 
    uint16_t m_client_port;
 
    uint32_t m_cur_user_id;
    std::string m_cur_user_token;
 
    std::string m_server_id_file;
 
    std::vector<std::tuple<InputDevice*, PlayerProfile*, HandicapLevel> > m_network_players;
 
    NetworkConfig();
 
    uint32_t m_joined_server_version;
 
    int m_state_frequency;
 
    std::set<std::string> m_server_capabilities;
 
    std::string m_nat64_prefix;
    std::array<uint32_t, 8> m_nat64_prefix_data;
    // ------------------------------------------------------------------------
    static void fillStunList(std::vector<std::pair<std::string, int> >* l,
                             const std::string& dns);
 
public:
    static void initSystemIP();
    // ------------------------------------------------------------------------
    static NetworkConfig *get()
    {
        ProcessType type = STKProcess::getType();
        if (!m_network_config[type])
            m_network_config[type] = new NetworkConfig();
        return m_network_config[type];
    }   // get
    // ------------------------------------------------------------------------
    static NetworkConfig* getByType(ProcessType type)
    {
        return m_network_config[type];
    }   // get
    // ------------------------------------------------------------------------
    static void clearDetectIPThread(bool quit_stk);
    // ------------------------------------------------------------------------
    static void queueIPDetection();
    // ------------------------------------------------------------------------
    static void destroy()
    {
        ProcessType type = STKProcess::getType();
        delete m_network_config[type];   // It's ok to delete NULL
        m_network_config[type] = NULL;
        if (type == PT_MAIN)
            clearDetectIPThread(true/*quit_stk*/);
    }   // destroy
    // ------------------------------------------------------------------------
    static void clear()
    {
        memset(m_network_config, 0, sizeof(m_network_config));
    }   // clear
    // ------------------------------------------------------------------------
    void setIsServer(bool b)
    {
        m_is_server = b;
    }   // setIsServer
    // ------------------------------------------------------------------------
    void setClientPort(uint16_t port) { m_client_port = port; }
    // ------------------------------------------------------------------------
    uint16_t getClientPort() const { return m_client_port; }
    // ------------------------------------------------------------------------
    void setIsPublicServer() { m_is_public_server = true; }
    // ------------------------------------------------------------------------
    bool isPublicServer() const { return m_is_public_server; }
    // ------------------------------------------------------------------------
    bool isNetworking() const { return m_network_type!=NETWORK_NONE; }
    // ------------------------------------------------------------------------
    bool isLAN() const { return m_network_type == NETWORK_LAN; }
    // ------------------------------------------------------------------------
    bool isWAN() const { return m_network_type == NETWORK_WAN; }
    // ------------------------------------------------------------------------
    void setIsLAN() { m_network_type = NETWORK_LAN; }
    // ------------------------------------------------------------------------
    void setIsWAN() { m_network_type = NETWORK_WAN; }
    // ------------------------------------------------------------------------
    void unsetNetworking();
    // ------------------------------------------------------------------------
    std::vector<std::tuple<InputDevice*, PlayerProfile*, HandicapLevel> >&
                        getNetworkPlayers()       { return m_network_players; }
    // ------------------------------------------------------------------------
    bool isAddingNetworkPlayers() const
                                     { return !m_done_adding_network_players; }
    // ------------------------------------------------------------------------
    void doneAddingNetworkPlayers()   { m_done_adding_network_players = true; }
    // ------------------------------------------------------------------------
    bool addNetworkPlayer(InputDevice* device, PlayerProfile* profile,
                          HandicapLevel h)
    {
        for (auto& p : m_network_players)
        {
            if (std::get<0>(p) == device && !m_network_ai_instance)
                return false;
            if (std::get<1>(p) == profile)
                return false;
        }
        m_network_players.emplace_back(device, profile, h);
        return true;
    }
    // ------------------------------------------------------------------------
    bool playerExists(PlayerProfile* profile) const
    {
        for (auto& p : m_network_players)
        {
            if (std::get<1>(p) == profile)
                return true;
        }
        return false;
    }
    // ------------------------------------------------------------------------
    void cleanNetworkPlayers()
    {
        m_network_players.clear();
        m_done_adding_network_players = false;
    }
    // ------------------------------------------------------------------------
    bool isServer() const { return m_is_server;  }
    // ------------------------------------------------------------------------
    bool isClient() const { return !m_is_server; }
    // ------------------------------------------------------------------------
    void setAutoConnect(bool b) { m_auto_connect = b; }
    // ------------------------------------------------------------------------
    bool isAutoConnect() const { return m_auto_connect; }
    // ------------------------------------------------------------------------
    void setNetworkAIInstance(bool b) { m_network_ai_instance = b; }
    // ------------------------------------------------------------------------
    bool isNetworkAIInstance() const { return m_network_ai_instance; }
    // ------------------------------------------------------------------------
    void setCurrentUserId(uint32_t id) { m_cur_user_id = id ; }
    // ------------------------------------------------------------------------
    void setCurrentUserToken(const std::string& t) { m_cur_user_token = t; }
    // ------------------------------------------------------------------------
    uint32_t getCurrentUserId() const { return m_cur_user_id; }
    // ------------------------------------------------------------------------
    const std::string& getCurrentUserToken() const { return m_cur_user_token; }
    // ------------------------------------------------------------------------
    void setUserDetails(std::shared_ptr<Online::XMLRequest> r,
                        const std::string& name);
    // ------------------------------------------------------------------------
    void setServerDetails(std::shared_ptr<Online::XMLRequest> r,
                          const std::string& name);
    // ------------------------------------------------------------------------
    void setServerIdFile(const std::string& id) { m_server_id_file = id; }
    // ------------------------------------------------------------------------
    const std::string& getServerIdFile() const { return m_server_id_file; }
    // ------------------------------------------------------------------------
    std::vector<GUIEngine::Screen*> getResetScreens(bool lobby = false) const;
    // ------------------------------------------------------------------------
    void setJoinedServerVersion(uint32_t v)    { m_joined_server_version = v; }
    // ------------------------------------------------------------------------
    uint32_t getJoinedServerVersion() const { return m_joined_server_version; }
    // ------------------------------------------------------------------------
    void clearActivePlayersForClient() const;
    // ------------------------------------------------------------------------
    void setStateFrequency(int frequency)    { m_state_frequency = frequency; }
    // ------------------------------------------------------------------------
    int getStateFrequency() const                 { return m_state_frequency; }
    // ------------------------------------------------------------------------
    bool roundValuesNow() const;
    // ------------------------------------------------------------------------
    void setServerCapabilities(std::set<std::string>& caps)
                                   { m_server_capabilities = std::move(caps); }
    // ------------------------------------------------------------------------
    void clearServerCapabilities()           { m_server_capabilities.clear(); }
    // ------------------------------------------------------------------------
    const std::set<std::string>& getServerCapabilities() const
                                              { return m_server_capabilities; }
    // ------------------------------------------------------------------------
    void getIPDetectionResult(uint64_t timeout);
    // ------------------------------------------------------------------------
    IPType getIPType() const                       { return m_ip_type.load(); }
    // ------------------------------------------------------------------------
    void setIPType(IPType ip_type)                { m_ip_type.store(ip_type); }
    // ------------------------------------------------------------------------
    const std::string& getNAT64Prefix() const        { return m_nat64_prefix; }
    // ------------------------------------------------------------------------
    const std::array<uint32_t, 8>& getNAT64PrefixData() const
                                                { return m_nat64_prefix_data; }
    // ------------------------------------------------------------------------
    void initClientPort();
    // ------------------------------------------------------------------------
    void setNumFixedAI(unsigned num)                  { m_num_fixed_ai = num; }
    // ------------------------------------------------------------------------
    unsigned getNumFixedAI() const                   { return m_num_fixed_ai; }
    // ------------------------------------------------------------------------
    static const std::vector<std::pair<std::string, int> >&
                                                        getStunList(bool ipv4);
    // ------------------------------------------------------------------------
    void setTuxHitboxAddon(bool val)              { m_tux_hitbox_addon = val; }
    // ------------------------------------------------------------------------
    bool useTuxHitboxAddon() const               { return m_tux_hitbox_addon; }
};   // class NetworkConfig
 
#endif // HEADER_NETWORK_CONFIG