src/engine/client/serverbrowser.cpp

   1 /* (c) Magnus Auvinen. See licence.txt in the root of the distribution for more information. */
   2 /* If you are missing that file, acquire a complete release at teeworlds.com.                */
   3 #include <algorithm> // sort
   4
   5 #include <base/math.h>
   6 #include <base/system.h>
   7
   8 #include <engine/shared/config.h>
   9 #include <engine/shared/memheap.h>
  10 #include <engine/shared/network.h>
  11 #include <engine/shared/protocol.h>
  12
  13 #include <engine/config.h>
  14 #include <engine/console.h>
  15 #include <engine/friends.h>
  16 #include <engine/masterserver.h>
  17
  18 #include <mastersrv/mastersrv.h>
  19
  20 #include "serverbrowser.h"
  21
  22 class SortWrap
  23 {
  24         typedef bool (CServerBrowser::*SortFunc)(int, int) const;
  25         SortFunc m_pfnSort;
  26         CServerBrowser *m_pThis;
  27 public:
  28         SortWrap(CServerBrowser *t, SortFunc f) : m_pfnSort(f), m_pThis(t) {}
  29         bool operator()(int a, int b) { return (m_pThis->*m_pfnSort)(a, b); }
  30 };
  31
  32 CServerBrowser::CServerBrowser()
  33 {
  34         m_pMasterServer = 0;
  35         m_ppServerlist = 0;
  36         m_pSortedServerlist = 0;
  37
  38         m_NumFavoriteServers = 0;
  39
  40         mem_zero(m_aServerlistIp, sizeof(m_aServerlistIp));
  41
  42         m_pFirstReqServer = 0; // request list
  43         m_pLastReqServer = 0;
  44         m_NumRequests = 0;
  45
  46         m_NeedRefresh = 0;
  47
  48         m_NumSortedServers = 0;
  49         m_NumSortedServersCapacity = 0;
  50         m_NumServers = 0;
  51         m_NumServerCapacity = 0;
  52
  53         m_Sorthash = 0;
  54         m_aFilterString[0] = 0;
  55         m_aFilterGametypeString[0] = 0;
  56
  57         // the token is to keep server refresh separated from each other
  58         m_CurrentToken = 1;
  59
  60         m_ServerlistType = 0;
  61         m_BroadcastTime = 0;
  62 }
  63
  64 void CServerBrowser::SetBaseInfo(class CNetClient *pClient, const char *pNetVersion)
  65 {
  66         m_pNetClient = pClient;
  67         str_copy(m_aNetVersion, pNetVersion, sizeof(m_aNetVersion));
  68         m_pMasterServer = Kernel()->RequestInterface<IMasterServer>();
  69         m_pConsole = Kernel()->RequestInterface<IConsole>();
  70         m_pFriends = Kernel()->RequestInterface<IFriends>();
  71         IConfig *pConfig = Kernel()->RequestInterface<IConfig>();
  72         if(pConfig)
  73                 pConfig->RegisterCallback(ConfigSaveCallback, this);
  74 }
  75
  76 const CServerInfo *CServerBrowser::SortedGet(int Index) const
  77 {
  78         if(Index < 0 || Index >= m_NumSortedServers)
  79                 return 0;
  80         return &m_ppServerlist[m_pSortedServerlist[Index]]->m_Info;
  81 }
  82
  83
  84 bool CServerBrowser::SortCompareName(int Index1, int Index2) const
  85 {
  86         CServerEntry *a = m_ppServerlist[Index1];
  87         CServerEntry *b = m_ppServerlist[Index2];
  88         //      make sure empty entries are listed last
  89         return (a->m_GotInfo && b->m_GotInfo) || (!a->m_GotInfo && !b->m_GotInfo) ? str_comp(a->m_Info.m_aName, b->m_Info.m_aName) < 0 :
  90                         a->m_GotInfo ? true : false;
  91 }
  92
  93 bool CServerBrowser::SortCompareMap(int Index1, int Index2) const
  94 {
  95         CServerEntry *a = m_ppServerlist[Index1];
  96         CServerEntry *b = m_ppServerlist[Index2];
  97         return str_comp(a->m_Info.m_aMap, b->m_Info.m_aMap) < 0;
  98 }
  99
 100 bool CServerBrowser::SortComparePing(int Index1, int Index2) const
 101 {
 102         CServerEntry *a = m_ppServerlist[Index1];
 103         CServerEntry *b = m_ppServerlist[Index2];
 104         return a->m_Info.m_Latency < b->m_Info.m_Latency;
 105 }
 106
 107 bool CServerBrowser::SortCompareGametype(int Index1, int Index2) const
 108 {
 109         CServerEntry *a = m_ppServerlist[Index1];
 110         CServerEntry *b = m_ppServerlist[Index2];
 111         return str_comp(a->m_Info.m_aGameType, b->m_Info.m_aGameType) < 0;
 112 }
 113
 114 bool CServerBrowser::SortCompareNumPlayers(int Index1, int Index2) const
 115 {
 116         CServerEntry *a = m_ppServerlist[Index1];
 117         CServerEntry *b = m_ppServerlist[Index2];
 118         return a->m_Info.m_NumPlayers < b->m_Info.m_NumPlayers;
 119 }
 120
 121 bool CServerBrowser::SortCompareNumClients(int Index1, int Index2) const
 122 {
 123         CServerEntry *a = m_ppServerlist[Index1];
 124         CServerEntry *b = m_ppServerlist[Index2];
 125         return a->m_Info.m_NumClients < b->m_Info.m_NumClients;
 126 }
 127
 128 void CServerBrowser::Filter()
 129 {
 130         int i = 0, p = 0;
 131         m_NumSortedServers = 0;
 132
 133         // allocate the sorted list
 134         if(m_NumSortedServersCapacity < m_NumServers)
 135         {
 136                 if(m_pSortedServerlist)
 137                         mem_free(m_pSortedServerlist);
 138                 m_NumSortedServersCapacity = m_NumServers;
 139                 m_pSortedServerlist = (int *)mem_alloc(m_NumSortedServersCapacity*sizeof(int), 1);
 140         }
 141
 142         // filter the servers
 143         for(i = 0; i < m_NumServers; i++)
 144         {
 145                 int Filtered = 0;
 146
 147                 if(g_Config.m_BrFilterEmpty && ((g_Config.m_BrFilterSpectators && m_ppServerlist[i]->m_Info.m_NumPlayers == 0) || m_ppServerlist[i]->m_Info.m_NumClients == 0))
 148                         Filtered = 1;
 149                 else if(g_Config.m_BrFilterFull && ((g_Config.m_BrFilterSpectators && m_ppServerlist[i]->m_Info.m_NumPlayers == m_ppServerlist[i]->m_Info.m_MaxPlayers) ||
 150                                 m_ppServerlist[i]->m_Info.m_NumClients == m_ppServerlist[i]->m_Info.m_MaxClients))
 151                         Filtered = 1;
 152                 else if(g_Config.m_BrFilterPw && m_ppServerlist[i]->m_Info.m_Flags&SERVER_FLAG_PASSWORD)
 153                         Filtered = 1;
 154                 else if(g_Config.m_BrFilterPure &&
 155                         (str_comp(m_ppServerlist[i]->m_Info.m_aGameType, "DM") != 0 &&
 156                         str_comp(m_ppServerlist[i]->m_Info.m_aGameType, "TDM") != 0 &&
 157                         str_comp(m_ppServerlist[i]->m_Info.m_aGameType, "CTF") != 0))
 158                 {
 159                         Filtered = 1;
 160                 }
 161                 else if(g_Config.m_BrFilterPureMap &&
 162                         !(str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm1") == 0 ||
 163                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm2") == 0 ||
 164                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm6") == 0 ||
 165                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm7") == 0 ||
 166                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm8") == 0 ||
 167                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "dm9") == 0 ||
 168                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf1") == 0 ||
 169                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf2") == 0 ||
 170                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf3") == 0 ||
 171                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf4") == 0 ||
 172                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf5") == 0 ||
 173                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf6") == 0 ||
 174                         str_comp(m_ppServerlist[i]->m_Info.m_aMap, "ctf7") == 0)
 175                 )
 176                 {
 177                         Filtered = 1;
 178                 }
 179                 else if(g_Config.m_BrFilterPing < m_ppServerlist[i]->m_Info.m_Latency)
 180                         Filtered = 1;
 181                 else if(g_Config.m_BrFilterCompatversion && str_comp_num(m_ppServerlist[i]->m_Info.m_aVersion, m_aNetVersion, 3) != 0)
 182                         Filtered = 1;
 183                 else if(g_Config.m_BrFilterServerAddress[0] && !str_find_nocase(m_ppServerlist[i]->m_Info.m_aAddress, g_Config.m_BrFilterServerAddress))
 184                         Filtered = 1;
 185                 else if(g_Config.m_BrFilterGametypeStrict && g_Config.m_BrFilterGametype[0] && str_comp_nocase(m_ppServerlist[i]->m_Info.m_aGameType, g_Config.m_BrFilterGametype))
 186                         Filtered = 1;
 187                 else if(!g_Config.m_BrFilterGametypeStrict && g_Config.m_BrFilterGametype[0] && !str_find_nocase(m_ppServerlist[i]->m_Info.m_aGameType, g_Config.m_BrFilterGametype))
 188                         Filtered = 1;
 189                 else
 190                 {
 191                         if(g_Config.m_BrFilterCountry)
 192                         {
 193                                 Filtered = 1;
 194                                 // match against player country
 195                                 for(p = 0; p < m_ppServerlist[i]->m_Info.m_NumClients; p++)
 196                                 {
 197                                         if(m_ppServerlist[i]->m_Info.m_aClients[p].m_Country == g_Config.m_BrFilterCountryIndex)
 198                                         {
 199                                                 Filtered = 0;
 200                                                 break;
 201                                         }
 202                                 }
 203                         }
 204
 205                         if(!Filtered && g_Config.m_BrFilterString[0] != 0)
 206                         {
 207                                 int MatchFound = 0;
 208
 209                                 m_ppServerlist[i]->m_Info.m_QuickSearchHit = 0;
 210
 211                                 // match against server name
 212                                 if(str_find_nocase(m_ppServerlist[i]->m_Info.m_aName, g_Config.m_BrFilterString))
 213                                 {
 214                                         MatchFound = 1;
 215                                         m_ppServerlist[i]->m_Info.m_QuickSearchHit |= IServerBrowser::QUICK_SERVERNAME;
 216                                 }
 217
 218                                 // match against players
 219                                 for(p = 0; p < m_ppServerlist[i]->m_Info.m_NumClients; p++)
 220                                 {
 221                                         if(str_find_nocase(m_ppServerlist[i]->m_Info.m_aClients[p].m_aName, g_Config.m_BrFilterString) ||
 222                                                 str_find_nocase(m_ppServerlist[i]->m_Info.m_aClients[p].m_aClan, g_Config.m_BrFilterString))
 223                                         {
 224                                                 MatchFound = 1;
 225                                                 m_ppServerlist[i]->m_Info.m_QuickSearchHit |= IServerBrowser::QUICK_PLAYER;
 226                                                 break;
 227                                         }
 228                                 }
 229
 230                                 // match against map
 231                                 if(str_find_nocase(m_ppServerlist[i]->m_Info.m_aMap, g_Config.m_BrFilterString))
 232                                 {
 233                                         MatchFound = 1;
 234                                         m_ppServerlist[i]->m_Info.m_QuickSearchHit |= IServerBrowser::QUICK_MAPNAME;
 235                                 }
 236
 237                                 if(!MatchFound)
 238                                         Filtered = 1;
 239                         }
 240                 }
 241
 242                 if(Filtered == 0)
 243                 {
 244                         // check for friend
 245                         m_ppServerlist[i]->m_Info.m_FriendState = IFriends::FRIEND_NO;
 246                         for(p = 0; p < m_ppServerlist[i]->m_Info.m_NumClients; p++)
 247                         {
 248                                 m_ppServerlist[i]->m_Info.m_aClients[p].m_FriendState = m_pFriends->GetFriendState(m_ppServerlist[i]->m_Info.m_aClients[p].m_aName,
 249                                         m_ppServerlist[i]->m_Info.m_aClients[p].m_aClan);
 250                                 m_ppServerlist[i]->m_Info.m_FriendState = max(m_ppServerlist[i]->m_Info.m_FriendState, m_ppServerlist[i]->m_Info.m_aClients[p].m_FriendState);
 251                         }
 252
 253                         if(!g_Config.m_BrFilterFriends || m_ppServerlist[i]->m_Info.m_FriendState != IFriends::FRIEND_NO)
 254                                 m_pSortedServerlist[m_NumSortedServers++] = i;
 255                 }
 256         }
 257 }
 258
 259 int CServerBrowser::SortHash() const
 260 {
 261         int i = g_Config.m_BrSort&0xf;
 262         i |= g_Config.m_BrFilterEmpty<<4;
 263         i |= g_Config.m_BrFilterFull<<5;
 264         i |= g_Config.m_BrFilterSpectators<<6;
 265         i |= g_Config.m_BrFilterFriends<<7;
 266         i |= g_Config.m_BrFilterPw<<8;
 267         i |= g_Config.m_BrSortOrder<<9;
 268         i |= g_Config.m_BrFilterCompatversion<<10;
 269         i |= g_Config.m_BrFilterPure<<11;
 270         i |= g_Config.m_BrFilterPureMap<<12;
 271         i |= g_Config.m_BrFilterGametypeStrict<<13;
 272         i |= g_Config.m_BrFilterCountry<<14;
 273         i |= g_Config.m_BrFilterPing<<15;
 274         return i;
 275 }
 276
 277 void CServerBrowser::Sort()
 278 {
 279         int i;
 280
 281         // create filtered list
 282         Filter();
 283
 284         // sort
 285         if(g_Config.m_BrSort == IServerBrowser::SORT_NAME)
 286                 std::sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareName));
 287         else if(g_Config.m_BrSort == IServerBrowser::SORT_PING)
 288                 std::sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortComparePing));
 289         else if(g_Config.m_BrSort == IServerBrowser::SORT_MAP)
 290                 std::sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareMap));
 291         else if(g_Config.m_BrSort == IServerBrowser::SORT_NUMPLAYERS)
 292                 std::sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this,
 293                                         g_Config.m_BrFilterSpectators ? &CServerBrowser::SortCompareNumPlayers : &CServerBrowser::SortCompareNumClients));
 294         else if(g_Config.m_BrSort == IServerBrowser::SORT_GAMETYPE)
 295                 std::sort(m_pSortedServerlist, m_pSortedServerlist+m_NumSortedServers, SortWrap(this, &CServerBrowser::SortCompareGametype));
 296
 297         // invert the list if requested
 298         if(g_Config.m_BrSortOrder)
 299         {
 300                 for(i = 0; i < m_NumSortedServers/2; i++)
 301                 {
 302                         int Temp = m_pSortedServerlist[i];
 303                         m_pSortedServerlist[i] = m_pSortedServerlist[m_NumSortedServers-i-1];
 304                         m_pSortedServerlist[m_NumSortedServers-i-1] = Temp;
 305                 }
 306         }
 307
 308         // set indexes
 309         for(i = 0; i < m_NumSortedServers; i++)
 310                 m_ppServerlist[m_pSortedServerlist[i]]->m_Info.m_SortedIndex = i;
 311
 312         str_copy(m_aFilterGametypeString, g_Config.m_BrFilterGametype, sizeof(m_aFilterGametypeString));
 313         str_copy(m_aFilterString, g_Config.m_BrFilterString, sizeof(m_aFilterString));
 314         m_Sorthash = SortHash();
 315 }
 316
 317 void CServerBrowser::RemoveRequest(CServerEntry *pEntry)
 318 {
 319         if(pEntry->m_pPrevReq || pEntry->m_pNextReq || m_pFirstReqServer == pEntry)
 320         {
 321                 if(pEntry->m_pPrevReq)
 322                         pEntry->m_pPrevReq->m_pNextReq = pEntry->m_pNextReq;
 323                 else
 324                         m_pFirstReqServer = pEntry->m_pNextReq;
 325
 326                 if(pEntry->m_pNextReq)
 327                         pEntry->m_pNextReq->m_pPrevReq = pEntry->m_pPrevReq;
 328                 else
 329                         m_pLastReqServer = pEntry->m_pPrevReq;
 330
 331                 pEntry->m_pPrevReq = 0;
 332                 pEntry->m_pNextReq = 0;
 333                 m_NumRequests--;
 334         }
 335 }
 336
 337 CServerBrowser::CServerEntry *CServerBrowser::Find(const NETADDR &Addr)
 338 {
 339         CServerEntry *pEntry = m_aServerlistIp[Addr.ip[0]];
 340
 341         for(; pEntry; pEntry = pEntry->m_pNextIp)
 342         {
 343                 if(net_addr_comp(&pEntry->m_Addr, &Addr) == 0)
 344                         return pEntry;
 345         }
 346         return (CServerEntry*)0;
 347 }
 348
 349 void CServerBrowser::QueueRequest(CServerEntry *pEntry)
 350 {
 351         // add it to the list of servers that we should request info from
 352         pEntry->m_pPrevReq = m_pLastReqServer;
 353         if(m_pLastReqServer)
 354                 m_pLastReqServer->m_pNextReq = pEntry;
 355         else
 356                 m_pFirstReqServer = pEntry;
 357         m_pLastReqServer = pEntry;
 358
 359         m_NumRequests++;
 360 }
 361
 362 void CServerBrowser::SetInfo(CServerEntry *pEntry, const CServerInfo &Info)
 363 {
 364         int Fav = pEntry->m_Info.m_Favorite;
 365         pEntry->m_Info = Info;
 366         pEntry->m_Info.m_Favorite = Fav;
 367         pEntry->m_Info.m_NetAddr = pEntry->m_Addr;
 368
 369         // all these are just for nice compability
 370         if(pEntry->m_Info.m_aGameType[0] == '0' && pEntry->m_Info.m_aGameType[1] == 0)
 371                 str_copy(pEntry->m_Info.m_aGameType, "DM", sizeof(pEntry->m_Info.m_aGameType));
 372         else if(pEntry->m_Info.m_aGameType[0] == '1' && pEntry->m_Info.m_aGameType[1] == 0)
 373                 str_copy(pEntry->m_Info.m_aGameType, "TDM", sizeof(pEntry->m_Info.m_aGameType));
 374         else if(pEntry->m_Info.m_aGameType[0] == '2' && pEntry->m_Info.m_aGameType[1] == 0)
 375                 str_copy(pEntry->m_Info.m_aGameType, "CTF", sizeof(pEntry->m_Info.m_aGameType));
 376
 377         /*if(!request)
 378         {
 379                 pEntry->m_Info.latency = (time_get()-pEntry->request_time)*1000/time_freq();
 380                 RemoveRequest(pEntry);
 381         }*/
 382
 383         pEntry->m_GotInfo = 1;
 384         Sort();
 385 }
 386
 387 CServerBrowser::CServerEntry *CServerBrowser::Add(const NETADDR &Addr)
 388 {
 389         int Hash = Addr.ip[0];
 390         CServerEntry *pEntry = 0;
 391         int i;
 392
 393         // create new pEntry
 394         pEntry = (CServerEntry *)m_ServerlistHeap.Allocate(sizeof(CServerEntry));
 395         mem_zero(pEntry, sizeof(CServerEntry));
 396
 397         // set the info
 398         pEntry->m_Addr = Addr;
 399         pEntry->m_Info.m_NetAddr = Addr;
 400
 401         pEntry->m_Info.m_Latency = 999;
 402         net_addr_str(&Addr, pEntry->m_Info.m_aAddress, sizeof(pEntry->m_Info.m_aAddress));
 403         str_copy(pEntry->m_Info.m_aName, pEntry->m_Info.m_aAddress, sizeof(pEntry->m_Info.m_aName));
 404
 405         // check if it's a favorite
 406         for(i = 0; i < m_NumFavoriteServers; i++)
 407         {
 408                 if(net_addr_comp(&Addr, &m_aFavoriteServers[i]) == 0)
 409                         pEntry->m_Info.m_Favorite = 1;
 410         }
 411
 412         // add to the hash list
 413         pEntry->m_pNextIp = m_aServerlistIp[Hash];
 414         m_aServerlistIp[Hash] = pEntry;
 415
 416         if(m_NumServers == m_NumServerCapacity)
 417         {
 418                 CServerEntry **ppNewlist;
 419                 m_NumServerCapacity += 100;
 420                 ppNewlist = (CServerEntry **)mem_alloc(m_NumServerCapacity*sizeof(CServerEntry*), 1);
 421                 mem_copy(ppNewlist, m_ppServerlist, m_NumServers*sizeof(CServerEntry*));
 422                 mem_free(m_ppServerlist);
 423                 m_ppServerlist = ppNewlist;
 424         }
 425
 426         // add to list
 427         m_ppServerlist[m_NumServers] = pEntry;
 428         pEntry->m_Info.m_ServerIndex = m_NumServers;
 429         m_NumServers++;
 430
 431         return pEntry;
 432 }
 433
 434 void CServerBrowser::Set(const NETADDR &Addr, int Type, int Token, const CServerInfo *pInfo)
 435 {
 436         CServerEntry *pEntry = 0;
 437         if(Type == IServerBrowser::SET_MASTER_ADD)
 438         {
 439                 if(m_ServerlistType != IServerBrowser::TYPE_INTERNET)
 440                         return;
 441
 442                 if(!Find(Addr))
 443                 {
 444                         pEntry = Add(Addr);
 445                         QueueRequest(pEntry);
 446                 }
 447         }
 448         else if(Type == IServerBrowser::SET_FAV_ADD)
 449         {
 450                 if(m_ServerlistType != IServerBrowser::TYPE_FAVORITES)
 451                         return;
 452
 453                 if(!Find(Addr))
 454                 {
 455                         pEntry = Add(Addr);
 456                         QueueRequest(pEntry);
 457                 }
 458         }
 459         else if(Type == IServerBrowser::SET_TOKEN)
 460         {
 461                 if(Token != m_CurrentToken)
 462                         return;
 463
 464                 pEntry = Find(Addr);
 465                 if(!pEntry)
 466                         pEntry = Add(Addr);
 467                 if(pEntry)
 468                 {
 469                         SetInfo(pEntry, *pInfo);
 470                         if(m_ServerlistType == IServerBrowser::TYPE_LAN)
 471                                 pEntry->m_Info.m_Latency = min(static_cast<int>((time_get()-m_BroadcastTime)*1000/time_freq()), 999);
 472                         else
 473                                 pEntry->m_Info.m_Latency = min(static_cast<int>((time_get()-pEntry->m_RequestTime)*1000/time_freq()), 999);
 474                         RemoveRequest(pEntry);
 475                 }
 476         }
 477
 478         Sort();
 479 }
 480
 481 void CServerBrowser::Refresh(int Type)
 482 {
 483         // clear out everything
 484         m_ServerlistHeap.Reset();
 485         m_NumServers = 0;
 486         m_NumSortedServers = 0;
 487         mem_zero(m_aServerlistIp, sizeof(m_aServerlistIp));
 488         m_pFirstReqServer = 0;
 489         m_pLastReqServer = 0;
 490         m_NumRequests = 0;
 491
 492         // next token
 493         m_CurrentToken = (m_CurrentToken+1)&0xff;
 494
 495         //
 496         m_ServerlistType = Type;
 497
 498         if(Type == IServerBrowser::TYPE_LAN)
 499         {
 500                 unsigned char Buffer[sizeof(SERVERBROWSE_GETINFO)+1];
 501                 CNetChunk Packet;
 502                 int i;
 503
 504                 mem_copy(Buffer, SERVERBROWSE_GETINFO, sizeof(SERVERBROWSE_GETINFO));
 505                 Buffer[sizeof(SERVERBROWSE_GETINFO)] = m_CurrentToken;
 506
 507                 /* do the broadcast version */
 508                 Packet.m_ClientID = -1;
 509                 mem_zero(&Packet, sizeof(Packet));
 510                 Packet.m_Address.type = NETTYPE_ALL|NETTYPE_LINK_BROADCAST;
 511                 Packet.m_Flags = NETSENDFLAG_CONNLESS;
 512                 Packet.m_DataSize = sizeof(Buffer);
 513                 Packet.m_pData = Buffer;
 514                 m_BroadcastTime = time_get();
 515
 516                 for(i = 8303; i <= 8310; i++)
 517                 {
 518                         Packet.m_Address.port = i;
 519                         m_pNetClient->Send(&Packet);
 520                 }
 521
 522                 if(g_Config.m_Debug)
 523                         m_pConsole->Print(IConsole::OUTPUT_LEVEL_DEBUG, "client_srvbrowse", "broadcasting for servers");
 524         }
 525         else if(Type == IServerBrowser::TYPE_INTERNET)
 526                 m_NeedRefresh = 1;
 527         else if(Type == IServerBrowser::TYPE_FAVORITES)
 528         {
 529                 for(int i = 0; i < m_NumFavoriteServers; i++)
 530                         Set(m_aFavoriteServers[i], IServerBrowser::SET_FAV_ADD, -1, 0);
 531         }
 532 }
 533
 534 void CServerBrowser::RequestImpl(const NETADDR &Addr, CServerEntry *pEntry) const
 535 {
 536         unsigned char Buffer[sizeof(SERVERBROWSE_GETINFO)+1];
 537         CNetChunk Packet;
 538
 539         if(g_Config.m_Debug)
 540         {
 541                 char aAddrStr[NETADDR_MAXSTRSIZE];
 542                 net_addr_str(&Addr, aAddrStr, sizeof(aAddrStr));
 543                 char aBuf[256];
 544                 str_format(aBuf, sizeof(aBuf),"requesting server info from %s", aAddrStr);
 545                 m_pConsole->Print(IConsole::OUTPUT_LEVEL_DEBUG, "client_srvbrowse", aBuf);
 546         }
 547
 548         mem_copy(Buffer, SERVERBROWSE_GETINFO, sizeof(SERVERBROWSE_GETINFO));
 549         Buffer[sizeof(SERVERBROWSE_GETINFO)] = m_CurrentToken;
 550
 551         Packet.m_ClientID = -1;
 552         Packet.m_Address = Addr;
 553         Packet.m_Flags = NETSENDFLAG_CONNLESS;
 554         Packet.m_DataSize = sizeof(Buffer);
 555         Packet.m_pData = Buffer;
 556
 557         m_pNetClient->Send(&Packet);
 558
 559         if(pEntry)
 560                 pEntry->m_RequestTime = time_get();
 561 }
 562
 563 void CServerBrowser::Request(const NETADDR &Addr) const
 564 {
 565         RequestImpl(Addr, 0);
 566 }
 567
 568
 569 void CServerBrowser::Update(bool ForceResort)
 570 {
 571         int64 Timeout = time_freq();
 572         int64 Now = time_get();
 573         int Count;
 574         CServerEntry *pEntry, *pNext;
 575
 576         // do server list requests
 577         if(m_NeedRefresh && !m_pMasterServer->IsRefreshing())
 578         {
 579                 NETADDR Addr;
 580                 CNetChunk Packet;
 581                 int i;
 582
 583                 m_NeedRefresh = 0;
 584
 585                 mem_zero(&Packet, sizeof(Packet));
 586                 Packet.m_ClientID = -1;
 587                 Packet.m_Flags = NETSENDFLAG_CONNLESS;
 588                 Packet.m_DataSize = sizeof(SERVERBROWSE_GETLIST);
 589                 Packet.m_pData = SERVERBROWSE_GETLIST;
 590
 591                 for(i = 0; i < IMasterServer::MAX_MASTERSERVERS; i++)
 592                 {
 593                         if(!m_pMasterServer->IsValid(i))
 594                                 continue;
 595
 596                         Addr = m_pMasterServer->GetAddr(i);
 597                         Packet.m_Address = Addr;
 598                         m_pNetClient->Send(&Packet);
 599                 }
 600
 601                 if(g_Config.m_Debug)
 602                         m_pConsole->Print(IConsole::OUTPUT_LEVEL_DEBUG, "client_srvbrowse", "requesting server list");
 603         }
 604
 605         // do timeouts
 606         pEntry = m_pFirstReqServer;
 607         while(1)
 608         {
 609                 if(!pEntry) // no more entries
 610                         break;
 611
 612                 pNext = pEntry->m_pNextReq;
 613
 614                 if(pEntry->m_RequestTime && pEntry->m_RequestTime+Timeout < Now)
 615                 {
 616                         // timeout
 617                         RemoveRequest(pEntry);
 618                 }
 619
 620                 pEntry = pNext;
 621         }
 622
 623         // do timeouts
 624         pEntry = m_pFirstReqServer;
 625         Count = 0;
 626         while(1)
 627         {
 628                 if(!pEntry) // no more entries
 629                         break;
 630
 631                 // no more then 10 concurrent requests
 632                 if(Count == g_Config.m_BrMaxRequests)
 633                         break;
 634
 635                 if(pEntry->m_RequestTime == 0)
 636                         RequestImpl(pEntry->m_Addr, pEntry);
 637
 638                 Count++;
 639                 pEntry = pEntry->m_pNextReq;
 640         }
 641
 642         // check if we need to resort
 643         if(m_Sorthash != SortHash() || ForceResort)
 644                 Sort();
 645 }
 646
 647
 648 bool CServerBrowser::IsFavorite(const NETADDR &Addr) const
 649 {
 650         // search for the address
 651         int i;
 652         for(i = 0; i < m_NumFavoriteServers; i++)
 653         {
 654                 if(net_addr_comp(&Addr, &m_aFavoriteServers[i]) == 0)
 655                         return true;
 656         }
 657         return false;
 658 }
 659
 660 void CServerBrowser::AddFavorite(const NETADDR &Addr)
 661 {
 662         CServerEntry *pEntry;
 663
 664         if(m_NumFavoriteServers == MAX_FAVORITES)
 665                 return;
 666
 667         // make sure that we don't already have the server in our list
 668         for(int i = 0; i < m_NumFavoriteServers; i++)
 669         {
 670                 if(net_addr_comp(&Addr, &m_aFavoriteServers[i]) == 0)
 671                         return;
 672         }
 673
 674         // add the server to the list
 675         m_aFavoriteServers[m_NumFavoriteServers++] = Addr;
 676         pEntry = Find(Addr);
 677         if(pEntry)
 678                 pEntry->m_Info.m_Favorite = 1;
 679
 680         if(g_Config.m_Debug)
 681         {
 682                 char aAddrStr[NETADDR_MAXSTRSIZE];
 683                 net_addr_str(&Addr, aAddrStr, sizeof(aAddrStr));
 684                 char aBuf[256];
 685                 str_format(aBuf, sizeof(aBuf), "added fav, %s", aAddrStr);
 686                 m_pConsole->Print(IConsole::OUTPUT_LEVEL_DEBUG, "client_srvbrowse", aBuf);
 687         }
 688 }
 689
 690 void CServerBrowser::RemoveFavorite(const NETADDR &Addr)
 691 {
 692         int i;
 693         CServerEntry *pEntry;
 694
 695         for(i = 0; i < m_NumFavoriteServers; i++)
 696         {
 697                 if(net_addr_comp(&Addr, &m_aFavoriteServers[i]) == 0)
 698                 {
 699                         mem_move(&m_aFavoriteServers[i], &m_aFavoriteServers[i+1], sizeof(NETADDR)*(m_NumFavoriteServers-(i+1)));
 700                         m_NumFavoriteServers--;
 701
 702                         pEntry = Find(Addr);
 703                         if(pEntry)
 704                                 pEntry->m_Info.m_Favorite = 0;
 705
 706                         return;
 707                 }
 708         }
 709 }
 710
 711 bool CServerBrowser::IsRefreshing() const
 712 {
 713         return m_pFirstReqServer != 0;
 714 }
 715
 716 bool CServerBrowser::IsRefreshingMasters() const
 717 {
 718         return m_pMasterServer->IsRefreshing();
 719 }
 720
 721
 722 int CServerBrowser::LoadingProgression() const
 723 {
 724         if(m_NumServers == 0)
 725                 return 0;
 726
 727         int Servers = m_NumServers;
 728         int Loaded = m_NumServers-m_NumRequests;
 729         return 100.0f * Loaded/Servers;
 730 }
 731
 732
 733 void CServerBrowser::ConfigSaveCallback(IConfig *pConfig, void *pUserData)
 734 {
 735         CServerBrowser *pSelf = (CServerBrowser *)pUserData;
 736
 737         int i;
 738         char aAddrStr[128];
 739         char aBuffer[256];
 740         for(i = 0; i < pSelf->m_NumFavoriteServers; i++)
 741         {
 742                 net_addr_str(&pSelf->m_aFavoriteServers[i], aAddrStr, sizeof(aAddrStr));
 743                 str_format(aBuffer, sizeof(aBuffer), "add_favorite %s", aAddrStr);
 744                 pConfig->WriteLine(aBuffer);
 745         }
 746 }