sb_internal.h

#ifndef _SB_INTERNAL_H_
#define _SB_INTERNAL_H_
 
 
#include "../common/gsCommon.h"
#include "../common/gsAvailable.h"
 
#include "../darray.h"
#include "../hashtable.h"
 
#include "sb_serverbrowsing.h"
#include "../qr2/qr2regkeys.h"
 
#include "sb_crypt.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum {  pi_cryptheader,
                pi_fixedheader, 
                pi_keylist,
                pi_uniquevaluelist,
                pi_servers,
                pi_finished } SBListParseState;
 
 
typedef enum {sl_lanbrowse, sl_disconnected, sl_connected, sl_mainlist} SBServerListState;
 
 
//master server query port
#define MSPORT2 28910
 
//number of master servers
#define NUM_MASTER_SERVERS 20
 
//max length of field list to master server
#define MAX_FIELD_LIST_LEN 256
 
//max number of values in a popular value list
#define MAX_POPULAR_VALUES 255
 
//max number of maps to track in a map loop
#define MAX_MAPLOOP_LENGTH 16
 
// max number of bytes that can be received from a single recvfrom call
// This must not be higher than 2048 for PS2 insock compatability
#define MAX_RECVFROM_SIZE 2048
 
//states for SBServer->state 
#define STATE_BASICKEYS         (1 << 0)
#define STATE_FULLKEYS          (1 << 1)
#define STATE_PENDINGBASICQUERY (1 << 2)
#define STATE_PENDINGFULLQUERY  (1 << 3)
#define STATE_QUERYFAILED       (1 << 4)
#define STATE_PENDINGICMPQUERY  (1 << 5)
#define STATE_VALIDPING         (1 << 6)
#define STATE_PENDINGQUERYCHALLENGE (1 << 7)
 
//how long before a server query times out
#define MAX_QUERY_MSEC 2500
 
//game server flags
#define UNSOLICITED_UDP_FLAG    1
#define PRIVATE_IP_FLAG         2
#define CONNECT_NEGOTIATE_FLAG  4
#define ICMP_IP_FLAG            8
#define NONSTANDARD_PORT_FLAG   16
#define NONSTANDARD_PRIVATE_PORT_FLAG   32
#define HAS_KEYS_FLAG                   64
#define HAS_FULL_RULES_FLAG             128
 
//backend query flags (set in hbmaster, don't change)
#define QR2_USE_QUERY_CHALLENGE 128
 
//key types for the key type list
#define KEYTYPE_STRING  0
#define KEYTYPE_BYTE    1
#define KEYTYPE_SHORT   2
 
//how long to make the outgoing challenge
#define LIST_CHALLENGE_LEN 8
 
//protocol versions
#define LIST_PROTOCOL_VERSION 1
#define LIST_ENCODING_VERSION 3
 
//message types for outgoing requests
#define SERVER_LIST_REQUEST     0
#define SERVER_INFO_REQUEST     1
#define SEND_MESSAGE_REQUEST    2
#define KEEPALIVE_REPLY         3
#define MAPLOOP_REQUEST         4
#define PLAYERSEARCH_REQUEST    5
 
//message types for incoming requests
#define PUSH_KEYS_MESSAGE       1
#define PUSH_SERVER_MESSAGE     2
#define KEEPALIVE_MESSAGE       3
#define DELETE_SERVER_MESSAGE   4
#define MAPLOOP_MESSAGE         5
#define PLAYERSEARCH_MESSAGE    6
 
//server list update options
#define SEND_FIELDS_FOR_ALL     1
#define NO_SERVER_LIST          2
#define PUSH_UPDATES            4
#define SEND_GROUPS             32
#define NO_LIST_CACHE           64
#define LIMIT_RESULT_COUNT      128
 
//player search options
#define SEARCH_ALL_GAMES        1
#define SEARCH_LEFT_SUBSTRING   2
#define SEARCH_RIGHT_SUBSTRING  4
#define SEARCH_ANY_SUBSTRING    8
 
//max number of keys for the basic key list
#define MAX_QUERY_KEYS 20
 
//how long to search on the LAN
#define SL_LAN_SEARCH_TIME 2000
 
//MAGIC bytes for the QR2 queries
#define QR2_MAGIC_1 0xFE
#define QR2_MAGIC_2 0xFD
 
