src/mods.cpp

   1 /*
   2 Minetest
   3 Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU Lesser General Public License as published by
   7 the Free Software Foundation; either version 2.1 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU Lesser General Public License for more details.
  14
  15 You should have received a copy of the GNU Lesser General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include <cctype>
  21 #include <fstream>
  22 #include "mods.h"
  23 #include "filesys.h"
  24 #include "log.h"
  25 #include "subgame.h"
  26 #include "settings.h"
  27 #include "convert_json.h"
  28 #include "exceptions.h"
  29 #include "porting.h"
  30
  31 static bool parseDependsLine(std::istream &is,
  32                 std::string &dep, std::set<char> &symbols)
  33 {
  34         std::getline(is, dep);
  35         dep = trim(dep);
  36         symbols.clear();
  37         size_t pos = dep.size();
  38         while(pos > 0 && !string_allowed(dep.substr(pos-1, 1), MODNAME_ALLOWED_CHARS)){
  39                 // last character is a symbol, not part of the modname
  40                 symbols.insert(dep[pos-1]);
  41                 --pos;
  42         }
  43         dep = trim(dep.substr(0, pos));
  44         return dep != "";
  45 }
  46
  47 void parseModContents(ModSpec &spec)
  48 {
  49         // NOTE: this function works in mutual recursion with getModsInPath
  50         Settings info;
  51         info.readConfigFile((spec.path+DIR_DELIM+"mod.conf").c_str());
  52
  53         if (info.exists("name"))
  54                 spec.name = info.get("name");
  55
  56         spec.depends.clear();
  57         spec.optdepends.clear();
  58         spec.is_modpack = false;
  59         spec.modpack_content.clear();
  60
  61         // Handle modpacks (defined by containing modpack.txt)
  62         std::ifstream modpack_is((spec.path+DIR_DELIM+"modpack.txt").c_str());
  63         if(modpack_is.good()){ //a modpack, recursively get the mods in it
  64                 modpack_is.close(); // We don't actually need the file
  65                 spec.is_modpack = true;
  66                 spec.modpack_content = getModsInPath(spec.path, true);
  67
  68                 // modpacks have no dependencies; they are defined and
  69                 // tracked separately for each mod in the modpack
  70         }
  71         else{ // not a modpack, parse the dependencies
  72                 std::ifstream is((spec.path+DIR_DELIM+"depends.txt").c_str());
  73                 while(is.good()){
  74                         std::string dep;
  75                         std::set<char> symbols;
  76                         if(parseDependsLine(is, dep, symbols)){
  77                                 if(symbols.count('?') != 0){
  78                                         spec.optdepends.insert(dep);
  79                                 }
  80                                 else{
  81                                         spec.depends.insert(dep);
  82                                 }
  83                         }
  84                 }
  85         }
  86 }
  87
  88 std::map<std::string, ModSpec> getModsInPath(std::string path, bool part_of_modpack)
  89 {
  90         // NOTE: this function works in mutual recursion with parseModContents
  91
  92         std::map<std::string, ModSpec> result;
  93         std::vector<fs::DirListNode> dirlist = fs::GetDirListing(path);
  94         for(u32 j=0; j<dirlist.size(); j++){
  95                 if(!dirlist[j].dir)
  96                         continue;
  97                 std::string modname = dirlist[j].name;
  98                 // Ignore all directories beginning with a ".", especially
  99                 // VCS directories like ".git" or ".svn"
 100                 if(modname[0] == '.')
 101                         continue;
 102                 std::string modpath = path + DIR_DELIM + modname;
 103
 104                 ModSpec spec(modname, modpath);
 105                 spec.part_of_modpack = part_of_modpack;
 106                 parseModContents(spec);
 107                 result.insert(std::make_pair(modname, spec));
 108         }
 109         return result;
 110 }
 111
 112 std::vector<ModSpec> flattenMods(std::map<std::string, ModSpec> mods)
 113 {
 114         std::vector<ModSpec> result;
 115         for(std::map<std::string,ModSpec>::iterator it = mods.begin();
 116                 it != mods.end(); ++it)
 117         {
 118                 ModSpec mod = (*it).second;
 119                 if(mod.is_modpack)
 120                 {
 121                         std::vector<ModSpec> content = flattenMods(mod.modpack_content);
 122                         result.reserve(result.size() + content.size());
 123                         result.insert(result.end(),content.begin(),content.end());
 124
 125                 }
 126                 else //not a modpack
 127                 {
 128                         result.push_back(mod);
 129                 }
 130         }
 131         return result;
 132 }
 133
 134 ModConfiguration::ModConfiguration(const std::string &worldpath):
 135         m_unsatisfied_mods(),
 136         m_sorted_mods(),
 137         m_name_conflicts()
 138 {
 139 }
 140
 141 void ModConfiguration::printUnsatisfiedModsError() const
 142 {
 143         for (std::vector<ModSpec>::const_iterator it = m_unsatisfied_mods.begin();
 144                 it != m_unsatisfied_mods.end(); ++it) {
 145                 ModSpec mod = *it;
 146                 errorstream << "mod \"" << mod.name << "\" has unsatisfied dependencies: ";
 147                 for (UNORDERED_SET<std::string>::iterator dep_it = mod.unsatisfied_depends.begin();
 148                         dep_it != mod.unsatisfied_depends.end(); ++dep_it)
 149                         errorstream << " \"" << *dep_it << "\"";
 150                 errorstream << std::endl;
 151         }
 152 }
 153
 154 void ModConfiguration::addModsInPath(const std::string &path)
 155 {
 156         addMods(flattenMods(getModsInPath(path)));
 157 }
 158
 159 void ModConfiguration::addMods(const std::vector<ModSpec> &new_mods)
 160 {
 161         // Maintain a map of all existing m_unsatisfied_mods.
 162         // Keys are mod names and values are indices into m_unsatisfied_mods.
 163         std::map<std::string, u32> existing_mods;
 164         for(u32 i = 0; i < m_unsatisfied_mods.size(); ++i){
 165                 existing_mods[m_unsatisfied_mods[i].name] = i;
 166         }
 167
 168         // Add new mods
 169         for(int want_from_modpack = 1; want_from_modpack >= 0; --want_from_modpack){
 170                 // First iteration:
 171                 // Add all the mods that come from modpacks
 172                 // Second iteration:
 173                 // Add all the mods that didn't come from modpacks
 174
 175                 std::set<std::string> seen_this_iteration;
 176
 177                 for (std::vector<ModSpec>::const_iterator it = new_mods.begin();
 178                                 it != new_mods.end(); ++it) {
 179                         const ModSpec &mod = *it;
 180                         if(mod.part_of_modpack != (bool)want_from_modpack)
 181                                 continue;
 182                         if(existing_mods.count(mod.name) == 0){
 183                                 // GOOD CASE: completely new mod.
 184                                 m_unsatisfied_mods.push_back(mod);
 185                                 existing_mods[mod.name] = m_unsatisfied_mods.size() - 1;
 186                         }
 187                         else if(seen_this_iteration.count(mod.name) == 0){
 188                                 // BAD CASE: name conflict in different levels.
 189                                 u32 oldindex = existing_mods[mod.name];
 190                                 const ModSpec &oldmod = m_unsatisfied_mods[oldindex];
 191                                 warningstream<<"Mod name conflict detected: \""
 192                                         <<mod.name<<"\""<<std::endl
 193                                         <<"Will not load: "<<oldmod.path<<std::endl
 194                                         <<"Overridden by: "<<mod.path<<std::endl;
 195                                 m_unsatisfied_mods[oldindex] = mod;
 196
 197                                 // If there was a "VERY BAD CASE" name conflict
 198                                 // in an earlier level, ignore it.
 199                                 m_name_conflicts.erase(mod.name);
 200                         }
 201                         else{
 202                                 // VERY BAD CASE: name conflict in the same level.
 203                                 u32 oldindex = existing_mods[mod.name];
 204                                 const ModSpec &oldmod = m_unsatisfied_mods[oldindex];
 205                                 warningstream<<"Mod name conflict detected: \""
 206                                         <<mod.name<<"\""<<std::endl
 207                                         <<"Will not load: "<<oldmod.path<<std::endl
 208                                         <<"Will not load: "<<mod.path<<std::endl;
 209                                 m_unsatisfied_mods[oldindex] = mod;
 210                                 m_name_conflicts.insert(mod.name);
 211                         }
 212                         seen_this_iteration.insert(mod.name);
 213                 }
 214         }
 215 }
 216
 217 void ModConfiguration::checkConflictsAndDeps()
 218 {
 219         // report on name conflicts
 220         if (!m_name_conflicts.empty()) {
 221                 std::string s = "Unresolved name conflicts for mods ";
 222                 for (UNORDERED_SET<std::string>::const_iterator it = m_name_conflicts.begin();
 223                         it != m_name_conflicts.end(); ++it) {
 224                         if (it != m_name_conflicts.begin()) s += ", ";
 225                         s += std::string("\"") + (*it) + "\"";
 226                 }
 227                 s += ".";
 228                 throw ModError(s);
 229         }
 230
 231         // get the mods in order
 232         resolveDependencies();
 233 }
 234
 235 void ModConfiguration::resolveDependencies()
 236 {
 237         // Step 1: Compile a list of the mod names we're working with
 238         std::set<std::string> modnames;
 239         for(std::vector<ModSpec>::iterator it = m_unsatisfied_mods.begin();
 240                 it != m_unsatisfied_mods.end(); ++it){
 241                 modnames.insert((*it).name);
 242         }
 243
 244         // Step 2: get dependencies (including optional dependencies)
 245         // of each mod, split mods into satisfied and unsatisfied
 246         std::list<ModSpec> satisfied;
 247         std::list<ModSpec> unsatisfied;
 248         for (std::vector<ModSpec>::iterator it = m_unsatisfied_mods.begin();
 249                         it != m_unsatisfied_mods.end(); ++it) {
 250                 ModSpec mod = *it;
 251                 mod.unsatisfied_depends = mod.depends;
 252                 // check which optional dependencies actually exist
 253                 for (UNORDERED_SET<std::string>::iterator it_optdep = mod.optdepends.begin();
 254                                 it_optdep != mod.optdepends.end(); ++it_optdep) {
 255                         std::string optdep = *it_optdep;
 256                         if (modnames.count(optdep) != 0)
 257                                 mod.unsatisfied_depends.insert(optdep);
 258                 }
 259                 // if a mod has no depends it is initially satisfied
 260                 if (mod.unsatisfied_depends.empty())
 261                         satisfied.push_back(mod);
 262                 else
 263                         unsatisfied.push_back(mod);
 264         }
 265
 266         // Step 3: mods without unmet dependencies can be appended to
 267         // the sorted list.
 268         while(!satisfied.empty()){
 269                 ModSpec mod = satisfied.back();
 270                 m_sorted_mods.push_back(mod);
 271                 satisfied.pop_back();
 272                 for(std::list<ModSpec>::iterator it = unsatisfied.begin();
 273                                 it != unsatisfied.end(); ){
 274                         ModSpec& mod2 = *it;
 275                         mod2.unsatisfied_depends.erase(mod.name);
 276                         if(mod2.unsatisfied_depends.empty()){
 277                                 satisfied.push_back(mod2);
 278                                 it = unsatisfied.erase(it);
 279                         }
 280                         else{
 281                                 ++it;
 282                         }
 283                 }
 284         }
 285
 286         // Step 4: write back list of unsatisfied mods
 287         m_unsatisfied_mods.assign(unsatisfied.begin(), unsatisfied.end());
 288 }
 289
 290 ServerModConfiguration::ServerModConfiguration(const std::string &worldpath):
 291         ModConfiguration(worldpath)
 292 {
 293         SubgameSpec gamespec = findWorldSubgame(worldpath);
 294
 295         // Add all game mods and all world mods
 296         addModsInPath(gamespec.gamemods_path);
 297         addModsInPath(worldpath + DIR_DELIM + "worldmods");
 298
 299         // check world.mt file for mods explicitely declared to be
 300         // loaded or not by a load_mod_<modname> = ... line.
 301         std::string worldmt = worldpath+DIR_DELIM+"world.mt";
 302         Settings worldmt_settings;
 303         worldmt_settings.readConfigFile(worldmt.c_str());
 304         std::vector<std::string> names = worldmt_settings.getNames();
 305         std::set<std::string> include_mod_names;
 306         for (std::vector<std::string>::const_iterator it = names.begin();
 307                 it != names.end(); ++it) {
 308                 std::string name = *it;
 309                 // for backwards compatibility: exclude only mods which are
 310                 // explicitely excluded. if mod is not mentioned at all, it is
 311                 // enabled. So by default, all installed mods are enabled.
 312                 if (name.compare(0,9,"load_mod_") == 0 &&
 313                         worldmt_settings.getBool(name)) {
 314                         include_mod_names.insert(name.substr(9));
 315                 }
 316         }
 317
 318         // Collect all mods that are also in include_mod_names
 319         std::vector<ModSpec> addon_mods;
 320         for (std::set<std::string>::const_iterator it_path = gamespec.addon_mods_paths.begin();
 321                 it_path != gamespec.addon_mods_paths.end(); ++it_path) {
 322                 std::vector<ModSpec> addon_mods_in_path = flattenMods(getModsInPath(*it_path));
 323                 for (std::vector<ModSpec>::const_iterator it = addon_mods_in_path.begin();
 324                         it != addon_mods_in_path.end(); ++it) {
 325                         const ModSpec& mod = *it;
 326                         if (include_mod_names.count(mod.name) != 0)
 327                                 addon_mods.push_back(mod);
 328                         else
 329                                 worldmt_settings.setBool("load_mod_" + mod.name, false);
 330                 }
 331         }
 332         worldmt_settings.updateConfigFile(worldmt.c_str());
 333
 334         addMods(addon_mods);
 335
 336         checkConflictsAndDeps();
 337 }
 338
 339 #ifndef SERVER
 340 ClientModConfiguration::ClientModConfiguration(const std::string &path):
 341         ModConfiguration(path)
 342 {
 343         addModsInPath(path);
 344         addModsInPath(porting::path_user + DIR_DELIM + "clientmods");
 345         checkConflictsAndDeps();
 346 }
 347 #endif
 348
 349 #if USE_CURL
 350 Json::Value getModstoreUrl(std::string url)
 351 {
 352         std::vector<std::string> extra_headers;
 353
 354         bool special_http_header = true;
 355
 356         try {
 357                 special_http_header = g_settings->getBool("modstore_disable_special_http_header");
 358         } catch (SettingNotFoundException) {}
 359
 360         if (special_http_header) {
 361                 extra_headers.push_back("Accept: application/vnd.minetest.mmdb-v1+json");
 362         }
 363         return fetchJsonValue(url, special_http_header ? &extra_headers : NULL);
 364 }
 365
 366 #endif
 367
 368 ModMetadata::ModMetadata(const std::string &mod_name):
 369         m_mod_name(mod_name),
 370         m_modified(false)
 371 {
 372         m_stringvars.clear();
 373 }
 374
 375 void ModMetadata::clear()
 376 {
 377         Metadata::clear();
 378         m_modified = true;
 379 }
 380
 381 bool ModMetadata::save(const std::string &root_path)
 382 {
 383         Json::Value json;
 384         for (StringMap::const_iterator it = m_stringvars.begin();
 385                         it != m_stringvars.end(); ++it) {
 386                 json[it->first] = it->second;
 387         }
 388
 389         if (!fs::PathExists(root_path)) {
 390                 if (!fs::CreateAllDirs(root_path)) {
 391                         errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
 392                                 << root_path << "' tree cannot be created." << std::endl;
 393                         return false;
 394                 }
 395         } else if (!fs::IsDir(root_path)) {
 396                 errorstream << "ModMetadata[" << m_mod_name << "]: Unable to save. '"
 397                         << root_path << "' is not a directory." << std::endl;
 398                 return false;
 399         }
 400
 401         bool w_ok = fs::safeWriteToFile(root_path + DIR_DELIM + m_mod_name,
 402                 Json::FastWriter().write(json));
 403
 404         if (w_ok) {
 405                 m_modified = false;
 406         } else {
 407                 errorstream << "ModMetadata[" << m_mod_name << "]: failed write file." << std::endl;
 408         }
 409         return w_ok;
 410 }
 411
 412 bool ModMetadata::load(const std::string &root_path)
 413 {
 414         m_stringvars.clear();
 415
 416         std::ifstream is((root_path + DIR_DELIM + m_mod_name).c_str(), std::ios_base::binary);
 417         if (!is.good()) {
 418                 return false;
 419         }
 420
 421         Json::Reader reader;
 422         Json::Value root;
 423         if (!reader.parse(is, root)) {
 424                 errorstream << "ModMetadata[" << m_mod_name << "]: failed read data "
 425                         "(Json decoding failure)." << std::endl;
 426                 return false;
 427         }
 428
 429         const Json::Value::Members attr_list = root.getMemberNames();
 430         for (Json::Value::Members::const_iterator it = attr_list.begin();
 431                         it != attr_list.end(); ++it) {
 432                 Json::Value attr_value = root[*it];
 433                 m_stringvars[*it] = attr_value.asString();
 434         }
 435
 436         return true;
 437 }
 438
 439 bool ModMetadata::setString(const std::string &name, const std::string &var)
 440 {
 441         m_modified = Metadata::setString(name, var);
 442         return m_modified;
 443 }