AddonManager Class Reference

Checks for, installs and removes Add-ons. More...

#include <addon_manager.hpp>

List of all members.

Public Member Functions
std::vector< Addon * >	get_addons ()
	returns a list of installed Add-ons
void	check_online ()
	downloads list of available Add-ons
void	install (Addon *addon)
	Download and install Add-on.
void	remove (Addon *addon)
	Physically delete Add-on.
void	disable (Addon *addon)
	Unload Add-on and mark as not to be loaded automatically.
void	enable (Addon *addon)
	Load Add-on and mark as to be loaded automatically.
void	unload (Addon *addon)
	Remove Add-on from search path.
void	load (Addon *addon)
	Add Add-on to search path.
void	load_addons ()
	Loads all enabled Add-ons, i.e.
void	write (Writer &writer)
	Write AddonManager configuration to Lisp.
void	read (const Reader &lisp)
	Read AddonManager configuration from Lisp.
Static Public Member Functions
static AddonManager &	get_instance ()
	Returns the shared AddonManager instance.
Protected Member Functions
	AddonManager ()
	~AddonManager ()
Protected Attributes
std::vector< Addon * >	addons
std::vector< std::string >	ignored_addon_filenames

---

Detailed Description

Checks for, installs and removes Add-ons.

Definition at line 31 of file addon_manager.hpp.

---

Constructor & Destructor Documentation

AddonManager::AddonManager

(

)

[protected]

Definition at line 71 of file addon_manager.cpp.

                           :
  addons(),
  ignored_addon_filenames()
{
#ifdef HAVE_LIBCURL
  curl_global_init(CURL_GLOBAL_ALL);
#endif
}

AddonManager::~AddonManager

(

)

[protected]

Definition at line 80 of file addon_manager.cpp.

References addons.

{
#ifdef HAVE_LIBCURL
  curl_global_cleanup();
#endif

  for (std::vector<Addon*>::iterator i = addons.begin(); i != addons.end(); i++) delete *i;
}

---

Member Function Documentation

std::vector< Addon * > AddonManager::get_addons

(

)

returns a list of installed Add-ons

Definition at line 90 of file addon_manager.cpp.

References addons.

Referenced by AddonMenu::refresh().

{
  /*
    for (std::vector<Addon>::iterator it = installed_addons.begin(); it != installed_addons.end(); ++it) {
    Addon& addon = *it;
    if (addon.md5 == "") addon.md5 = calculate_md5(addon);
    }
  */
  return addons;
}

void AddonManager::check_online

(

)

downloads list of available Add-ons

Definition at line 102 of file addon_manager.cpp.

References addons, lisp::Lisp::get_lisp(), lisp::ListIterator::item(), lisp::ListIterator::lisp(), log_warning, lisp::ListIterator::next(), and lisp::Parser::parse().

Referenced by AddonMenu::check_menu().