//magic bytes for nat negotiation message
#define NATNEG_MAGIC_LEN 6
#define NN_MAGIC_0 0xFD
#define NN_MAGIC_1 0xFC
#define NN_MAGIC_2 0x1E
#define NN_MAGIC_3 0x66
#define NN_MAGIC_4 0x6A
#define NN_MAGIC_5 0xB2
 
 
//query types
#define QTYPE_BASIC 0
#define QTYPE_FULL  1
#define QTYPE_ICMP  2
 
//query strings for old-style servers
#define BASIC_GOA_QUERY "\\basic\\\\info\\"
#define BASIC_GOA_QUERY_LEN 13
#define FULL_GOA_QUERY "\\status\\"
#define FULL_GOA_QUERY_LEN 8
 
//maximum length of a sortkey string
#define SORTKEY_LENGTH 255
 
//include ICMP support by default
#ifndef SB_NO_ICMP_SUPPORT
    #undef SB_ICMP_SUPPORT
    #define SB_ICMP_SUPPORT
#endif
 
//a key/value pair
typedef struct _SBKeyValuePair
{
    const char *key;
    const char *value;
} SBKeyValuePair;
 
 
//a ref-counted string
typedef struct _SBRefString
{
    const char *str;
#ifdef GSI_UNICODE
    const unsigned short *str_W;
#endif
    int refcount;
} SBRefString;
 
 
typedef struct _SBServerList *SBServerListPtr;
typedef struct _SBQueryEngine *SBQueryEnginePtr;
 
//callback types for server lists
typedef enum {slc_serveradded, slc_serverupdated, slc_serverdeleted, slc_initiallistcomplete, slc_disconnected, slc_queryerror, slc_publicipdetermined, slc_serverchallengereceived} SBListCallbackReason;
//callback types for query engine
typedef enum {qe_updatesuccess, qe_updatefailed, qe_engineidle, qe_challengereceived} SBQueryEngineCallbackReason;
 
//callback function prototypes
typedef void (*SBListCallBackFn)(SBServerListPtr serverlist, SBListCallbackReason reason, SBServer server, void *instance);
typedef void (*SBEngineCallbackFn)(SBQueryEnginePtr engine, SBQueryEngineCallbackReason reason, SBServer server, void *instance);
typedef void (*SBMaploopCallbackFn)(SBServerListPtr serverlist, SBServer server, time_t mapChangeTime, int numMaps, char *mapList[], void *instance);
typedef void (*SBPlayerSearchCallbackFn)(SBServerListPtr serverlist, char *nick, goa_uint32 serverIP, unsigned short serverPort, time_t lastSeenTime, char *gamename, void *instance);
 
//key information structure
typedef struct _KeyInfo
{
    const char *keyName;
    int keyType;
} KeyInfo;
 
 
typedef struct _SBServerList SBServerList;
 
#ifdef VENGINE_SUPPORT
    #define FTABLE_TYPES
    #include "../../VEngine/ve_gm3ftable.h"
#endif
 
 
//keeps track of previous and current sorting information
typedef struct _SortInfo
{
    gsi_char sortkey[SORTKEY_LENGTH];
    SBCompareMode comparemode;  
} SortInfo;
 
struct _SBServerList
{
    SBServerListState state;
    DArray servers;
    DArray keylist;
    char queryforgamename[36];
    char queryfromgamename[36];
    char queryfromkey[32];
    char mychallenge[LIST_CHALLENGE_LEN];
    char *inbuffer;
    int inbufferlen;
    const char *popularvalues[MAX_POPULAR_VALUES];
    int numpopularvalues;
    int expectedelements;
    
    SBListCallBackFn ListCallback;
    SBMaploopCallbackFn MaploopCallback;
    SBPlayerSearchCallbackFn PlayerSearchCallback;
    void *instance;
 
    SortInfo currsortinfo;
    SortInfo prevsortinfo;
 
    SBBool sortascending;
    goa_uint32 mypublicip;
    goa_uint32 srcip;
    unsigned short defaultport;
 
    char *lasterror;
#ifdef GSI_UNICODE
    unsigned short *lasterror_W;
#endif
 
