/*

 * 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>

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

    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)

    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

}