/*****************************************************************************

 * bank.c : Modules list

 *****************************************************************************

 * Copyright (C) 2001-2011 VLC authors and VideoLAN

 *

 * Authors: Sam Hocevar <sam@zoy.org>

 *          Ethan C. Baldridge <BaldridgeE@cadmus.com>

 *          Hans-Peter Jansen <hpj@urpla.net>

 *          Gildas Bazin <gbazin@videolan.org>

 *          Rémi Denis-Courmont

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms of the GNU Lesser General Public License as published by

 * the Free Software Foundation; either version 2.1 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * GNU Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.

 *****************************************************************************/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#ifdef HAVE_SEARCH_H

# include <search.h>

#endif

#include <vlc_common.h>

#include <vlc_plugin.h>

#include <vlc_modules.h>

#include <vlc_fs.h>

#include <vlc_block.h>

#include "../libvlc.h"

#include "config/configuration.h"

#include "modules/modules.h"

/** Core module */

VLC_DECL_MODULE_ENTRY(core);

typedef struct vlc_modcap

{

    char *name;

    module_t **modv;

    size_t modc;

} vlc_modcap_t;

static int vlc_modcap_cmp(const void *a, const void *b)

{

    const vlc_modcap_t *capa = a, *capb = b;

    return strcmp(capa->name, capb->name);

}

static void vlc_modcap_free(void *data)

{

    vlc_modcap_t *cap = data;

    free(cap->modv);

    free(cap->name);

    free(cap);

}

static int vlc_module_cmp (const void *a, const void *b)

{

    module_t *const *ma = a, *const *mb = b;

    /* Note that qsort() uses _ascending_ order,

     * so the smallest module is the one with the biggest score. */

    return (*mb)->i_score - (*ma)->i_score;

}

static void vlc_modcap_sort(const void *node, const VISIT which,

                            const int depth)

{

    vlc_modcap_t *const *cp = node, *cap = *cp;

    if (which != postorder && which != leaf)

        return;

    qsort(cap->modv, cap->modc, sizeof (*cap->modv), vlc_module_cmp);

    (void) depth;

}

static struct

{

    vlc_mutex_t lock;

    block_t *caches;

    void *caps_tree;

    size_t count;

    unsigned usage;

} modules = { VLC_STATIC_MUTEX, NULL, NULL, 0, 0 };

vlc_plugin_t *vlc_plugins = NULL;

/**

 * Adds a module to the bank

 */

static int vlc_module_store(module_t *mod)

{

    const char *name = module_get_capability(mod);

    vlc_modcap_t *cap = malloc(sizeof (*cap));

    if (unlikely(cap == NULL))

        return -1;

    cap->name = strdup(name);

    cap->modv = NULL;

    cap->modc = 0;

    if (unlikely(cap->name == NULL))

        goto error;

    void **cp = tsearch(cap, &modules.caps_tree, vlc_modcap_cmp);

    if (unlikely(cp == NULL))

        goto error;

    if (*cp != cap)

    {

        vlc_modcap_free(cap);

        cap = *cp;

    }

    module_t **modv = realloc(cap->modv, sizeof (*modv) * (cap->modc + 1));

    if (unlikely(modv == NULL))

        return -1;

    cap->modv = modv;

    cap->modv[cap->modc] = mod;

    cap->modc++;

    return 0;

error:

    vlc_modcap_free(cap);

    return -1;

}

/**

 * Adds a plugin (and all its modules) to the bank

 */

static void vlc_plugin_store(vlc_plugin_t *lib)

{

    vlc_mutex_assert(&modules.lock);

    lib->next = vlc_plugins;

    vlc_plugins = lib;

    modules.count += lib->modules_count;

    for (module_t *m = lib->module; m != NULL; m = m->next)

        vlc_module_store(m);

}

/**

 * Registers a statically-linked plug-in.

 */

static vlc_plugin_t *module_InitStatic(vlc_plugin_cb entry)

{

    /* Initializes the statically-linked library */

    vlc_plugin_t *lib = vlc_plugin_describe (entry);

    if (unlikely(lib == NULL))

        return NULL;

#ifdef HAVE_DYNAMIC_PLUGINS

    atomic_init(&lib->handle, 0);

    lib->unloadable = false;

#endif

    return lib;

}