{
#ifdef HAVE_LIBCURL
  char error_buffer[CURL_ERROR_SIZE+1];

  const char* baseUrl = "http://supertux.lethargik.org/addons/index.nfo";
  std::string addoninfos = "";

  CURL *curl_handle;
  curl_handle = curl_easy_init();
  curl_easy_setopt(curl_handle, CURLOPT_URL, baseUrl);
  curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "SuperTux/" PACKAGE_VERSION " libcURL");
  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, my_curl_string_append);
  curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, &addoninfos);
  curl_easy_setopt(curl_handle, CURLOPT_ERRORBUFFER, error_buffer);
  curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1);
  curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
  curl_easy_setopt(curl_handle, CURLOPT_FAILONERROR, 1);
  curl_easy_setopt(curl_handle, CURLOPT_FOLLOWLOCATION, 1);
  CURLcode result = curl_easy_perform(curl_handle);
  curl_easy_cleanup(curl_handle);

  if (result != CURLE_OK) {
    std::string why = error_buffer[0] ? error_buffer : "unhandled error";
    throw std::runtime_error("Downloading Add-on list failed: " + why);
  }

  try {
    lisp::Parser parser;
    std::stringstream addoninfos_stream(addoninfos);
    const lisp::Lisp* root = parser.parse(addoninfos_stream, "supertux-addons");

    const lisp::Lisp* addons_lisp = root->get_lisp("supertux-addons");
    if(!addons_lisp) throw std::runtime_error("Downloaded file is not an Add-on list");

    lisp::ListIterator iter(addons_lisp);
    while(iter.next()) 
    {
      const std::string& token = iter.item();
      if(token != "supertux-addoninfo") 
      {
        log_warning << "Unknown token '" << token << "' in Add-on list" << std::endl;
        continue;
      }
      std::auto_ptr<Addon> addon(new Addon());
      addon->parse(*(iter.lisp()));
      addon->installed = false;
      addon->loaded = false;

      // make sure the list of known Add-ons does not already contain this one 
      bool exists = false;
      for (std::vector<Addon*>::const_iterator i = addons.begin(); i != addons.end(); i++) {
        if (**i == *addon) {
          exists = true; 
          break; 
        }
      }

      if (exists) 
      {
        // do nothing
      }
      else if (addon->suggested_filename.find_first_not_of("match.quiz-proxy_gwenblvdjfks0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos) 
      {
        // make sure the Add-on's file name does not contain weird characters
        log_warning << "Add-on \"" << addon->title << "\" contains unsafe file name. Skipping." << std::endl;
      }
      else
      {
        addons.push_back(addon.release());
      }
    }
  } catch(std::exception& e) {
    std::stringstream msg;
    msg << "Problem when reading Add-on list: " << e.what();
    throw std::runtime_error(msg.str());
  }

#endif
}

void AddonManager::install

(

Addon *

addon

)

Download and install Add-on.

Definition at line 184 of file addon_manager.cpp.

References enable(), Addon::get_md5(), Addon::http_url, Addon::installed, Addon::installed_absolute_filename, Addon::installed_physfs_filename, Addon::loaded, log_debug, Addon::stored_md5, and Addon::suggested_filename.

Referenced by AddonMenu::check_menu().

{
#ifdef HAVE_LIBCURL

  if (addon->installed) throw std::runtime_error("Tried installing installed Add-on");

  // make sure the Add-on's file name does not contain weird characters
  if (addon->suggested_filename.find_first_not_of("match.quiz-proxy_gwenblvdjfks0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos) {
    throw std::runtime_error("Add-on has unsafe file name (\""+addon->suggested_filename+"\")");
  }

  std::string fileName = addon->suggested_filename;

  // make sure its file doesn't already exist
  if (PHYSFS_exists(fileName.c_str())) {
    fileName = addon->stored_md5 + "_" + addon->suggested_filename;
    if (PHYSFS_exists(fileName.c_str())) {
      throw std::runtime_error("Add-on of suggested filename already exists (\""+addon->suggested_filename+"\", \""+fileName+"\")");
    }
  }

  char error_buffer[CURL_ERROR_SIZE+1];

  char* url = (char*)malloc(addon->http_url.length() + 1);
  strncpy(url, addon->http_url.c_str(), addon->http_url.length() + 1);

  PHYSFS_file* f = PHYSFS_openWrite(fileName.c_str());

  log_debug << "Downloading \"" << url << "\"" << std::endl;

  CURL *curl_handle;
  curl_handle = curl_easy_init();
  curl_easy_setopt(curl_handle, CURLOPT_URL, url);
  curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "SuperTux/" PACKAGE_VERSION " libcURL");
  curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION, my_curl_physfs_write);
  curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, f);
  curl_easy_setopt(curl_handle, CURLOPT_ERRORBUFFER, error_buffer);
  curl_easy_setopt(curl_handle, CURLOPT_NOPROGRESS, 1);
  curl_easy_setopt(curl_handle, CURLOPT_NOSIGNAL, 1);
  curl_easy_setopt(curl_handle, CURLOPT_FAILONERROR, 1);
  CURLcode result = curl_easy_perform(curl_handle);
  curl_easy_cleanup(curl_handle);

  PHYSFS_close(f);

  free(url);

  if (result != CURLE_OK) {
    PHYSFS_delete(fileName.c_str());
    std::string why = error_buffer[0] ? error_buffer : "unhandled error";
    throw std::runtime_error("Downloading Add-on failed: " + why);
  }

  addon->installed = true;
  addon->installed_physfs_filename = fileName;
  static const std::string writeDir = PHYSFS_getWriteDir();
  static const std::string dirSep = PHYSFS_getDirSeparator();
  addon->installed_absolute_filename = writeDir + dirSep + fileName;
  addon->loaded = false;

  if (addon->get_md5() != addon->stored_md5) {
    addon->installed = false;
    PHYSFS_delete(fileName.c_str());
    std::string why = "MD5 checksums differ"; 
    throw std::runtime_error("Downloading Add-on failed: " + why);
  }

  log_debug << "Finished downloading \"" << addon->installed_absolute_filename << "\". Enabling Add-on." << std::endl;

  enable(addon);