    SOCKET slsocket;
    gsi_time lanstarttime;
    int fromgamever;
    GOACryptState cryptkey;
    int queryoptions;
    SBListParseState pstate;
    gsi_u16 backendgameflags;
 
    const char* mLanAdapterOverride;
 
    SBServer deadlist;
    
#ifdef VENGINE_SUPPORT
    #define FTABLE_IMPLEMENT
    #include "../../VEngine/ve_gm3ftable.h"
#endif
 
};
 
 
//server object
 
#ifndef SB_SERVER_DECLARED
#define SB_SERVER_DECLARED
 
struct _SBServer
{
    goa_uint32 publicip;
    unsigned short publicport;
    goa_uint32 privateip;
    unsigned short privateport;
    goa_uint32 icmpip;  
    unsigned char state;
    unsigned char flags;
    HashTable keyvals;
    gsi_time updatetime;
    gsi_u32 querychallenge;
    struct _SBServer *next;
    gsi_u8 splitResponseBitmap;
};
 
#endif
 
typedef struct _SBServerFIFO
{
    SBServer first;
    SBServer last;
    int count;
} SBServerFIFO;
 
typedef struct _SBQueryEngine
{
    int queryversion;
    int maxupdates;
    SBServerFIFO querylist;
    SBServerFIFO pendinglist;
    SOCKET querysock;
    #if !defined(SN_SYSTEMS)
    SOCKET icmpsock;
    #endif
    goa_uint32 mypublicip;
    unsigned char serverkeys[MAX_QUERY_KEYS];
    int numserverkeys;  
    SBEngineCallbackFn ListCallback;
    void *instance;
} SBQueryEngine;
 
 
struct _ServerBrowser
{
    SBQueryEngine engine;
    SBServerList list;
    SBBool disconnectFlag;
    SBBool dontUpdate;
    goa_uint32 triggerIP;
    unsigned short triggerPort;
    ServerBrowserCallback BrowserCallback;
    SBConnectToServerCallback ConnectCallback;
    void *instance;
};
 
#define SB_ICMP_ECHO 8
#define SB_ICMP_ECHO_REPLY  0
 
typedef struct _IPHeader {
    gsi_u8  ip_hl_ver;
    gsi_u8  ip_tos;
    gsi_i16   ip_len;
    gsi_u16 ip_id; 
    gsi_i16   ip_off;
    gsi_u8  ip_ttl;
    gsi_u8  ip_p;
    gsi_u16 ip_sum;
    struct  in_addr ip_src,ip_dst; 
} SBIPHeader;
 
 
 
typedef struct _ICMPHeader
{
    gsi_u8      type;
    gsi_u8      code;
    gsi_u16 cksum;
    union {
        struct {
            gsi_u16 id;
            gsi_u16 sequence;
        } echo;
        gsi_u32 idseq;
        gsi_u16 gateway;
        struct {
            gsi_u16 __notused;
            gsi_u16 mtu;
        } frag;
    } un;
} SBICMPHeader;
 
 
//server list functions
void SBServerListInit(SBServerList *slist, const char *queryForGamename, const char *queryFromGamename, const char *queryFromKey, int queryFromVersion, SBBool lanBrowse, SBListCallBackFn callback, void *instance);
SBError SBServerListConnectAndQuery(SBServerList *slist, const char *fieldList, const char *serverFilter, int options, int maxServers);
SBError SBServerListGetLANList(SBServerList *slist, unsigned short startport, unsigned short endport, int queryversion);
void SBServerListDisconnect(SBServerList *slist);
void SBServerListCleanup(SBServerList *slist); 
void SBServerListClear(SBServerList *slist);
SBError SBGetServerRulesFromMaster(SBServerList *slist, goa_uint32 ip, unsigned short port);
SBError SBSendMessageToServer(SBServerList *slist, goa_uint32 ip, unsigned short port, const char *data, int len);
SBError SBSendNatNegotiateCookieToServer(SBServerList *slist, goa_uint32 ip, unsigned short port, int cookie);
SBError SBSendMaploopRequest(SBServerList *slist, SBServer server, SBMaploopCallbackFn callback);
SBError SBSendPlayerSearchRequest(SBServerList *slist, char *searchName, int searchOptions, int maxResults, SBPlayerSearchCallbackFn callback);
int SBServerListFindServerByIP(SBServerList *slist, goa_uint32 ip, unsigned short port);
int SBServerListFindServer(SBServerList *slist, SBServer findserver);
void SBServerListRemoveAt(SBServerList *slist, int index);
void SBServerListAppendServer(SBServerList *slist, SBServer server);
void SBServerListSort(SBServerList *slist, SBBool ascending, SortInfo sortinfo);
int SBServerListCount(SBServerList *slist);
SBServer SBServerListNth(SBServerList *slist, int i);
SBError SBListThink(SBServerList *slist);
const char *SBLastListErrorA(SBServerList *slist);
const unsigned short *SBLastListErrorW(SBServerList *slist);
void SBSetLastListErrorPtr(SBServerList *slist, char* theError);
void SBFreeDeadList(SBServerList *slist);
void SBAllocateServerList(SBServerList *slist);
 
