src/network/nServerInfo.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

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 2
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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

#ifndef ArmageTron_ServerInfo_H
#define ArmageTron_ServerInfo_H

#include "tString.h"
#include "tLinkedList.h"
#include "tArray.h"
#include "nNetwork.h"

#include <iosfwd>
#include <memory>

class nSocket;
class nAddress;
class nServerInfo;
class tPath;

typedef nServerInfo* (sn_ServerInfoCreator)();

class nServerInfoBase
{
public:
    nServerInfoBase();
    virtual ~nServerInfoBase();

    bool operator == ( const nServerInfoBase & other ) const;
    bool operator != ( const nServerInfoBase & other ) const;

    inline void NetWrite(nMessage &m) const;    
    inline void NetRead (nMessage &m);          
    void NetWriteThis(nMessage &m) const;       
    void NetReadThis (nMessage &m);             

    inline void GetFrom( nSocket const * socket );  

    //    nConnectError Connect();                      //!< connect to this server
    nConnectError Connect( nLoginType loginType = Login_All, const nSocket * socket = NULL );  

    void CopyFrom( const nServerInfoBase & other );   

    nServerInfoBase & operator = ( const nServerInfoBase & other );

    inline const tString & GetName() const;     
protected:
    virtual void DoNetWrite(nMessage &m) const; 
    virtual void DoNetRead (nMessage &m);       

    virtual void DoGetFrom( nSocket const * socket );  

    virtual const tString& DoGetName() const;   
private:
    tString         connectionName_;            
    unsigned int    port_;                      
    mutable std::auto_ptr< nAddress > address_; 
public:
    inline tString const & GetConnectionName( void ) const;                                      
    inline nServerInfoBase const & GetConnectionName( tString & connectionName ) const;      
    inline unsigned int GetPort( void ) const;                                               
    inline nServerInfoBase const & GetPort( unsigned int & port ) const;                         
    nAddress const & GetAddress( void ) const;                                               
    nServerInfoBase const & GetAddress( nAddress & address ) const;                              
    nServerInfoBase const & ClearAddress() const;                                                
private:
    nAddress & AccessAddress( void ) const;                            
    nServerInfoBase & SetAddress( nAddress const & address );      
protected:
    inline nServerInfoBase & SetConnectionName( tString const & connectionName );                
    inline nServerInfoBase & SetPort( unsigned int port );                                       
};

class nServerInfoRedirect: public nServerInfoBase
{
public:
    // construct a server directly with connection name and port
    nServerInfoRedirect( tString const & connectionName, unsigned int port )
    {
        nServerInfoBase::SetConnectionName( connectionName );
        nServerInfoBase::SetPort( port );
    };
};

class nServerInfo: public tListItem<nServerInfo>, public nServerInfoBase
{
    int pollID;
protected:
    // information only for the master server
    unsigned int    transactionNr;     // a running number assigned to every server that connects to the master

    // encryption information (from the master server, too)
    int method;                   // encryption method identifier
    tArray<unsigned int> key;    // the public key for encrypting important messages to the server (i.e. the session key)

    // advanced information; obtained by directly querying the server.
    bool    advancedInfoSet;  // did we already get the info?
    bool    advancedInfoSetEver;  // did we already get the info during this query run?
    int     queried;          // how often did we already query for it this turn?

    nTimeRolling timeQuerySent;    //  the time the info query message was sent
    REAL         ping;             // the ping time

    nVersion version_;          // currently supported protocol versions
    tString release_;                   // release version
    bool                login2_;                // flag indicating whether the second version of the logic can be tried

    int     timesNotAnswered; // number of times the server did not answer to information queries recently
    bool    stillOnMasterServer; // flag indicating whether the server is still listed on the master

    // human information
    tString name;             // the human name of the server ("Z-Man's Armagetron Server");
    int     users;            // number of users online
    int   maxUsers_;            // maximum number of users allowed

    tString userNames_;         // names of the connected users
    tString userNamesOneLine_;// names of the connected users in one line
    tString options_;                   // description of non-default options
    tString url_;                               // url asociated with the server

    REAL    score;            // score based on ping and number of users (and game mode...)
    int     scoreBias_;         // score bias for this server

    virtual void DoNetWrite(nMessage &m) const; 
    virtual void DoNetRead (nMessage &m);       
    void NetWriteThis(nMessage &m) const;       
    void NetReadThis (nMessage &m);             

    virtual void DoGetFrom( nSocket const * socket );  

