Source/WebCore/plugins/PluginDatabase.cpp - platform/external/webkit - Git at Google

 /*
  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
  * Copyright (C) 2008 Collabora, Ltd.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */

 #include "config.h"
 #include "PluginDatabase.h"

 #include "Frame.h"
 #include "KURL.h"
 #include "PluginPackage.h"
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
 #include "FileSystem.h"
 #endif
 #include <stdlib.h>
 #include <wtf/text/CString.h>

 #if PLATFORM(ANDROID)
 #include "JavaSharedClient.h"
 #include "PluginClient.h"
 #endif

 namespace WebCore {

 typedef HashMap<String, RefPtr<PluginPackage> > PluginPackageByNameMap;

 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
 static const size_t maximumPersistentPluginMetadataCacheSize = 32768;

 static bool gPersistentPluginMetadataCacheIsEnabled;

 String& persistentPluginMetadataCachePath()
 {
     DEFINE_STATIC_LOCAL(String, cachePath, ());
     return cachePath;
 }
 #endif

 PluginDatabase::PluginDatabase()
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
     : m_persistentMetadataCacheIsLoaded(false)
 #endif
 {
 }

 PluginDatabase* PluginDatabase::installedPlugins(bool populate)
 {
     static PluginDatabase* plugins = 0;

     if (!plugins) {
         plugins = new PluginDatabase;

         if (populate) {
             plugins->setPluginDirectories(PluginDatabase::defaultPluginDirectories());
             plugins->refresh();
         }
     }

     return plugins;
 }

 bool PluginDatabase::isMIMETypeRegistered(const String& mimeType)
 {
     if (mimeType.isNull())
         return false;
     if (m_registeredMIMETypes.contains(mimeType))
         return true;
     // No plugin was found, try refreshing the database and searching again
     return (refresh() && m_registeredMIMETypes.contains(mimeType));
 }

 void PluginDatabase::addExtraPluginDirectory(const String& directory)
 {
     m_pluginDirectories.append(directory);
     refresh();
 }

 bool PluginDatabase::refresh()
 {
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
     if (!m_persistentMetadataCacheIsLoaded)
         loadPersistentMetadataCache();
 #endif
     bool pluginSetChanged = false;

     if (!m_plugins.isEmpty()) {
         PluginSet pluginsToUnload;
         getDeletedPlugins(pluginsToUnload);

         // Unload plugins
         PluginSet::const_iterator end = pluginsToUnload.end();
         for (PluginSet::const_iterator it = pluginsToUnload.begin(); it != end; ++it)
             remove(it->get());

         pluginSetChanged = !pluginsToUnload.isEmpty();
     }

     HashSet<String> paths;
     getPluginPathsInDirectories(paths);

     HashMap<String, time_t> pathsWithTimes;

     // We should only skip unchanged files if we didn't remove any plugins above. If we did remove
     // any plugins, we need to look at every plugin file so that, e.g., if the user has two versions
     // of RealPlayer installed and just removed the newer one, we'll pick up the older one.
     bool shouldSkipUnchangedFiles = !pluginSetChanged;

     HashSet<String>::const_iterator pathsEnd = paths.end();
     for (HashSet<String>::const_iterator it = paths.begin(); it != pathsEnd; ++it) {
         time_t lastModified;
         if (!getFileModificationTime(*it, lastModified))
             continue;

         pathsWithTimes.add(*it, lastModified);

         // If the path's timestamp hasn't changed since the last time we ran refresh(), we don't have to do anything.
         if (shouldSkipUnchangedFiles && m_pluginPathsWithTimes.get(*it) == lastModified)
             continue;

         if (RefPtr<PluginPackage> oldPackage = m_pluginsByPath.get(*it)) {
             ASSERT(!shouldSkipUnchangedFiles || oldPackage->lastModified() != lastModified);
             remove(oldPackage.get());
         }

         RefPtr<PluginPackage> package = PluginPackage::createPackage(*it, lastModified);
         if (package && add(package.release()))
             pluginSetChanged = true;
     }

     // Cache all the paths we found with their timestamps for next time.
     pathsWithTimes.swap(m_pluginPathsWithTimes);

     if (!pluginSetChanged)
         return false;

 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
     updatePersistentMetadataCache();
 #endif

     m_registeredMIMETypes.clear();

     // Register plug-in MIME types
     PluginSet::const_iterator end = m_plugins.end();
     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
         // Get MIME types
         MIMEToDescriptionsMap::const_iterator map_it = (*it)->mimeToDescriptions().begin();
         MIMEToDescriptionsMap::const_iterator map_end = (*it)->mimeToDescriptions().end();
         for (; map_it != map_end; ++map_it)
             m_registeredMIMETypes.add(map_it->first);
     }

     return true;
 }

 Vector<PluginPackage*> PluginDatabase::plugins() const
 {
     Vector<PluginPackage*> result;

     PluginSet::const_iterator end = m_plugins.end();
     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it)
         result.append((*it).get());

     return result;
 }

 int PluginDatabase::preferredPluginCompare(const void* a, const void* b)
 {
     PluginPackage* pluginA = *static_cast<PluginPackage* const*>(a);
     PluginPackage* pluginB = *static_cast<PluginPackage* const*>(b);

     return pluginA->compare(*pluginB);
 }

 PluginPackage* PluginDatabase::pluginForMIMEType(const String& mimeType)
 {
     if (mimeType.isEmpty())
         return 0;

     String key = mimeType.lower();
     PluginSet::const_iterator end = m_plugins.end();
     PluginPackage* preferredPlugin = m_preferredPlugins.get(key).get();
     if (preferredPlugin
         && preferredPlugin->isEnabled()
         && preferredPlugin->mimeToDescriptions().contains(key)) {
         return preferredPlugin;
     }

     Vector<PluginPackage*, 2> pluginChoices;

     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
         PluginPackage* plugin = (*it).get();

         if (!plugin->isEnabled())
             continue;

         if (plugin->mimeToDescriptions().contains(key)) {
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
             if (!plugin->ensurePluginLoaded())
                 continue;
 #endif
             pluginChoices.append(plugin);
         }
     }

     if (pluginChoices.isEmpty())
         return 0;

     qsort(pluginChoices.data(), pluginChoices.size(), sizeof(PluginPackage*), PluginDatabase::preferredPluginCompare);

     return pluginChoices[0];
 }

 String PluginDatabase::MIMETypeForExtension(const String& extension) const
 {
     if (extension.isEmpty())
         return String();

     PluginSet::const_iterator end = m_plugins.end();
     String mimeType;
     Vector<PluginPackage*, 2> pluginChoices;
     HashMap<PluginPackage*, String> mimeTypeForPlugin;

     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
         if (!(*it)->isEnabled())
             continue;

         MIMEToExtensionsMap::const_iterator mime_end = (*it)->mimeToExtensions().end();

         for (MIMEToExtensionsMap::const_iterator mime_it = (*it)->mimeToExtensions().begin(); mime_it != mime_end; ++mime_it) {
             mimeType = mime_it->first;
             PluginPackage* preferredPlugin = m_preferredPlugins.get(mimeType).get();
             const Vector<String>& extensions = mime_it->second;
             bool foundMapping = false;
             for (unsigned i = 0; i < extensions.size(); i++) {
                 if (equalIgnoringCase(extensions[i], extension)) {
                     PluginPackage* plugin = (*it).get();

                     if (preferredPlugin && PluginPackage::equal(*plugin, *preferredPlugin))
                         return mimeType;

 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
                     if (!plugin->ensurePluginLoaded())
                         continue;
 #endif
                     pluginChoices.append(plugin);
                     mimeTypeForPlugin.add(plugin, mimeType);
                     foundMapping = true;
                     break;
                 }
             }
             if (foundMapping)
                 break;
         }
     }

     if (pluginChoices.isEmpty())
         return String();

     qsort(pluginChoices.data(), pluginChoices.size(), sizeof(PluginPackage*), PluginDatabase::preferredPluginCompare);

     return mimeTypeForPlugin.get(pluginChoices[0]);
 }

 PluginPackage* PluginDatabase::findPlugin(const KURL& url, String& mimeType)
 {
     if (!mimeType.isEmpty())
         return pluginForMIMEType(mimeType);

     String filename = url.lastPathComponent();
     if (filename.endsWith("/"))
         return 0;

     int extensionPos = filename.reverseFind('.');
     if (extensionPos == -1)
         return 0;

     String mimeTypeForExtension = MIMETypeForExtension(filename.substring(extensionPos + 1));
     PluginPackage* plugin = pluginForMIMEType(mimeTypeForExtension);
     if (!plugin) {
         // FIXME: if no plugin could be found, query Windows for the mime type
         // corresponding to the extension.
         return 0;
     }

     mimeType = mimeTypeForExtension;
     return plugin;
 }

 void PluginDatabase::setPreferredPluginForMIMEType(const String& mimeType, PluginPackage* plugin)
 {
     if (!plugin || plugin->mimeToExtensions().contains(mimeType))
         m_preferredPlugins.set(mimeType.lower(), plugin);
 }

 void PluginDatabase::getDeletedPlugins(PluginSet& plugins) const
 {
     PluginSet::const_iterator end = m_plugins.end();
     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
         if (!fileExists((*it)->path()))
             plugins.add(*it);
     }
 }

 bool PluginDatabase::add(PassRefPtr<PluginPackage> prpPackage)
 {
     ASSERT_ARG(prpPackage, prpPackage);

     RefPtr<PluginPackage> package = prpPackage;

     if (!m_plugins.add(package).second)
         return false;

     m_pluginsByPath.add(package->path(), package);
     return true;
 }

 void PluginDatabase::remove(PluginPackage* package)
 {
     MIMEToExtensionsMap::const_iterator it = package->mimeToExtensions().begin();
     MIMEToExtensionsMap::const_iterator end = package->mimeToExtensions().end();
     for ( ; it != end; ++it) {
         PluginPackageByNameMap::iterator packageInMap = m_preferredPlugins.find(it->first);
         if (packageInMap != m_preferredPlugins.end() && packageInMap->second == package)
             m_preferredPlugins.remove(packageInMap);
     }

     m_plugins.remove(package);
     m_pluginsByPath.remove(package->path());
 }

 void PluginDatabase::clear()
 {
     m_plugins.clear();
     m_pluginsByPath.clear();
     m_pluginPathsWithTimes.clear();
     m_registeredMIMETypes.clear();
     m_preferredPlugins.clear();
 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
     m_persistentMetadataCacheIsLoaded = false;
 #endif
 }

 #if (!OS(WINCE)) && (!OS(SYMBIAN)) && (!OS(WINDOWS) || !ENABLE(NETSCAPE_PLUGIN_API))
 // For Safari/Win the following three methods are implemented
 // in PluginDatabaseWin.cpp, but if we can use WebCore constructs
 // for the logic we should perhaps move it here under XP_WIN?

 Vector<String> PluginDatabase::defaultPluginDirectories()
 {
     Vector<String> paths;

     // Add paths specific to each platform
 #if defined(XP_UNIX)
     String userPluginPath = homeDirectoryPath();
     userPluginPath.append(String("/.mozilla/plugins"));
     paths.append(userPluginPath);

     userPluginPath = homeDirectoryPath();
     userPluginPath.append(String("/.netscape/plugins"));
     paths.append(userPluginPath);

     paths.append("/usr/lib/browser/plugins");
     paths.append("/usr/local/lib/mozilla/plugins");
     paths.append("/usr/lib/firefox/plugins");
     paths.append("/usr/lib64/browser-plugins");
     paths.append("/usr/lib/browser-plugins");
     paths.append("/usr/lib/mozilla/plugins");
     paths.append("/usr/local/netscape/plugins");
     paths.append("/opt/mozilla/plugins");
     paths.append("/opt/mozilla/lib/plugins");
     paths.append("/opt/netscape/plugins");
     paths.append("/opt/netscape/communicator/plugins");
     paths.append("/usr/lib/netscape/plugins");
     paths.append("/usr/lib/netscape/plugins-libc5");
     paths.append("/usr/lib/netscape/plugins-libc6");
     paths.append("/usr/lib64/netscape/plugins");
     paths.append("/usr/lib64/mozilla/plugins");
     paths.append("/usr/lib/nsbrowser/plugins");
     paths.append("/usr/lib64/nsbrowser/plugins");

     String mozHome(getenv("MOZILLA_HOME"));
     mozHome.append("/plugins");
     paths.append(mozHome);

     Vector<String> mozPaths;
     String mozPath(getenv("MOZ_PLUGIN_PATH"));
     mozPath.split(UChar(':'), /* allowEmptyEntries */ false, mozPaths);
     paths.append(mozPaths);
 #elif defined(XP_MACOSX)
     String userPluginPath = homeDirectoryPath();
     userPluginPath.append(String("/Library/Internet Plug-Ins"));
     paths.append(userPluginPath);
     paths.append("/Library/Internet Plug-Ins");
 #elif defined(XP_WIN)
     String userPluginPath = homeDirectoryPath();
     userPluginPath.append(String("\\Application Data\\Mozilla\\plugins"));
     paths.append(userPluginPath);
 #endif

     // Add paths specific to each port
 #if PLATFORM(QT)
     Vector<String> qtPaths;
     String qtPath(qgetenv("QTWEBKIT_PLUGIN_PATH").constData());
     qtPath.split(UChar(':'), /* allowEmptyEntries */ false, qtPaths);
     paths.append(qtPaths);
 #endif

 #if PLATFORM(ANDROID)
     if (android::JavaSharedClient::GetPluginClient())
         return android::JavaSharedClient::GetPluginClient()->getPluginDirectories();
 #endif

     return paths;
 }

 bool PluginDatabase::isPreferredPluginDirectory(const String& path)
 {
     String preferredPath = homeDirectoryPath();

 #if defined(XP_UNIX)
     preferredPath.append(String("/.mozilla/plugins"));
 #elif defined(XP_MACOSX)
     preferredPath.append(String("/Library/Internet Plug-Ins"));
 #elif defined(XP_WIN)
     preferredPath.append(String("\\Application Data\\Mozilla\\plugins"));
 #endif

     // TODO: We should normalize the path before doing a comparison.
     return path == preferredPath;
 }

 void PluginDatabase::getPluginPathsInDirectories(HashSet<String>& paths) const
 {
     // FIXME: This should be a case insensitive set.
     HashSet<String> uniqueFilenames;

 #if defined(XP_UNIX) || defined(ANDROID)
     String fileNameFilter("*.so");
 #else
     String fileNameFilter("");
 #endif

     Vector<String>::const_iterator dirsEnd = m_pluginDirectories.end();
     for (Vector<String>::const_iterator dIt = m_pluginDirectories.begin(); dIt != dirsEnd; ++dIt) {
         Vector<String> pluginPaths = listDirectory(*dIt, fileNameFilter);
         Vector<String>::const_iterator pluginsEnd = pluginPaths.end();
         for (Vector<String>::const_iterator pIt = pluginPaths.begin(); pIt != pluginsEnd; ++pIt) {
             if (!fileExists(*pIt))
                 continue;

             paths.add(*pIt);
         }
     }
 }

 #endif // !OS(SYMBIAN) && !OS(WINDOWS)

 #if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)

 static void fillBufferWithContentsOfFile(PlatformFileHandle file, Vector<char>& buffer)
 {
     size_t bufferSize = 0;
     size_t bufferCapacity = 1024;
     buffer.resize(bufferCapacity);

     do {
         bufferSize += readFromFile(file, buffer.data() + bufferSize, bufferCapacity - bufferSize);
         if (bufferSize == bufferCapacity) {
             if (bufferCapacity < maximumPersistentPluginMetadataCacheSize) {
                 bufferCapacity *= 2;
                 buffer.resize(bufferCapacity);
             } else {
                 buffer.clear();
                 return;
             }
         } else
             break;
     } while (true);

     buffer.shrink(bufferSize);
 }

 static bool readUTF8String(String& resultString, char*& start, const char* end)
 {
     if (start >= end)
         return false;

     int len = strlen(start);
     resultString = String::fromUTF8(start, len);
     start += len + 1;

     return true;
 }

 static bool readTime(time_t& resultTime, char*& start, const char* end)
 {
     if (start + sizeof(time_t) >= end)
         return false;

     resultTime = *reinterpret_cast_ptr<time_t*>(start);
     start += sizeof(time_t);

     return true;
 }

 static const char schemaVersion = '1';
 static const char persistentPluginMetadataCacheFilename[] = "PluginMetadataCache.bin";

 void PluginDatabase::loadPersistentMetadataCache()
 {
     if (!isPersistentMetadataCacheEnabled() || persistentMetadataCachePath().isEmpty())
         return;

     PlatformFileHandle file;
     String absoluteCachePath = pathByAppendingComponent(persistentMetadataCachePath(), persistentPluginMetadataCacheFilename);
     file = openFile(absoluteCachePath, OpenForRead);

     if (!isHandleValid(file))
         return;

     // Mark cache as loaded regardless of success or failure. If
     // there's error in the cache, we won't try to load it anymore.
     m_persistentMetadataCacheIsLoaded = true;

     Vector<char> fileContents;
     fillBufferWithContentsOfFile(file, fileContents);
     closeFile(file);

     if (fileContents.size() < 2 || fileContents.first() != schemaVersion || fileContents.last() != '\0') {
         LOG_ERROR("Unable to read plugin metadata cache: corrupt schema");
         deleteFile(absoluteCachePath);
         return;
     }

     char* bufferPos = fileContents.data() + 1;
     char* end = fileContents.data() + fileContents.size();

     PluginSet cachedPlugins;
     HashMap<String, time_t> cachedPluginPathsWithTimes;
     HashMap<String, RefPtr<PluginPackage> > cachedPluginsByPath;

     while (bufferPos < end) {
         String path;
         time_t lastModified;
         String name;
         String desc;
         String mimeDesc;
         if (!(readUTF8String(path, bufferPos, end)
               && readTime(lastModified, bufferPos, end)
               && readUTF8String(name, bufferPos, end)
               && readUTF8String(desc, bufferPos, end)
               && readUTF8String(mimeDesc, bufferPos, end))) {
             LOG_ERROR("Unable to read plugin metadata cache: corrupt data");
             deleteFile(absoluteCachePath);
             return;
         }

         // Skip metadata that points to plugins from directories that
         // are not part of plugin directory list anymore.
         String pluginDirectoryName = directoryName(path);
         if (m_pluginDirectories.find(pluginDirectoryName) == WTF::notFound)
             continue;

         RefPtr<PluginPackage> package = PluginPackage::createPackageFromCache(path, lastModified, name, desc, mimeDesc);

         if (package && cachedPlugins.add(package).second) {
             cachedPluginPathsWithTimes.add(package->path(), package->lastModified());
             cachedPluginsByPath.add(package->path(), package);
         }
     }

     m_plugins.swap(cachedPlugins);
     m_pluginsByPath.swap(cachedPluginsByPath);
     m_pluginPathsWithTimes.swap(cachedPluginPathsWithTimes);
 }

 static bool writeUTF8String(PlatformFileHandle file, const String& string)
 {
     CString utf8String = string.utf8();
     int length = utf8String.length() + 1;
     return writeToFile(file, utf8String.data(), length) == length;
 }

 static bool writeTime(PlatformFileHandle file, const time_t& time)
 {
     return writeToFile(file, reinterpret_cast<const char*>(&time), sizeof(time_t)) == sizeof(time_t);
 }

 void PluginDatabase::updatePersistentMetadataCache()
 {
     if (!isPersistentMetadataCacheEnabled() || persistentMetadataCachePath().isEmpty())
         return;

     makeAllDirectories(persistentMetadataCachePath());
     String absoluteCachePath = pathByAppendingComponent(persistentMetadataCachePath(), persistentPluginMetadataCacheFilename);
     deleteFile(absoluteCachePath);

     if (m_plugins.isEmpty())
         return;

     PlatformFileHandle file;
     file = openFile(absoluteCachePath, OpenForWrite);

     if (!isHandleValid(file)) {
         LOG_ERROR("Unable to open plugin metadata cache for saving");
         return;
     }

     char localSchemaVersion = schemaVersion;
     if (writeToFile(file, &localSchemaVersion, 1) != 1) {
         LOG_ERROR("Unable to write plugin metadata cache schema");
         closeFile(file);
         deleteFile(absoluteCachePath);
         return;
     }

     PluginSet::const_iterator end = m_plugins.end();
     for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
         if (!(writeUTF8String(file, (*it)->path())
               && writeTime(file, (*it)->lastModified())
               && writeUTF8String(file, (*it)->name())
               && writeUTF8String(file, (*it)->description())
               && writeUTF8String(file, (*it)->fullMIMEDescription()))) {
             LOG_ERROR("Unable to write plugin metadata to cache");
             closeFile(file);
             deleteFile(absoluteCachePath);
             return;
         }
     }

     closeFile(file);
 }

 bool PluginDatabase::isPersistentMetadataCacheEnabled()
 {
     return gPersistentPluginMetadataCacheIsEnabled;
 }

 void PluginDatabase::setPersistentMetadataCacheEnabled(bool isEnabled)
 {
     gPersistentPluginMetadataCacheIsEnabled = isEnabled;
 }

 String PluginDatabase::persistentMetadataCachePath()
 {
     return WebCore::persistentPluginMetadataCachePath();
 }

 void PluginDatabase::setPersistentMetadataCachePath(const String& persistentMetadataCachePath)
 {
     WebCore::persistentPluginMetadataCachePath() = persistentMetadataCachePath;
 }
 #endif
 }
	/*
	* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
	* Copyright (C) 2008 Collabora, Ltd. All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	*
	* THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
	* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR
	* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
	* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
	* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
	* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
	* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/

	#include "config.h"
	#include "PluginDatabase.h"

	#include "Frame.h"
	#include "KURL.h"
	#include "PluginPackage.h"
	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	#include "FileSystem.h"
	#endif
	#include <stdlib.h>
	#include <wtf/text/CString.h>

	#if PLATFORM(ANDROID)
	#include "JavaSharedClient.h"
	#include "PluginClient.h"
	#endif

	namespace WebCore {

	typedef HashMap<String, RefPtr<PluginPackage> > PluginPackageByNameMap;

	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	static const size_t maximumPersistentPluginMetadataCacheSize = 32768;

	static bool gPersistentPluginMetadataCacheIsEnabled;

	String& persistentPluginMetadataCachePath()
	{
	DEFINE_STATIC_LOCAL(String, cachePath, ());
	return cachePath;
	}
	#endif

	PluginDatabase::PluginDatabase()
	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	: m_persistentMetadataCacheIsLoaded(false)
	#endif
	{
	}

	PluginDatabase* PluginDatabase::installedPlugins(bool populate)
	{
	static PluginDatabase* plugins = 0;

	if (!plugins) {
	plugins = new PluginDatabase;

	if (populate) {
	plugins->setPluginDirectories(PluginDatabase::defaultPluginDirectories());
	plugins->refresh();
	}
	}

	return plugins;
	}

	bool PluginDatabase::isMIMETypeRegistered(const String& mimeType)
	{
	if (mimeType.isNull())
	return false;
	if (m_registeredMIMETypes.contains(mimeType))
	return true;
	// No plugin was found, try refreshing the database and searching again
	return (refresh() && m_registeredMIMETypes.contains(mimeType));
	}

	void PluginDatabase::addExtraPluginDirectory(const String& directory)
	{
	m_pluginDirectories.append(directory);
	refresh();
	}

	bool PluginDatabase::refresh()
	{
	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	if (!m_persistentMetadataCacheIsLoaded)
	loadPersistentMetadataCache();
	#endif
	bool pluginSetChanged = false;

	if (!m_plugins.isEmpty()) {
	PluginSet pluginsToUnload;
	getDeletedPlugins(pluginsToUnload);

	// Unload plugins
	PluginSet::const_iterator end = pluginsToUnload.end();
	for (PluginSet::const_iterator it = pluginsToUnload.begin(); it != end; ++it)
	remove(it->get());

	pluginSetChanged = !pluginsToUnload.isEmpty();
	}

	HashSet<String> paths;
	getPluginPathsInDirectories(paths);

	HashMap<String, time_t> pathsWithTimes;

	// We should only skip unchanged files if we didn't remove any plugins above. If we did remove
	// any plugins, we need to look at every plugin file so that, e.g., if the user has two versions
	// of RealPlayer installed and just removed the newer one, we'll pick up the older one.
	bool shouldSkipUnchangedFiles = !pluginSetChanged;

	HashSet<String>::const_iterator pathsEnd = paths.end();
	for (HashSet<String>::const_iterator it = paths.begin(); it != pathsEnd; ++it) {
	time_t lastModified;
	if (!getFileModificationTime(*it, lastModified))
	continue;

	pathsWithTimes.add(*it, lastModified);

	// If the path's timestamp hasn't changed since the last time we ran refresh(), we don't have to do anything.
	if (shouldSkipUnchangedFiles && m_pluginPathsWithTimes.get(*it) == lastModified)
	continue;

	if (RefPtr<PluginPackage> oldPackage = m_pluginsByPath.get(*it)) {
	ASSERT(!shouldSkipUnchangedFiles \|\| oldPackage->lastModified() != lastModified);
	remove(oldPackage.get());
	}

	RefPtr<PluginPackage> package = PluginPackage::createPackage(*it, lastModified);
	if (package && add(package.release()))
	pluginSetChanged = true;
	}

	// Cache all the paths we found with their timestamps for next time.
	pathsWithTimes.swap(m_pluginPathsWithTimes);

	if (!pluginSetChanged)
	return false;

	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	updatePersistentMetadataCache();
	#endif

	m_registeredMIMETypes.clear();

	// Register plug-in MIME types
	PluginSet::const_iterator end = m_plugins.end();
	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
	// Get MIME types
	MIMEToDescriptionsMap::const_iterator map_it = (*it)->mimeToDescriptions().begin();
	MIMEToDescriptionsMap::const_iterator map_end = (*it)->mimeToDescriptions().end();
	for (; map_it != map_end; ++map_it)
	m_registeredMIMETypes.add(map_it->first);
	}

	return true;
	}

	Vector<PluginPackage*> PluginDatabase::plugins() const
	{
	Vector<PluginPackage*> result;

	PluginSet::const_iterator end = m_plugins.end();
	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it)
	result.append((*it).get());

	return result;
	}

	int PluginDatabase::preferredPluginCompare(const void* a, const void* b)
	{
	PluginPackage* pluginA = static_cast<PluginPackage const*>(a);
	PluginPackage* pluginB = static_cast<PluginPackage const*>(b);

	return pluginA->compare(*pluginB);
	}

	PluginPackage* PluginDatabase::pluginForMIMEType(const String& mimeType)
	{
	if (mimeType.isEmpty())
	return 0;

	String key = mimeType.lower();
	PluginSet::const_iterator end = m_plugins.end();
	PluginPackage* preferredPlugin = m_preferredPlugins.get(key).get();
	if (preferredPlugin
	&& preferredPlugin->isEnabled()
	&& preferredPlugin->mimeToDescriptions().contains(key)) {
	return preferredPlugin;
	}

	Vector<PluginPackage*, 2> pluginChoices;

	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
	PluginPackage* plugin = (*it).get();

	if (!plugin->isEnabled())
	continue;

	if (plugin->mimeToDescriptions().contains(key)) {
	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	if (!plugin->ensurePluginLoaded())
	continue;
	#endif
	pluginChoices.append(plugin);
	}
	}

	if (pluginChoices.isEmpty())
	return 0;

	qsort(pluginChoices.data(), pluginChoices.size(), sizeof(PluginPackage*), PluginDatabase::preferredPluginCompare);

	return pluginChoices[0];
	}

	String PluginDatabase::MIMETypeForExtension(const String& extension) const
	{
	if (extension.isEmpty())
	return String();

	PluginSet::const_iterator end = m_plugins.end();
	String mimeType;
	Vector<PluginPackage*, 2> pluginChoices;
	HashMap<PluginPackage*, String> mimeTypeForPlugin;

	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
	if (!(*it)->isEnabled())
	continue;

	MIMEToExtensionsMap::const_iterator mime_end = (*it)->mimeToExtensions().end();

	for (MIMEToExtensionsMap::const_iterator mime_it = (*it)->mimeToExtensions().begin(); mime_it != mime_end; ++mime_it) {
	mimeType = mime_it->first;
	PluginPackage* preferredPlugin = m_preferredPlugins.get(mimeType).get();
	const Vector<String>& extensions = mime_it->second;
	bool foundMapping = false;
	for (unsigned i = 0; i < extensions.size(); i++) {
	if (equalIgnoringCase(extensions[i], extension)) {
	PluginPackage* plugin = (*it).get();

	if (preferredPlugin && PluginPackage::equal(plugin, preferredPlugin))
	return mimeType;

	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	if (!plugin->ensurePluginLoaded())
	continue;
	#endif
	pluginChoices.append(plugin);
	mimeTypeForPlugin.add(plugin, mimeType);
	foundMapping = true;
	break;
	}
	}
	if (foundMapping)
	break;
	}
	}

	if (pluginChoices.isEmpty())
	return String();

	qsort(pluginChoices.data(), pluginChoices.size(), sizeof(PluginPackage*), PluginDatabase::preferredPluginCompare);

	return mimeTypeForPlugin.get(pluginChoices[0]);
	}

	PluginPackage* PluginDatabase::findPlugin(const KURL& url, String& mimeType)
	{
	if (!mimeType.isEmpty())
	return pluginForMIMEType(mimeType);

	String filename = url.lastPathComponent();
	if (filename.endsWith("/"))
	return 0;

	int extensionPos = filename.reverseFind('.');
	if (extensionPos == -1)
	return 0;

	String mimeTypeForExtension = MIMETypeForExtension(filename.substring(extensionPos + 1));
	PluginPackage* plugin = pluginForMIMEType(mimeTypeForExtension);
	if (!plugin) {
	// FIXME: if no plugin could be found, query Windows for the mime type
	// corresponding to the extension.
	return 0;
	}

	mimeType = mimeTypeForExtension;
	return plugin;
	}

	void PluginDatabase::setPreferredPluginForMIMEType(const String& mimeType, PluginPackage* plugin)
	{
	if (!plugin \|\| plugin->mimeToExtensions().contains(mimeType))
	m_preferredPlugins.set(mimeType.lower(), plugin);
	}

	void PluginDatabase::getDeletedPlugins(PluginSet& plugins) const
	{
	PluginSet::const_iterator end = m_plugins.end();
	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
	if (!fileExists((*it)->path()))
	plugins.add(*it);
	}
	}

	bool PluginDatabase::add(PassRefPtr<PluginPackage> prpPackage)
	{
	ASSERT_ARG(prpPackage, prpPackage);

	RefPtr<PluginPackage> package = prpPackage;

	if (!m_plugins.add(package).second)
	return false;

	m_pluginsByPath.add(package->path(), package);
	return true;
	}

	void PluginDatabase::remove(PluginPackage* package)
	{
	MIMEToExtensionsMap::const_iterator it = package->mimeToExtensions().begin();
	MIMEToExtensionsMap::const_iterator end = package->mimeToExtensions().end();
	for ( ; it != end; ++it) {
	PluginPackageByNameMap::iterator packageInMap = m_preferredPlugins.find(it->first);
	if (packageInMap != m_preferredPlugins.end() && packageInMap->second == package)
	m_preferredPlugins.remove(packageInMap);
	}

	m_plugins.remove(package);
	m_pluginsByPath.remove(package->path());
	}

	void PluginDatabase::clear()
	{
	m_plugins.clear();
	m_pluginsByPath.clear();
	m_pluginPathsWithTimes.clear();
	m_registeredMIMETypes.clear();
	m_preferredPlugins.clear();
	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)
	m_persistentMetadataCacheIsLoaded = false;
	#endif
	}

	#if (!OS(WINCE)) && (!OS(SYMBIAN)) && (!OS(WINDOWS) \|\| !ENABLE(NETSCAPE_PLUGIN_API))
	// For Safari/Win the following three methods are implemented
	// in PluginDatabaseWin.cpp, but if we can use WebCore constructs
	// for the logic we should perhaps move it here under XP_WIN?

	Vector<String> PluginDatabase::defaultPluginDirectories()
	{
	Vector<String> paths;

	// Add paths specific to each platform
	#if defined(XP_UNIX)
	String userPluginPath = homeDirectoryPath();
	userPluginPath.append(String("/.mozilla/plugins"));
	paths.append(userPluginPath);

	userPluginPath = homeDirectoryPath();
	userPluginPath.append(String("/.netscape/plugins"));
	paths.append(userPluginPath);

	paths.append("/usr/lib/browser/plugins");
	paths.append("/usr/local/lib/mozilla/plugins");
	paths.append("/usr/lib/firefox/plugins");
	paths.append("/usr/lib64/browser-plugins");
	paths.append("/usr/lib/browser-plugins");
	paths.append("/usr/lib/mozilla/plugins");
	paths.append("/usr/local/netscape/plugins");
	paths.append("/opt/mozilla/plugins");
	paths.append("/opt/mozilla/lib/plugins");
	paths.append("/opt/netscape/plugins");
	paths.append("/opt/netscape/communicator/plugins");
	paths.append("/usr/lib/netscape/plugins");
	paths.append("/usr/lib/netscape/plugins-libc5");
	paths.append("/usr/lib/netscape/plugins-libc6");
	paths.append("/usr/lib64/netscape/plugins");
	paths.append("/usr/lib64/mozilla/plugins");
	paths.append("/usr/lib/nsbrowser/plugins");
	paths.append("/usr/lib64/nsbrowser/plugins");

	String mozHome(getenv("MOZILLA_HOME"));
	mozHome.append("/plugins");
	paths.append(mozHome);

	Vector<String> mozPaths;
	String mozPath(getenv("MOZ_PLUGIN_PATH"));
	mozPath.split(UChar(':'), /* allowEmptyEntries */ false, mozPaths);
	paths.append(mozPaths);
	#elif defined(XP_MACOSX)
	String userPluginPath = homeDirectoryPath();
	userPluginPath.append(String("/Library/Internet Plug-Ins"));
	paths.append(userPluginPath);
	paths.append("/Library/Internet Plug-Ins");
	#elif defined(XP_WIN)
	String userPluginPath = homeDirectoryPath();
	userPluginPath.append(String("\\Application Data\\Mozilla\\plugins"));
	paths.append(userPluginPath);
	#endif

	// Add paths specific to each port
	#if PLATFORM(QT)
	Vector<String> qtPaths;
	String qtPath(qgetenv("QTWEBKIT_PLUGIN_PATH").constData());
	qtPath.split(UChar(':'), /* allowEmptyEntries */ false, qtPaths);
	paths.append(qtPaths);
	#endif

	#if PLATFORM(ANDROID)
	if (android::JavaSharedClient::GetPluginClient())
	return android::JavaSharedClient::GetPluginClient()->getPluginDirectories();
	#endif

	return paths;
	}

	bool PluginDatabase::isPreferredPluginDirectory(const String& path)
	{
	String preferredPath = homeDirectoryPath();

	#if defined(XP_UNIX)
	preferredPath.append(String("/.mozilla/plugins"));
	#elif defined(XP_MACOSX)
	preferredPath.append(String("/Library/Internet Plug-Ins"));
	#elif defined(XP_WIN)
	preferredPath.append(String("\\Application Data\\Mozilla\\plugins"));
	#endif

	// TODO: We should normalize the path before doing a comparison.
	return path == preferredPath;
	}

	void PluginDatabase::getPluginPathsInDirectories(HashSet<String>& paths) const
	{
	// FIXME: This should be a case insensitive set.
	HashSet<String> uniqueFilenames;

	#if defined(XP_UNIX) \|\| defined(ANDROID)
	String fileNameFilter("*.so");
	#else
	String fileNameFilter("");
	#endif

	Vector<String>::const_iterator dirsEnd = m_pluginDirectories.end();
	for (Vector<String>::const_iterator dIt = m_pluginDirectories.begin(); dIt != dirsEnd; ++dIt) {
	Vector<String> pluginPaths = listDirectory(*dIt, fileNameFilter);
	Vector<String>::const_iterator pluginsEnd = pluginPaths.end();
	for (Vector<String>::const_iterator pIt = pluginPaths.begin(); pIt != pluginsEnd; ++pIt) {
	if (!fileExists(*pIt))
	continue;

	paths.add(*pIt);
	}
	}
	}

	#endif // !OS(SYMBIAN) && !OS(WINDOWS)

	#if ENABLE(NETSCAPE_PLUGIN_METADATA_CACHE)

	static void fillBufferWithContentsOfFile(PlatformFileHandle file, Vector<char>& buffer)
	{
	size_t bufferSize = 0;
	size_t bufferCapacity = 1024;
	buffer.resize(bufferCapacity);

	do {
	bufferSize += readFromFile(file, buffer.data() + bufferSize, bufferCapacity - bufferSize);
	if (bufferSize == bufferCapacity) {
	if (bufferCapacity < maximumPersistentPluginMetadataCacheSize) {
	bufferCapacity *= 2;
	buffer.resize(bufferCapacity);
	} else {
	buffer.clear();
	return;
	}
	} else
	break;
	} while (true);

	buffer.shrink(bufferSize);
	}

	static bool readUTF8String(String& resultString, char& start, const char end)
	{
	if (start >= end)
	return false;

	int len = strlen(start);
	resultString = String::fromUTF8(start, len);
	start += len + 1;

	return true;
	}

	static bool readTime(time_t& resultTime, char& start, const char end)
	{
	if (start + sizeof(time_t) >= end)
	return false;

	resultTime = reinterpret_cast_ptr<time_t>(start);
	start += sizeof(time_t);

	return true;
	}

	static const char schemaVersion = '1';
	static const char persistentPluginMetadataCacheFilename[] = "PluginMetadataCache.bin";

	void PluginDatabase::loadPersistentMetadataCache()
	{
	if (!isPersistentMetadataCacheEnabled() \|\| persistentMetadataCachePath().isEmpty())
	return;

	PlatformFileHandle file;
	String absoluteCachePath = pathByAppendingComponent(persistentMetadataCachePath(), persistentPluginMetadataCacheFilename);
	file = openFile(absoluteCachePath, OpenForRead);

	if (!isHandleValid(file))
	return;

	// Mark cache as loaded regardless of success or failure. If
	// there's error in the cache, we won't try to load it anymore.
	m_persistentMetadataCacheIsLoaded = true;

	Vector<char> fileContents;
	fillBufferWithContentsOfFile(file, fileContents);
	closeFile(file);

	if (fileContents.size() < 2 \|\| fileContents.first() != schemaVersion \|\| fileContents.last() != '\0') {
	LOG_ERROR("Unable to read plugin metadata cache: corrupt schema");
	deleteFile(absoluteCachePath);
	return;
	}

	char* bufferPos = fileContents.data() + 1;
	char* end = fileContents.data() + fileContents.size();

	PluginSet cachedPlugins;
	HashMap<String, time_t> cachedPluginPathsWithTimes;
	HashMap<String, RefPtr<PluginPackage> > cachedPluginsByPath;

	while (bufferPos < end) {
	String path;
	time_t lastModified;
	String name;
	String desc;
	String mimeDesc;
	if (!(readUTF8String(path, bufferPos, end)
	&& readTime(lastModified, bufferPos, end)
	&& readUTF8String(name, bufferPos, end)
	&& readUTF8String(desc, bufferPos, end)
	&& readUTF8String(mimeDesc, bufferPos, end))) {
	LOG_ERROR("Unable to read plugin metadata cache: corrupt data");
	deleteFile(absoluteCachePath);
	return;
	}

	// Skip metadata that points to plugins from directories that
	// are not part of plugin directory list anymore.
	String pluginDirectoryName = directoryName(path);
	if (m_pluginDirectories.find(pluginDirectoryName) == WTF::notFound)
	continue;

	RefPtr<PluginPackage> package = PluginPackage::createPackageFromCache(path, lastModified, name, desc, mimeDesc);

	if (package && cachedPlugins.add(package).second) {
	cachedPluginPathsWithTimes.add(package->path(), package->lastModified());
	cachedPluginsByPath.add(package->path(), package);
	}
	}

	m_plugins.swap(cachedPlugins);
	m_pluginsByPath.swap(cachedPluginsByPath);
	m_pluginPathsWithTimes.swap(cachedPluginPathsWithTimes);
	}

	static bool writeUTF8String(PlatformFileHandle file, const String& string)
	{
	CString utf8String = string.utf8();
	int length = utf8String.length() + 1;
	return writeToFile(file, utf8String.data(), length) == length;
	}

	static bool writeTime(PlatformFileHandle file, const time_t& time)
	{
	return writeToFile(file, reinterpret_cast<const char*>(&time), sizeof(time_t)) == sizeof(time_t);
	}

	void PluginDatabase::updatePersistentMetadataCache()
	{
	if (!isPersistentMetadataCacheEnabled() \|\| persistentMetadataCachePath().isEmpty())
	return;

	makeAllDirectories(persistentMetadataCachePath());
	String absoluteCachePath = pathByAppendingComponent(persistentMetadataCachePath(), persistentPluginMetadataCacheFilename);
	deleteFile(absoluteCachePath);

	if (m_plugins.isEmpty())
	return;

	PlatformFileHandle file;
	file = openFile(absoluteCachePath, OpenForWrite);

	if (!isHandleValid(file)) {
	LOG_ERROR("Unable to open plugin metadata cache for saving");
	return;
	}

	char localSchemaVersion = schemaVersion;
	if (writeToFile(file, &localSchemaVersion, 1) != 1) {
	LOG_ERROR("Unable to write plugin metadata cache schema");
	closeFile(file);
	deleteFile(absoluteCachePath);
	return;
	}

	PluginSet::const_iterator end = m_plugins.end();
	for (PluginSet::const_iterator it = m_plugins.begin(); it != end; ++it) {
	if (!(writeUTF8String(file, (*it)->path())
	&& writeTime(file, (*it)->lastModified())
	&& writeUTF8String(file, (*it)->name())
	&& writeUTF8String(file, (*it)->description())
	&& writeUTF8String(file, (*it)->fullMIMEDescription()))) {
	LOG_ERROR("Unable to write plugin metadata to cache");
	closeFile(file);
	deleteFile(absoluteCachePath);
	return;
	}
	}

	closeFile(file);
	}

	bool PluginDatabase::isPersistentMetadataCacheEnabled()
	{
	return gPersistentPluginMetadataCacheIsEnabled;
	}

	void PluginDatabase::setPersistentMetadataCacheEnabled(bool isEnabled)
	{
	gPersistentPluginMetadataCacheIsEnabled = isEnabled;
	}

	String PluginDatabase::persistentMetadataCachePath()
	{
	return WebCore::persistentPluginMetadataCachePath();
	}

	void PluginDatabase::setPersistentMetadataCachePath(const String& persistentMetadataCachePath)
	{
	WebCore::persistentPluginMetadataCachePath() = persistentMetadataCachePath;
	}
	#endif
	}