//sbserver functions
SBServer SBAllocServer(SBServerList *slist, goa_uint32 publicip, unsigned short publicport);
void SBServerFree(void *elem);
void SBServerAddKeyValue(SBServer server, const char *keyname, const char *value);
void SBServerAddIntKeyValue(SBServer server, const char *keyname, int value);
void SBServerParseKeyVals(SBServer server, char *keyvals);
void SBServerParseQR2FullKeysSingle(SBServer server, char *data, int len);
void SBServerParseQR2FullKeysSplit(SBServer server, char *data, int len);
void SBServerSetFlags(SBServer server, unsigned char flags);
void SBServerSetPublicAddr(SBServer server, goa_uint32 ip, unsigned short port);
void SBServerSetPrivateAddr(SBServer server, goa_uint32 ip, unsigned short port);
void SBServerSetICMPIP(SBServer server, goa_uint32 icmpip);
void SBServerSetState(SBServer server, unsigned char state);
void SBServerSetNext(SBServer server, SBServer next);
SBServer SBServerGetNext(SBServer server);
unsigned char SBServerGetState(SBServer server);
unsigned char SBServerGetFlags(SBServer server);
unsigned short SBServerGetPublicQueryPortNBO(SBServer server);
int SBIsNullServer(SBServer server);
extern SBServer SBNullServer;
 
 
//ref-str functions
const char *SBRefStr(SBServerList *slist,const char *str);
void SBReleaseStr(SBServerList *slist,const char *str);
HashTable SBRefStrHash(SBServerList *slist);
void SBRefStrHashCleanup(SBServerList *slist);
 
extern char *SBOverrideMasterServer;
 
 
//query engine functions
void SBQueryEngineInit(SBQueryEngine *engine, int maxupdates, int queryversion, SBBool lanBrowse, SBEngineCallbackFn callback, void *instance);
void SBQueryEngineUpdateServer(SBQueryEngine *engine, SBServer server, int addfront, int querytype, SBBool usequerychallenge);
void SBQueryEngineSetPublicIP(SBQueryEngine *engine, goa_uint32 mypublicip);
SBServer SBQueryEngineUpdateServerByIP(SBQueryEngine *engine, const char *ip, unsigned short queryport, int addfront, int querytype, SBBool usequerychallenge);
void SBQueryEngineThink(SBQueryEngine *engine);
void SBQueryEngineAddQueryKey(SBQueryEngine *engine, unsigned char keyid);
void SBEngineCleanup(SBQueryEngine *engine);
void SBQueryEngineRemoveServerFromFIFOs(SBQueryEngine *engine, SBServer server);
int NTSLengthSB(char *buf, int len);
void SBEngineHaltUpdates(SBQueryEngine *engine);
 
 
//server browser internal function
SBError ServerBrowserBeginUpdate2(ServerBrowser sb, SBBool async, SBBool disconnectOnComplete, const unsigned char *basicFields, int numBasicFields, const char *serverFilter, int updateOptions, int maxServers);
 
 
// Ascii versions of functions that should still be available in GSI_UNICODE mode
#ifdef GSI_UNICODE
const char *SBServerGetStringValueA(SBServer server, const char *keyname, const char *def); // for peer SDK
int SBServerGetIntValueA(SBServer server, const char *key, int idefault);
#endif
 
 
#ifdef __cplusplus
}
#endif
 
#endif