    // common subfunctions of the two BigServerInfo functions
    static nServerInfo* GetBigServerInfoCommon(nMessage &m);
    static void GiveBigServerInfoCommon(nMessage &m, const nServerInfo & info, nDescriptor& descriptor );

    nServerInfo( nServerInfo const & other );
    nServerInfo & operator = ( nServerInfo const & other );
public:
    nServerInfo();
    virtual ~nServerInfo();

    nServerInfo* Prev();

    virtual void CalcScore(); // calculates the score from other data

    // read/write all the information a normal server will broadcast
    // virtual void NetWrite(nMessage &m);
    // virtual void NetRead (nMessage &m);

    // the same for the information the master server is responsible for
    //  virtual void MasterNetWrite(nMessage &m);
    //  virtual void MasterNetRead (nMessage &m);

    virtual void Save(std::ostream &s) const;
    virtual void Load(std::istream &s);

    // sort key selection
    enum PrimaryKey
    {
        KEY_NAME,       // alphanumerically by name
        KEY_PING,       // by ping
        KEY_USERS,      // by number of players
        KEY_SCORE,      // by combined score
        KEY_MAX         // max value
    };

    static nServerInfo *GetFirstServer();  // get the first (best) server
    static void Sort( PrimaryKey key );    // sort the servers by score
    static void CalcScoreAll();            // calculate the score for all servers
    static void DeleteAll(bool autosave=true);     // delete all server infos

    virtual void Alive();                                       // called whenever the server gave a signal of life

    // reads small server information (adress, port, public key)
    // from the master server or response to a broadcast to the client
    static void GetSmallServerInfo(nMessage &m);

    // reads request for small server information from master server/broadcast
    static void GiveSmallServerInfo(nMessage &m);

    // reads rest of the server info (name, number of players,
    // etc) from the server
    static void GetBigServerInfo(nMessage &m);

    // reads request for big server information on a server
    static void GiveBigServerInfo(nMessage &m);

    // reads the rest of the server info (name, number of players,
    // etc) from the master
    static void GetBigServerInfoMaster(nMessage &m);

    // reads request for big server information on a master
    static void GiveBigServerInfoMaster(nMessage &m);

    // used to transfer the extra erver info (players, settings
    // etc) from the server directly to the client
    //  static void GetExtraServerInfo(nMessage &m);

    // request extra server information from master server/broadcast
    //static void GiveExtraServerInfo(nMessage &m);

    // set the function that creates new server infos (so the server infos
    // generated by calls from the master server can be of a derived class).
    // returns the old function, so you can resore it later.
    static sn_ServerInfoCreator* SetCreator(sn_ServerInfoCreator* creator);

    static void Save();      // save/load all server infos
    static void Save(const tPath& path, const char *filename);      // save/load all server infos
    static void Load(const tPath& path, const char *filename);

    static nServerInfo* GetMasters();              
    static nServerInfo* GetRandomMaster();         

    static void GetFromMaster(nServerInfoBase *masterInfo=NULL, char const * fileSuffix = NULL );  // get all the basic infos from the master server, stored in the server info file of the given suffix

    static void TellMasterAboutMe(nServerInfoBase *masterInfo=NULL);  // dedicated server: tell master server about my existence

    static void GetFromLAN(unsigned int pollBeginPort=4534, unsigned int pollEndPort=4544);                            // get all the basic infos from a LAN broadcast

    static void GetFromLANContinuously(unsigned int pollBeginPort=4534, unsigned int pollEndPort=4544);                            // get all the basic infos from a LAN broadcast; return immediately, servers will accumulate later
    static void GetFromLANContinuouslyStop();       // stop accepting servers from the LAN

    // enum describing the query type logic ( all non-queried servers are queried once indirectly over the master server )
    enum QueryType
    {
        QUERY_ALL=0,    
        QUERY_OPTOUT=1, 
        QUERY_OPTIN=2,  
        QUERY_NONE=3    
    };

    static void DeleteUnreachable();     

    static void StartQueryAll( QueryType query = QUERY_ALL );     // start querying the advanced info of each of the servers in our list

    static bool DoQueryAll(int simultaneous=10);         // continue querying the advanced info of each of the servers in our list; return value: do we need to go on with this?

    void QueryServer();     // start to get advanced info from this server itself
    void SetQueryType( QueryType query );     // set the query type for this server
    void ClearInfoFlags();                               

    void SetFromMaster();                               


    static void RunMaster();                             // run a master server


    static void GetSenderData(const nMessage &m,tString& name, int& port);