/* With weak linking in __ELF__, there is no need to provide a definition

 * of vlc_static_modules at build time and it will be evaluated to NULL if

 * not provided at runtime. However, although __MACH__ implies the same runtime

 * consequences for weak linking, it will still require the definition to exist

 * at build time. To workaround this, we add -Wl,-U,vlc_static_modules. */

#if defined(__ELF__) \

    || (defined(__MACH__) && defined(HAVE_DYLIB_DYNAMIC_LOOKUP)) \

    || !defined(HAVE_DYNAMIC_PLUGINS)

VLC_WEAK

extern const vlc_plugin_cb vlc_static_modules[];

static void module_InitStaticModules(void)

{

    if (!vlc_static_modules)

        return;

    for (unsigned i = 0; vlc_static_modules[i]; i++)

    {

        vlc_plugin_t *lib = module_InitStatic(vlc_static_modules[i]);

        if (likely(lib != NULL))

            vlc_plugin_store(lib);

    }

}

#else

static void module_InitStaticModules(void) { }

#endif

#ifdef HAVE_DYNAMIC_PLUGINS

static const char *module_GetVersion(void *handle)

{

    const char *(*get_api_version)(void);

    get_api_version = vlc_dlsym(handle, "vlc_entry_api_version");

    if (get_api_version == NULL)

        return NULL;

    return get_api_version();

}

static void *module_Open(struct vlc_logger *log,

                         const char *path, bool fast)

{

    void *handle = vlc_dlopen(path, fast);

    if (handle == NULL)

    {

        char *errmsg = vlc_dlerror();

        vlc_error(log, "cannot load plug-in %s: %s", path,

                  errmsg ? errmsg : "unknown error");

        free(errmsg);

        return NULL;

    }

    const char *str = module_GetVersion(handle);

    if (str == NULL) {

        vlc_error(log, "cannot load plug-in %s: %s", path,

                  "unknown version or not a plug-in");

error:

        vlc_dlclose(handle);

        return NULL;

    }

    if (strcmp(str, VLC_API_VERSION_STRING)) {

        vlc_error(log, "cannot load plug-in %s: unsupported version %s", path,

                  str);

        goto error;

    }

    return handle;

}

/**

 * Loads a dynamically-linked plug-in into memory and initialize it.

 *

 * The module can then be handled by module_need() and module_unneed().

 *

 * \param path file path of the shared object

 * \param fast whether to optimize loading for speed or safety

 *             (fast is used when the plug-in is registered but not used)

 */

static vlc_plugin_t *module_InitDynamic(libvlc_int_t *obj, const char *path,

                                        bool fast)

{

    void *handle = module_Open(vlc_object_logger(obj), path, fast);

    if (handle == NULL)

        return NULL;

    /* Try to resolve the symbol */

    vlc_plugin_cb entry = vlc_dlsym(handle, "vlc_entry");

    if (entry == NULL)

    {

        msg_Warn (obj, "cannot find plug-in entry point in %s", path);

        goto error;

    }

    /* We can now try to call the symbol */

    vlc_plugin_t *plugin = vlc_plugin_describe(entry);

    if (unlikely(plugin == NULL))

    {

        /* With a well-written module we shouldn't have to print an

         * additional error message here, but just make sure. */

        msg_Err (obj, "cannot initialize plug-in %s", path);

        goto error;

    }

    atomic_init(&plugin->handle, (uintptr_t)handle);

    return plugin;

error:

    vlc_dlclose(handle);

    return NULL;

}

typedef enum

{

    CACHE_READ_FILE  = 0x1,

    CACHE_SCAN_DIR   = 0x2,

    CACHE_WRITE_FILE = 0x4,

} cache_mode_t;

typedef struct module_bank

{

    libvlc_int_t *obj;

    const char   *base;

    cache_mode_t  mode;

    size_t        size;

    vlc_plugin_t **plugins;

    vlc_plugin_t *cache;

} module_bank_t;

/**

 * Scans a plug-in from a file.

 */

