src/script/script_scanner.cpp

   1 /* $Id: script_scanner.cpp 25546 2013-06-30 20:40:49Z rubidium $ */
   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 /** @file script_scanner.cpp Allows scanning for scripts. */
  11
  12 #include "../stdafx.h"
  13 #include "../debug.h"
  14 #include "../string_func.h"
  15 #include "../settings_type.h"
  16
  17 #include "../script/squirrel.hpp"
  18 #include "script_scanner.hpp"
  19 #include "script_info.hpp"
  20
  21 #if defined(ENABLE_NETWORK)
  22 #include "../network/network_content.h"
  23 #include "../3rdparty/md5/md5.h"
  24 #include "../tar_type.h"
  25 #endif /* ENABLE_NETWORK */
  26
  27 #include "../safeguards.h"
  28
  29 bool ScriptScanner::AddFile(const char *filename, size_t basepath_length, const char *tar_filename)
  30 {
  31         free(this->main_script);
  32         this->main_script = stredup(filename);
  33         if (this->main_script == NULL) return false;
  34
  35         free(this->tar_file);
  36         if (tar_filename != NULL) {
  37                 this->tar_file = stredup(tar_filename);
  38                 if (this->tar_file == NULL) return false;
  39         } else {
  40                 this->tar_file = NULL;
  41         }
  42
  43         const char *end = this->main_script + strlen(this->main_script) + 1;
  44         char *p = strrchr(this->main_script, PATHSEPCHAR);
  45         if (p == NULL) {
  46                 p = this->main_script;
  47         } else {
  48                 /* Skip over the path separator character. We don't need that. */
  49                 p++;
  50         }
  51
  52         strecpy(p, "main.nut", end);
  53
  54         if (!FioCheckFileExists(filename, this->subdir) || !FioCheckFileExists(this->main_script, this->subdir)) return false;
  55
  56         this->ResetEngine();
  57         this->engine->LoadScript(filename);
  58
  59         return true;
  60 }
  61
  62 ScriptScanner::ScriptScanner() :
  63         engine(NULL),
  64         main_script(NULL),
  65         tar_file(NULL)
  66 {
  67 }
  68
  69 void ScriptScanner::ResetEngine()
  70 {
  71         this->engine->Reset();
  72         this->engine->SetGlobalPointer(this);
  73         this->RegisterAPI(this->engine);
  74 }
  75
  76 void ScriptScanner::Initialize(const char *name)
  77 {
  78         this->engine = new Squirrel(name);
  79
  80         this->RescanDir();
  81
  82         this->ResetEngine();
  83 }
  84
  85 ScriptScanner::~ScriptScanner()
  86 {
  87         this->Reset();
  88
  89         free(this->main_script);
  90         free(this->tar_file);
  91         delete this->engine;
  92 }
  93
  94 void ScriptScanner::RescanDir()
  95 {
  96         /* Forget about older scans */
  97         this->Reset();
  98
  99         /* Scan for scripts */
 100         this->Scan(this->GetFileName(), this->GetDirectory());
 101 }
 102
 103 void ScriptScanner::Reset()
 104 {
 105         ScriptInfoList::iterator it = this->info_list.begin();
 106         for (; it != this->info_list.end(); it++) {
 107                 free((*it).first);
 108                 delete (*it).second;
 109         }
 110         it = this->info_single_list.begin();
 111         for (; it != this->info_single_list.end(); it++) {
 112                 free((*it).first);
 113         }
 114
 115         this->info_list.clear();
 116         this->info_single_list.clear();
 117 }
 118
 119 void ScriptScanner::RegisterScript(ScriptInfo *info)
 120 {
 121         char script_original_name[1024];
 122         this->GetScriptName(info, script_original_name, lastof(script_original_name));
 123         strtolower(script_original_name);
 124
 125         char script_name[1024];
 126         seprintf(script_name, lastof(script_name), "%s.%d", script_original_name, info->GetVersion());
 127
 128         /* Check if GetShortName follows the rules */
 129         if (strlen(info->GetShortName()) != 4) {
 130                 DEBUG(script, 0, "The script '%s' returned a string from GetShortName() which is not four characaters. Unable to load the script.", info->GetName());
 131                 delete info;
 132                 return;
 133         }
 134
 135         if (this->info_list.find(script_name) != this->info_list.end()) {
 136                 /* This script was already registered */
 137 #ifdef WIN32
 138                 /* Windows doesn't care about the case */
 139                 if (strcasecmp(this->info_list[script_name]->GetMainScript(), info->GetMainScript()) == 0) {
 140 #else
 141                 if (strcmp(this->info_list[script_name]->GetMainScript(), info->GetMainScript()) == 0) {
 142 #endif
 143                         delete info;
 144                         return;
 145                 }
 146
 147                 DEBUG(script, 1, "Registering two scripts with the same name and version");
 148                 DEBUG(script, 1, "  1: %s", this->info_list[script_name]->GetMainScript());
 149                 DEBUG(script, 1, "  2: %s", info->GetMainScript());
 150                 DEBUG(script, 1, "The first is taking precedence.");
 151
 152                 delete info;
 153                 return;
 154         }
 155
 156         this->info_list[stredup(script_name)] = info;
 157
 158         if (!info->IsDeveloperOnly() || _settings_client.gui.ai_developer_tools) {
 159                 /* Add the script to the 'unique' script list, where only the highest version
 160                  *  of the script is registered. */
 161                 if (this->info_single_list.find(script_original_name) == this->info_single_list.end()) {
 162                         this->info_single_list[stredup(script_original_name)] = info;
 163                 } else if (this->info_single_list[script_original_name]->GetVersion() < info->GetVersion()) {
 164                         this->info_single_list[script_original_name] = info;
 165                 }
 166         }
 167 }
 168
 169 char *ScriptScanner::GetConsoleList(char *p, const char *last, bool newest_only) const
 170 {
 171         p += seprintf(p, last, "List of %s:\n", this->GetScannerName());
 172         const ScriptInfoList &list = newest_only ? this->info_single_list : this->info_list;
 173         ScriptInfoList::const_iterator it = list.begin();
 174         for (; it != list.end(); it++) {
 175                 ScriptInfo *i = (*it).second;
 176                 p += seprintf(p, last, "%10s (v%d): %s\n", i->GetName(), i->GetVersion(), i->GetDescription());
 177         }
 178         p += seprintf(p, last, "\n");
 179
 180         return p;
 181 }
 182
 183 #if defined(ENABLE_NETWORK)
 184
 185 /** Helper for creating a MD5sum of all files within of a script. */
 186 struct ScriptFileChecksumCreator : FileScanner {
 187         byte md5sum[16];  ///< The final md5sum.
 188         Subdirectory dir; ///< The directory to look in.
 189
 190         /**
 191          * Initialise the md5sum to be all zeroes,
 192          * so we can easily xor the data.
 193          */
 194         ScriptFileChecksumCreator(Subdirectory dir)
 195         {
 196                 this->dir = dir;
 197                 memset(this->md5sum, 0, sizeof(this->md5sum));
 198         }
 199
 200         /* Add the file and calculate the md5 sum. */
 201         virtual bool AddFile(const char *filename, size_t basepath_length, const char *tar_filename)
 202         {
 203                 Md5 checksum;
 204                 uint8 buffer[1024];
 205                 size_t len, size;
 206                 byte tmp_md5sum[16];
 207
 208                 /* Open the file ... */
 209                 FILE *f = FioFOpenFile(filename, "rb", this->dir, &size);
 210                 if (f == NULL) return false;
 211
 212                 /* ... calculate md5sum... */
 213                 while ((len = fread(buffer, 1, (size > sizeof(buffer)) ? sizeof(buffer) : size, f)) != 0 && size != 0) {
 214                         size -= len;
 215                         checksum.Append(buffer, len);
 216                 }
 217                 checksum.Finish(tmp_md5sum);
 218
 219                 FioFCloseFile(f);
 220
 221                 /* ... and xor it to the overall md5sum. */
 222                 for (uint i = 0; i < sizeof(md5sum); i++) this->md5sum[i] ^= tmp_md5sum[i];
 223
 224                 return true;
 225         }
 226 };
 227
 228 /**
 229  * Check whether the script given in info is the same as in ci based
 230  * on the shortname and md5 sum.
 231  * @param ci The information to compare to.
 232  * @param md5sum Whether to check the MD5 checksum.
 233  * @param info The script to get the shortname and md5 sum from.
 234  * @return True iff they're the same.
 235  */
 236 static bool IsSameScript(const ContentInfo *ci, bool md5sum, ScriptInfo *info, Subdirectory dir)
 237 {
 238         uint32 id = 0;
 239         const char *str = info->GetShortName();
 240         for (int j = 0; j < 4 && *str != '\0'; j++, str++) id |= *str << (8 * j);
 241
 242         if (id != ci->unique_id) return false;
 243         if (!md5sum) return true;
 244
 245         ScriptFileChecksumCreator checksum(dir);
 246         const char *tar_filename = info->GetTarFile();
 247         TarList::iterator iter;
 248         if (tar_filename != NULL && (iter = _tar_list[dir].find(tar_filename)) != _tar_list[dir].end()) {
 249                 /* The main script is in a tar file, so find all files that
 250                  * are in the same tar and add them to the MD5 checksumming. */
 251                 TarFileList::iterator tar;
 252                 FOR_ALL_TARS(tar, dir) {
 253                         /* Not in the same tar. */
 254                         if (tar->second.tar_filename != iter->first) continue;
 255
 256                         /* Check the extension. */
 257                         const char *ext = strrchr(tar->first.c_str(), '.');
 258                         if (ext == NULL || strcasecmp(ext, ".nut") != 0) continue;
 259
 260                         checksum.AddFile(tar->first.c_str(), 0, tar_filename);
 261                 }
 262         } else {
 263                 char path[MAX_PATH];
 264                 strecpy(path, info->GetMainScript(), lastof(path));
 265                 /* There'll always be at least 1 path separator character in a script
 266                  * main script name as the search algorithm requires the main script to
 267                  * be in a subdirectory of the script directory; so <dir>/<path>/main.nut. */
 268                 *strrchr(path, PATHSEPCHAR) = '\0';
 269                 checksum.Scan(".nut", path);
 270         }
 271
 272         return memcmp(ci->md5sum, checksum.md5sum, sizeof(ci->md5sum)) == 0;
 273 }
 274
 275 bool ScriptScanner::HasScript(const ContentInfo *ci, bool md5sum)
 276 {
 277         for (ScriptInfoList::iterator it = this->info_list.begin(); it != this->info_list.end(); it++) {
 278                 if (IsSameScript(ci, md5sum, (*it).second, this->GetDirectory())) return true;
 279         }
 280         return false;
 281 }
 282
 283 const char *ScriptScanner::FindMainScript(const ContentInfo *ci, bool md5sum)
 284 {
 285         for (ScriptInfoList::iterator it = this->info_list.begin(); it != this->info_list.end(); it++) {
 286                 if (IsSameScript(ci, md5sum, (*it).second, this->GetDirectory())) return (*it).second->GetMainScript();
 287         }
 288         return NULL;
 289 }
 290
 291 #endif /* ENABLE_NETWORK */