    // information query
    bool           Reachable()          const;
    bool           Polling()                    const;

    unsigned int   TransactionNr()      const   {return transactionNr;}
    unsigned int   Method()                     const   {return method;}
    const tArray<unsigned int>&Key()    const   {return key;}
    REAL           Ping()                               const   {return ping;}
    const       nVersion& Version()                     const   {return version_;}

    int            TimesNotAnswered() const     {return timesNotAnswered;}

    int            Users()            const     {return users;}
    int            MaxUsers()          const    {return maxUsers_;}

    const tString& UserNames()          const   { return userNames_;  }
    const tString& UserNamesOneLine()   const   { return userNamesOneLine_;  }
    const tString& Options()                    const   { return options_;  }
    const tString& Release()                    const   { return release_;  }
    const tString& Url()                                const   { return url_;  }

    REAL           Score()            const     {return score;}

    enum Compat
    {
        Compat_Ok,
        Compat_Downgrade,
        Compat_Upgrade
    };

    Compat      Compatibility()                 const;
    inline nServerInfo & SetScoreBias( int scoreBias ); 
    inline int GetScoreBias( void ) const;      
    inline nServerInfo const & GetScoreBias( int & scoreBias ) const;   

protected:
    virtual const tString& DoGetName() const;   

private:
    QueryType queryType_; 
};


class nServerInfoAdmin
{
    friend class nServerInfo;

public:

protected:
    nServerInfoAdmin();
    virtual ~nServerInfoAdmin();

private:
    virtual tString GetUsers()          const = 0;
    virtual tString     GetOptions()    const = 0;
    virtual tString GetUrl()            const = 0;

    static nServerInfoAdmin* GetAdmin();
};

// *******************************************************************************************
// *
// *   GetName
// *
// *******************************************************************************************
// *******************************************************************************************

const tString & nServerInfoBase::GetName( void ) const
{
    return DoGetName();
}

// *******************************************************************************************
// *
// *    GetScoreBias
// *
// *******************************************************************************************
// *******************************************************************************************

int nServerInfo::GetScoreBias( void ) const
{
    return this->scoreBias_;
}

// *******************************************************************************************
// *
// *    GetScoreBias
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfo const & nServerInfo::GetScoreBias( int & scoreBias ) const
{
    scoreBias = this->scoreBias_;
    return *this;
}

// *******************************************************************************************
// *
// *    SetScoreBias
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfo & nServerInfo::SetScoreBias( int scoreBias )
{
    this->scoreBias_ = scoreBias;
    return *this;
}

// *******************************************************************************************
// *
// *    NetWrite
// *
// *******************************************************************************************
// *******************************************************************************************

void nServerInfoBase::NetWrite( nMessage & message ) const
{
    DoNetWrite( message );
}

// *******************************************************************************************
// *
// *    NetRead
// *
// *******************************************************************************************
// *******************************************************************************************

void nServerInfoBase::NetRead( nMessage & message )
{
    DoNetRead( message );
}

// *******************************************************************************************
// *
// *    GetFrom
// *
// *******************************************************************************************
// *******************************************************************************************

void nServerInfoBase::GetFrom( nSocket const * socket )
{
    DoGetFrom( socket );
}

// *******************************************************************************************
// *
// *    GetConnectionName
// *
// *******************************************************************************************
// *******************************************************************************************

tString const & nServerInfoBase::GetConnectionName( void ) const
{
    return this->connectionName_;
}

// *******************************************************************************************
// *
// *    GetConnectionName
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfoBase const & nServerInfoBase::GetConnectionName( tString & connectionName ) const
{
    connectionName = this->connectionName_;
    return *this;
}

// *******************************************************************************************
// *
// *    SetConnectionName
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfoBase & nServerInfoBase::SetConnectionName( tString const & connectionName )
{
    this->connectionName_ = connectionName;
    return *this;
}

// *******************************************************************************************
// *
// *    GetPort
// *
// *******************************************************************************************
// *******************************************************************************************

unsigned nServerInfoBase::GetPort( void ) const
{
    return this->port_;
}

// *******************************************************************************************
// *
// *    GetPort
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfoBase const & nServerInfoBase::GetPort( unsigned & port ) const
{
    port = this->port_;
    return *this;
}

// *******************************************************************************************
// *
// *    SetPort
// *
// *******************************************************************************************
// *******************************************************************************************

nServerInfoBase & nServerInfoBase::SetPort( unsigned port )
{
    this->port_ = port;
    return *this;
}

#endif

---