static int AllocatePluginFile (module_bank_t *bank, const char *abspath,

                               const char *relpath, const struct stat *st)

{

    vlc_plugin_t *plugin = NULL;

    /* Check our plugins cache first then load plugin if needed */

    if (bank->mode & CACHE_READ_FILE)

    {

        plugin = vlc_cache_lookup(&bank->cache, relpath);

        if (plugin != NULL

         && (plugin->mtime != (int64_t)st->st_mtime

          || plugin->size != (uint64_t)st->st_size))

        {

            msg_Err(bank->obj, "stale plugins cache: modified %s",

                    plugin->abspath);

            vlc_plugin_destroy(plugin);

            plugin = NULL;

        }

    }

    if (plugin == NULL)

    {

        char *path = strdup(relpath);

        if (path == NULL)

            return -1;

        plugin = module_InitDynamic(bank->obj, abspath, true);

        if (plugin != NULL)

        {

            plugin->path = path;

            plugin->mtime = st->st_mtime;

            plugin->size = st->st_size;

        }

        else free(path);

    }

    if (plugin == NULL)

        return -1;

    vlc_plugin_store(plugin);

    if (bank->mode & CACHE_WRITE_FILE) /* Add entry to to-be-saved cache */

    {

        bank->plugins = xrealloc(bank->plugins,

                                 (bank->size + 1) * sizeof (vlc_plugin_t *));

        bank->plugins[bank->size] = plugin;

        bank->size++;

    }

    /* TODO: deal with errors */

    return  0;

}

#ifdef __APPLE__

/* Apple specific framework library browsing */

static int AllocatePluginFramework (module_bank_t *bank, const char *file,

                                    const char *relpath, const char *abspath)

{

    int i_ret = VLC_EGENERIC;

    size_t len_name = strlen (file);

    /* Skip frameworks not matching plugins naming conventions. */

    if (len_name < strlen("_plugin.framework")

      || strncmp(file + len_name - strlen("_plugin.framework"),

                 "_plugin", strlen("_plugin")) != 0)

    {

        /* The framework doesn't contain plugins, there's no need to

         * browse the rest of the framework folder. */

        return VLC_EGENERIC;

    }

    /* The framework is a plugin, extract the dylib from it. */

    int filename_len = len_name - strlen(".framework");

    char *framework_relpath = NULL, *framework_abspath = NULL;

    /* Compute absolute path */

    if (asprintf (&framework_abspath, "%s"DIR_SEP"%.*s",

                  abspath, filename_len, file) == -1)

    {

        framework_abspath = NULL;

        goto end;

    }

    struct stat framework_st;

    if (vlc_stat (framework_abspath, &framework_st) == -1

     || !S_ISREG (framework_st.st_mode))

        goto end;

    if (asprintf (&framework_relpath, "%s"DIR_SEP"%.*s",

                  relpath, filename_len, file) == -1)

        framework_relpath = NULL;

    i_ret = AllocatePluginFile (bank, framework_abspath, framework_relpath, &framework_st);

end:

    free(framework_relpath);

    free(framework_abspath);

    return i_ret;

}

#endif

/**

 * Recursively browses a directory to look for plug-ins.

 */

static void AllocatePluginDir (module_bank_t *bank, unsigned maxdepth,

                               const char *absdir, const char *reldir)

