src/network/network_gamelist.cpp

   1 /* $Id$ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD 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, version 2.
   6  * OpenTTD 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.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /**
  11  * @file network_gamelist.cpp This file handles the GameList
  12  * Also, it handles the request to a server for data about the server
  13  */
  14
  15 #ifdef ENABLE_NETWORK
  16
  17 #include "../stdafx.h"
  18 #include "../debug.h"
  19 #include "../window_func.h"
  20 #include "../thread/thread.h"
  21 #include "network_internal.h"
  22 #include "network_udp.h"
  23 #include "network_gamelist.h"
  24
  25 #include "../safeguards.h"
  26
  27 NetworkGameList *_network_game_list = NULL;
  28
  29 /** Mutex for handling delayed insertion/querying of servers. */
  30 static ThreadMutex *_network_game_list_mutex = ThreadMutex::New();
  31 /** The games to insert when the GUI thread has time for us. */
  32 static NetworkGameList *_network_game_delayed_insertion_list = NULL;
  33
  34 /**
  35  * Add a new item to the linked gamelist, but do it delayed in the next tick
  36  * or so to prevent race conditions.
  37  * @param item the item to add. Will be freed once added.
  38  */
  39 void NetworkGameListAddItemDelayed(NetworkGameList *item)
  40 {
  41         _network_game_list_mutex->BeginCritical();
  42         item->next = _network_game_delayed_insertion_list;
  43         _network_game_delayed_insertion_list = item;
  44         _network_game_list_mutex->EndCritical();
  45 }
  46
  47 /** Perform the delayed (thread safe) insertion into the game list */
  48 static void NetworkGameListHandleDelayedInsert()
  49 {
  50         _network_game_list_mutex->BeginCritical();
  51         while (_network_game_delayed_insertion_list != NULL) {
  52                 NetworkGameList *ins_item = _network_game_delayed_insertion_list;
  53                 _network_game_delayed_insertion_list = ins_item->next;
  54
  55                 NetworkGameList *item = NetworkGameListAddItem(ins_item->address);
  56
  57                 if (item != NULL) {
  58                         if (StrEmpty(item->info.server_name)) {
  59                                 ClearGRFConfigList(&item->info.grfconfig);
  60                                 memset(&item->info, 0, sizeof(item->info));
  61                                 strecpy(item->info.server_name, ins_item->info.server_name, lastof(item->info.server_name));
  62                                 strecpy(item->info.hostname, ins_item->info.hostname, lastof(item->info.hostname));
  63                                 item->online = false;
  64                         }
  65                         item->manually |= ins_item->manually;
  66                         if (item->manually) NetworkRebuildHostList();
  67                         UpdateNetworkGameWindow();
  68                 }
  69                 free(ins_item);
  70         }
  71         _network_game_list_mutex->EndCritical();
  72 }
  73
  74 /**
  75  * Add a new item to the linked gamelist. If the IP and Port match
  76  * return the existing item instead of adding it again
  77  * @param address the address of the to-be added item
  78  * @return a point to the newly added or already existing item
  79  */
  80 NetworkGameList *NetworkGameListAddItem(NetworkAddress address)
  81 {
  82         const char *hostname = address.GetHostname();
  83
  84         /* Do not query the 'any' address. */
  85         if (StrEmpty(hostname) ||
  86                         strcmp(hostname, "0.0.0.0") == 0 ||
  87                         strcmp(hostname, "::") == 0) {
  88                 return NULL;
  89         }
  90
  91         NetworkGameList *item, *prev_item;
  92
  93         prev_item = NULL;
  94         for (item = _network_game_list; item != NULL; item = item->next) {
  95                 if (item->address == address) return item;
  96                 prev_item = item;
  97         }
  98
  99         item = CallocT<NetworkGameList>(1);
 100         item->next = NULL;
 101         item->address = address;
 102
 103         if (prev_item == NULL) {
 104                 _network_game_list = item;
 105         } else {
 106                 prev_item->next = item;
 107         }
 108         DEBUG(net, 4, "[gamelist] added server to list");
 109
 110         UpdateNetworkGameWindow();
 111
 112         return item;
 113 }
 114
 115 /**
 116  * Remove an item from the gamelist linked list
 117  * @param remove pointer to the item to be removed
 118  */
 119 void NetworkGameListRemoveItem(NetworkGameList *remove)
 120 {
 121         NetworkGameList *prev_item = NULL;
 122         for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {
 123                 if (remove == item) {
 124                         if (prev_item == NULL) {
 125                                 _network_game_list = remove->next;
 126                         } else {
 127                                 prev_item->next = remove->next;
 128                         }
 129
 130                         /* Remove GRFConfig information */
 131                         ClearGRFConfigList(&remove->info.grfconfig);
 132                         free(remove);
 133                         remove = NULL;
 134
 135                         DEBUG(net, 4, "[gamelist] removed server from list");
 136                         NetworkRebuildHostList();
 137                         UpdateNetworkGameWindow();
 138                         return;
 139                 }
 140                 prev_item = item;
 141         }
 142 }
 143
 144 static const uint MAX_GAME_LIST_REQUERY_COUNT  = 10; ///< How often do we requery in number of times per server?
 145 static const uint REQUERY_EVERY_X_GAMELOOPS    = 60; ///< How often do we requery in time?
 146 static const uint REFRESH_GAMEINFO_X_REQUERIES = 50; ///< Refresh the game info itself after REFRESH_GAMEINFO_X_REQUERIES * REQUERY_EVERY_X_GAMELOOPS game loops
 147
 148 /** Requeries the (game) servers we have not gotten a reply from */
 149 void NetworkGameListRequery()
 150 {
 151         NetworkGameListHandleDelayedInsert();
 152
 153         static uint8 requery_cnt = 0;
 154
 155         if (++requery_cnt < REQUERY_EVERY_X_GAMELOOPS) return;
 156         requery_cnt = 0;
 157
 158         for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {
 159                 item->retries++;
 160                 if (item->retries < REFRESH_GAMEINFO_X_REQUERIES && (item->online || item->retries >= MAX_GAME_LIST_REQUERY_COUNT)) continue;
 161
 162                 /* item gets mostly zeroed by NetworkUDPQueryServer */
 163                 uint8 retries = item->retries;
 164                 NetworkUDPQueryServer(NetworkAddress(item->address));
 165                 item->retries = (retries >= REFRESH_GAMEINFO_X_REQUERIES) ? 0 : retries;
 166         }
 167 }
 168
 169 /**
 170  * Rebuild the GRFConfig's of the servers in the game list as we did
 171  * a rescan and might have found new NewGRFs.
 172  */
 173 void NetworkAfterNewGRFScan()
 174 {
 175         for (NetworkGameList *item = _network_game_list; item != NULL; item = item->next) {
 176                 /* Reset compatibility state */
 177                 item->info.compatible = item->info.version_compatible;
 178
 179                 for (GRFConfig *c = item->info.grfconfig; c != NULL; c = c->next) {
 180                         assert(HasBit(c->flags, GCF_COPY));
 181
 182                         const GRFConfig *f = FindGRFConfig(c->ident.grfid, FGCM_EXACT, c->ident.md5sum);
 183                         if (f == NULL) {
 184                                 /* Don't know the GRF, so mark game incompatible and the (possibly)
 185                                  * already resolved name for this GRF (another server has sent the
 186                                  * name of the GRF already. */
 187                                 c->name->Release();
 188                                 c->name = FindUnknownGRFName(c->ident.grfid, c->ident.md5sum, true);
 189                                 c->name->AddRef();
 190                                 c->status = GCS_NOT_FOUND;
 191
 192                                 /* If we miss a file, we're obviously incompatible. */
 193                                 item->info.compatible = false;
 194                         } else {
 195                                 c->filename = f->filename;
 196                                 c->name->Release();
 197                                 c->name = f->name;
 198                                 c->name->AddRef();
 199                                 c->info->Release();
 200                                 c->info = f->info;
 201                                 c->info->AddRef();
 202                                 c->status = GCS_UNKNOWN;
 203                         }
 204                 }
 205         }
 206
 207         InvalidateWindowClassesData(WC_NETWORK_WINDOW);
 208 }
 209
 210 #endif /* ENABLE_NETWORK */