#else
  (void) addon;
#endif

}

void AddonManager::remove

(

Addon *

addon

)

Physically delete Add-on.

Definition at line 262 of file addon_manager.cpp.

References Addon::installed, Addon::installed_absolute_filename, Addon::installed_physfs_filename, log_debug, and unload().

{
  if (!addon->installed) throw std::runtime_error("Tried removing non-installed Add-on");

  //FIXME: more checks

  // make sure the Add-on's file name does not contain weird characters
  if (addon->installed_physfs_filename.find_first_not_of("match.quiz-proxy_gwenblvdjfks0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos) {
    throw std::runtime_error("Add-on has unsafe file name (\""+addon->installed_physfs_filename+"\")");
  }

  unload(addon);

  log_debug << "deleting file \"" << addon->installed_absolute_filename << "\"" << std::endl;
  PHYSFS_delete(addon->installed_absolute_filename.c_str());
  addon->installed = false;

  // FIXME: As we don't know anything more about it (e.g. where to get it), remove it from list of known Add-ons
}

void AddonManager::disable

(

Addon *

addon

)

Unload Add-on and mark as not to be loaded automatically.

Definition at line 283 of file addon_manager.cpp.

References ignored_addon_filenames, Addon::installed_physfs_filename, and unload().

Referenced by AddonMenu::check_menu().

{
  unload(addon);

  std::string fileName = addon->installed_physfs_filename;
  if (std::find(ignored_addon_filenames.begin(), ignored_addon_filenames.end(), fileName) == ignored_addon_filenames.end()) {
    ignored_addon_filenames.push_back(fileName);
  }
}

void AddonManager::enable

(

Addon *

addon

)

Load Add-on and mark as to be loaded automatically.

Definition at line 294 of file addon_manager.cpp.

References ignored_addon_filenames, Addon::installed_physfs_filename, and load().

Referenced by AddonMenu::check_menu(), and install().

{
  load(addon);

  std::string fileName = addon->installed_physfs_filename;
  std::vector<std::string>::iterator i = std::find(ignored_addon_filenames.begin(), ignored_addon_filenames.end(), fileName);
  if (i != ignored_addon_filenames.end()) {
    ignored_addon_filenames.erase(i);
  }
}

void AddonManager::unload

(

Addon *

addon

)

Remove Add-on from search path.

Definition at line 306 of file addon_manager.cpp.

References Addon::installed, Addon::installed_absolute_filename, Addon::loaded, log_debug, and log_warning.

Referenced by disable(), load_addons(), and remove().

{
  if (!addon->installed) throw std::runtime_error("Tried unloading non-installed Add-on");
  if (!addon->loaded) return;

  log_debug << "Removing archive \"" << addon->installed_absolute_filename << "\" from search path" << std::endl;
  if (PHYSFS_removeFromSearchPath(addon->installed_absolute_filename.c_str()) == 0) {
    log_warning << "Could not remove " << addon->installed_absolute_filename << " from search path. Ignoring." << std::endl;
    return;
  }

  addon->loaded = false;
}

void AddonManager::load

(

Addon *

addon

)

Add Add-on to search path.

Definition at line 321 of file addon_manager.cpp.

References Addon::installed, Addon::installed_absolute_filename, Addon::loaded, log_debug, and log_warning.

Referenced by enable().

{
  if (!addon->installed) throw std::runtime_error("Tried loading non-installed Add-on");
  if (addon->loaded) return;

  log_debug << "Adding archive \"" << addon->installed_absolute_filename << "\" to search path" << std::endl;
  if (PHYSFS_addToSearchPath(addon->installed_absolute_filename.c_str(), 0) == 0) {
    log_warning << "Could not add " << addon->installed_absolute_filename << " to search path. Ignoring." << std::endl;
    return;
  }

  addon->loaded = true;
}

void AddonManager::load_addons

(

)

Loads all enabled Add-ons, i.e.

adds them to the search path

Definition at line 336 of file addon_manager.cpp.

References addons, ignored_addon_filenames, Addon::installed, Addon::installed_absolute_filename, Addon::installed_physfs_filename, Addon::loaded, log_debug, log_warning, Addon::parse(), and unload().

Referenced by Main::run().

{
  // unload all Addons and forget about them
  for (std::vector<Addon*>::iterator i = addons.begin(); i != addons.end(); i++) {
    if ((*i)->installed && (*i)->loaded) unload(*i);
    delete *i;
  }
  addons.clear();

  // Search for archives and add them to the search path
  char** rc = PHYSFS_enumerateFiles("/");

  for(char** i = rc; *i != 0; ++i) {

    // get filename of potential archive
    std::string fileName = *i;

    const std::string archiveDir = PHYSFS_getRealDir(fileName.c_str());
    static const std::string dirSep = PHYSFS_getDirSeparator();
    std::string fullFilename = archiveDir + dirSep + fileName;

    /*
    // make sure it's in the writeDir
    static const std::string writeDir = PHYSFS_getWriteDir();
    if (fileName.compare(0, writeDir.length(), writeDir) != 0) continue;
    */

    // make sure it looks like an archive
    static const std::string archiveExt = ".zip";
    if (fullFilename.compare(fullFilename.length()-archiveExt.length(), archiveExt.length(), archiveExt) != 0) continue;

    // make sure it exists
    struct stat stats;
    if (stat(fullFilename.c_str(), &stats) != 0) continue;

    // make sure it's an actual file
    if (!S_ISREG(stats.st_mode)) continue;

    log_debug << "Found archive \"" << fullFilename << "\"" << std::endl;

    // add archive to search path
    PHYSFS_addToSearchPath(fullFilename.c_str(), 0);

    // Search for infoFiles
    std::string infoFileName = "";
    char** rc2 = PHYSFS_enumerateFiles("/");
    for(char** i = rc2; *i != 0; ++i) {

      // get filename of potential infoFile
      std::string potentialInfoFileName = *i;

      // make sure it looks like an infoFile
      static const std::string infoExt = ".nfo";
      if (potentialInfoFileName.length() <= infoExt.length())
        continue;

      if (potentialInfoFileName.compare(potentialInfoFileName.length()-infoExt.length(), infoExt.length(), infoExt) != 0)
        continue;

      // make sure it's in the current archive
      std::string infoFileDir = PHYSFS_getRealDir(potentialInfoFileName.c_str());
      if (infoFileDir != fullFilename) continue;

      // found infoFileName
      infoFileName = potentialInfoFileName;
      break;
    }
    PHYSFS_freeList(rc2);

    // if we have an infoFile, it's an Addon
    if (infoFileName != "") {
      try {
        Addon* addon = new Addon();
        addon->parse(infoFileName);
        addon->installed = true;
        addon->installed_physfs_filename = fileName;
        addon->installed_absolute_filename = fullFilename;
        addon->loaded = true;
        addons.push_back(addon);

        // check if the Addon is disabled 
        if (std::find(ignored_addon_filenames.begin(), ignored_addon_filenames.end(), fileName) != ignored_addon_filenames.end()) {
          unload(addon);
        }

      } catch (const std::runtime_error& e) {
        log_warning << "Could not load add-on info for " << fullFilename << ", loading as unmanaged:" << e.what() << std::endl;
      }
    }

  }

  PHYSFS_freeList(rc);
}

AddonManager & AddonManager::get_instance

(

)

[static]

Returns the shared AddonManager instance.

Definition at line 65 of file addon_manager.cpp.

Referenced by AddonMenu::check_menu(), Config::load(), AddonMenu::refresh(), Main::run(), and Config::save().

{
  static AddonManager instance;
  return instance;
}

void AddonManager::write

(

Writer &

writer

)

Write AddonManager configuration to Lisp.

Definition at line 438 of file addon_manager.cpp.

References ignored_addon_filenames, and lisp::Writer::write().

Referenced by Config::save().

{
  writer.write("disabled-addons", ignored_addon_filenames); 
}

void AddonManager::read

(

const Reader &

lisp

)

Read AddonManager configuration from Lisp.

Definition at line 432 of file addon_manager.cpp.

References lisp::Lisp::get(), and ignored_addon_filenames.

Referenced by Config::load().

{
  lisp.get("disabled-addons", ignored_addon_filenames); 
}

---

Member Data Documentation

std::vector<Addon*> AddonManager::addons [protected]

Definition at line 95 of file addon_manager.hpp.

Referenced by check_online(), get_addons(), load_addons(), and ~AddonManager().

std::vector<std::string> AddonManager::ignored_addon_filenames [protected]

Definition at line 96 of file addon_manager.hpp.

Referenced by disable(), enable(), load_addons(), read(), and write().

---

The documentation for this class was generated from the following files:

• src/addon/addon_manager.hpp
• src/addon/addon_manager.cpp

---