{

    if (maxdepth == 0)

        return;

    maxdepth--;

    vlc_DIR *dh = vlc_opendir (absdir);

    if (dh == NULL)

        return;

    /* Parse the directory and try to load all files it contains. */

    for (;;)

    {

        char *relpath = NULL, *abspath = NULL;

        const char *file = vlc_readdir (dh);

        if (file == NULL)

            break;

        /* Skip ".", ".." */

        if (!strcmp (file, ".") || !strcmp (file, ".."))

            continue;

        /* Compute path relative to plug-in base directory */

        if (reldir != NULL)

        {

            if (asprintf (&relpath, "%s"DIR_SEP"%s", reldir, file) == -1)

                relpath = NULL;

        }

        else

            relpath = strdup (file);

        if (unlikely(relpath == NULL))

            continue;

        /* Compute absolute path */

        if (asprintf (&abspath, "%s"DIR_SEP"%s", bank->base, relpath) == -1)

        {

            abspath = NULL;

            goto skip;

        }

        struct stat st;

        if (vlc_stat (abspath, &st) == -1)

            goto skip;

        if (S_ISREG (st.st_mode))

        {

            static const char prefix[] = "lib";

            static const char suffix[] = "_plugin"LIBEXT;

            size_t len = strlen (file);

#ifndef __OS2__

            /* Check that file matches the "lib*_plugin"LIBEXT pattern */

            if (len > strlen (suffix)

             && !strncmp (file, prefix, strlen (prefix))

             && !strcmp (file + len - strlen (suffix), suffix))

#else

            /* We load all the files ending with LIBEXT on OS/2,

             * because OS/2 has a 8.3 length limitation for DLL name */

            if (len > strlen (LIBEXT)

             && !strcasecmp (file + len - strlen (LIBEXT), LIBEXT))

#endif

                AllocatePluginFile (bank, abspath, relpath, &st);

        }

        else if (S_ISDIR (st.st_mode))

        {

#ifdef __APPLE__

            size_t len_name = strlen (file);

            const char *framework_extension =

                file + len_name - strlen(".framework");

            if (len_name > strlen(".framework")

             && strcmp(framework_extension, ".framework") == 0)

            {

                AllocatePluginFramework (bank, file, relpath, abspath);

                /* Don't browse framework directories. */

                goto skip;

            }

#endif

            /* Recurse into another directory */

            AllocatePluginDir (bank, maxdepth, abspath, relpath);

        }

    skip:

        free (relpath);

        free (abspath);

    }

    vlc_closedir (dh);

}

/**

 * Scans for plug-ins within a file system hierarchy.

 * \param path base directory to browse

 */

static void AllocatePluginPath(libvlc_int_t *obj, const char *path,

                               cache_mode_t mode)

{

    module_bank_t bank =

    {

        .obj = obj,

        .base = path,

        .mode = mode,

    };

    if (mode & CACHE_READ_FILE)

        bank.cache = vlc_cache_load(obj, path, &modules.caches);

    else

        msg_Dbg(bank.obj, "ignoring plugins cache file");

    if (mode & CACHE_SCAN_DIR)

    {

        msg_Dbg(obj, "recursively browsing `%s'", bank.base);

        /* Don't go deeper than 5 subdirectories */

        AllocatePluginDir(&bank, 5, path, NULL);

    }

    /* Deal with unmatched cache entries from cache file */

    while (bank.cache != NULL)

    {

        vlc_plugin_t *plugin = bank.cache;

        bank.cache = plugin->next;

        if (mode & CACHE_SCAN_DIR)

            vlc_plugin_destroy(plugin);

        else

            vlc_plugin_store(plugin);

    }

    if (mode & CACHE_WRITE_FILE)

        CacheSave(obj, path, bank.plugins, bank.size);

    free(bank.plugins);

}

#if defined(_WIN32)

# if !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)

#  define HAVE_FORCED_PLUGINS

# endif

#endif

/**

 * Enumerates all dynamic plug-ins that can be found.

 *

 * This function will recursively browse the default plug-ins directory and any

 * directory listed in the VLC_PLUGIN_PATH environment variable.

 * For performance reasons, a cache is normally used so that plug-in shared

 * objects do not need to loaded and linked into the process.

 */

static void AllocateAllPlugins (libvlc_int_t *p_this)

{

    char *paths;

    cache_mode_t mode = 0;

    if (var_InheritBool(p_this, "plugins-cache"))

        mode |= CACHE_READ_FILE;

    if (var_InheritBool(p_this, "plugins-scan"))

        mode |= CACHE_SCAN_DIR;

    if (var_InheritBool(p_this, "reset-plugins-cache"))

        mode = (mode | CACHE_WRITE_FILE) & ~CACHE_READ_FILE;

#ifdef HAVE_FORCED_PLUGINS

    /* Windows Store Apps can not load external plugins with absolute paths. */

    AllocatePluginPath (p_this, "plugins", mode);

#else

    /* Construct the special search path for system that have a relocatable

     * executable. Set it to <vlc path>/plugins. */

    char *vlcpath = config_GetSysPath(VLC_PKG_LIB_DIR, "plugins");

    if (likely(vlcpath != NULL))

    {

        AllocatePluginPath(p_this, vlcpath, mode);

        free(vlcpath);

    }

#endif

    /* If the user provided a plugin path, we add it to the list */

    paths = getenv( "VLC_PLUGIN_PATH" );

    if( paths == NULL )

        return;

#ifdef _WIN32

    paths = realpath( paths, NULL );

#else

    paths = strdup( paths ); /* don't harm the environment ! :) */

#endif

    if( unlikely(paths == NULL) )

        return;

    for( char *buf, *path = strtok_r( paths, PATH_SEP, &buf );

         path != NULL;

         path = strtok_r( NULL, PATH_SEP, &buf ) )

        AllocatePluginPath (p_this, path, mode);

    free( paths );

}

/**

 * Ensures that a plug-in is loaded.

 *

 * \note This function is thread-safe but not re-entrant.

 *

 * \return 0 on success, -1 on failure

 */

int vlc_plugin_Map(struct vlc_logger *log, vlc_plugin_t *plugin)

{

    static vlc_mutex_t lock = VLC_STATIC_MUTEX;

    if (plugin->abspath == NULL)

        return 0; /* static module needs not be mapped */

    if (atomic_load_explicit(&plugin->handle, memory_order_acquire))

        return 0; /* fast path: already loaded */

    /* Try to load the plug-in (without locks, so read-only) */

    assert(plugin->abspath != NULL);

    void *handle = module_Open(log, plugin->abspath, false);

    if (handle == NULL)

        return -1;

    vlc_plugin_cb entry = vlc_dlsym(handle, "vlc_entry");

    if (entry == NULL)

    {

        vlc_error(log, "cannot find plug-in entry point in %s",

                  plugin->abspath);

        goto error;

    }

    vlc_mutex_lock(&lock);

    if (atomic_load_explicit(&plugin->handle, memory_order_relaxed) == 0)

    {   /* Lock is held, update the plug-in structure */

        if (vlc_plugin_resolve(plugin, entry))

        {

            vlc_mutex_unlock(&lock);

            goto error;

        }

        atomic_store_explicit(&plugin->handle, (uintptr_t)handle,

                              memory_order_release);

    }

    else /* Another thread won the race to load the plugin */

        vlc_dlclose(handle);

    vlc_mutex_unlock(&lock);

    return 0;

error:

    vlc_dlclose(handle);

    return -1;

}

/**

 * Ensures that a module is not loaded.

 *

 * \note This function is not thread-safe. The caller must ensure that the

 * plug-in is no longer used before calling this function.

 */

static void vlc_plugin_Unmap(vlc_plugin_t *plugin)

{

    if (!plugin->unloadable)

        return;

    void *handle = (void *)atomic_exchange_explicit(&plugin->handle, 0,

                                                    memory_order_acquire);

    if (handle != NULL)

        vlc_dlclose(handle);

}

void *vlc_plugin_Symbol(struct vlc_logger *log,

                        vlc_plugin_t *plugin, const char *name)

{

    if (plugin->abspath == NULL || vlc_plugin_Map(log, plugin))

        return NULL;

    void *handle = (void *)atomic_load_explicit(&plugin->handle,

                                                memory_order_relaxed);

    assert(handle != NULL);

    return vlc_dlsym(handle, name);

}

#else

int vlc_plugin_Map(struct vlc_logger *log, vlc_plugin_t *plugin)

{

    (void) log; (void) plugin;

    return 0;

}

static void vlc_plugin_Unmap(vlc_plugin_t *plugin)

{

    (void) plugin;

}

void *vlc_plugin_Symbol(struct vlc_logger *log,

                        vlc_plugin_t *plugin, const char *name)

{

    (void) log; (void) plugin; (void) name;

    return NULL;

}

#endif /* HAVE_DYNAMIC_PLUGINS */

/**

 * Init bank

 *

 * Creates a module bank structure which will be filled later

 * on with all the modules found.

 */

void module_InitBank (void)

{

    vlc_mutex_lock (&modules.lock);

    if (modules.usage == 0)

    {

        /* Fills the module bank structure with the core module infos.

         * This is very useful as it will allow us to consider the core

         * library just as another module, and for instance the configuration

         * options of core will be available in the module bank structure just

         * as for every other module. */

        vlc_plugin_t *plugin = module_InitStatic(VLC_MODULE_ENTRY(core));

        if (likely(plugin != NULL))

            vlc_plugin_store(plugin);

        config_SortConfig ();

    }

    modules.usage++;

    /* We do retain the module bank lock until the plugins are loaded as well.

     * This is ugly, this staged loading approach is needed: LibVLC gets

     * some configuration parameters relevant to loading the plugins from

     * the core (builtin) module. The module bank becomes shared read-only data

     * once it is ready, so we need to fully serialize initialization.

     * DO NOT UNCOMMENT the following line unless you managed to squeeze

     * module_LoadPlugins() before you unlock the mutex. */

    /*vlc_mutex_unlock (&modules.lock);*/

}

/**

 * Unloads all unused plugin modules and empties the module

 * bank in case of success.

 */

void module_EndBank (bool b_plugins)

{

    vlc_plugin_t *libs = NULL;

    block_t *caches = NULL;

    void *caps_tree = NULL;

    /* If plugins were _not_ loaded, then the caller still has the bank lock

     * from module_InitBank(). */

    if( b_plugins )

        vlc_mutex_lock (&modules.lock);

    else

        vlc_mutex_assert(&modules.lock);

    assert (modules.usage > 0);

    if (--modules.usage == 0)

    {

        config_UnsortConfig ();

        libs = vlc_plugins;

        caches = modules.caches;

        caps_tree = modules.caps_tree;

        vlc_plugins = NULL;

        modules.caches = NULL;

        modules.caps_tree = NULL;

        modules.count = 0;

    }

    vlc_mutex_unlock (&modules.lock);

    tdestroy(caps_tree, vlc_modcap_free);

    while (libs != NULL)

    {

        vlc_plugin_t *lib = libs;

        libs = lib->next;

        vlc_plugin_Unmap(lib);

        vlc_plugin_destroy(lib);

    }

    block_ChainRelease(caches);

}

/**

 * Loads module descriptions for all available plugins.

 * Fills the module bank structure with the plugin modules.

 *

 * \param obj vlc object structure

 */

void module_LoadPlugins(libvlc_int_t *obj)

{

    /*vlc_mutex_assert (&modules.lock); not for static mutexes :( */

    if (modules.usage == 1)

    {

        module_InitStaticModules ();

#ifdef HAVE_DYNAMIC_PLUGINS

        msg_Dbg (obj, "searching plug-in modules");

        AllocateAllPlugins (obj);

#endif

        config_UnsortConfig ();

        config_SortConfig ();

        twalk(modules.caps_tree, vlc_modcap_sort);

    }

    vlc_mutex_unlock (&modules.lock);

    msg_Dbg (obj, "plug-ins loaded: %zu modules", modules.count);

}

void module_list_free (module_t **list)

{

    free (list);

}

module_t **module_list_get (size_t *n)

{

    assert (n != NULL);

    *n = modules.count;

    if (unlikely(modules.count == 0))

        return NULL;

    module_t **tab = malloc(modules.count * sizeof(*tab));

    if (unlikely(tab == NULL))

        return NULL;

    size_t i = 0;

    for (vlc_plugin_t *lib = vlc_plugins; lib != NULL; lib = lib->next)

    {

        for (module_t *m = lib->module; m != NULL; m = m->next)

        {

            assert(i < modules.count);

            tab[i++] = m;

        }

    }

    return tab;

}

size_t module_list_cap(module_t *const **restrict list, const char *name)

{

    vlc_modcap_t key;

    assert(name != NULL);

    key.name = (char *)name;

    const void **cp = tfind(&key, &modules.caps_tree, vlc_modcap_cmp);

    if (cp == NULL)

    {

        *list = NULL;

        return 0;

    }

    const vlc_modcap_t *cap = *cp;

    *list = cap->modv;

    return cap->modc;

}