X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmodules%2Fmodules.c;h=846b804dc5a48bbce69510bc36ea9f916702a9ae;hb=553fa2da4ecc8a55cbaaefdc6ad4ed2b3eb7f48f;hp=ec4fa311cdb0deb974069bce38b9876e0b2d13d8;hpb=52943ce6dcaa19e2924846d2225176375f49b2c8;p=vlc diff --git a/src/modules/modules.c b/src/modules/modules.c index ec4fa311cd..846b804dc5 100644 --- a/src/modules/modules.c +++ b/src/modules/modules.c @@ -1,13 +1,14 @@ /***************************************************************************** * modules.c : Builtin and plugin modules management functions ***************************************************************************** - * Copyright (C) 2001-2007 the VideoLAN team + * Copyright (C) 2001-2011 the VideoLAN team * $Id$ * * Authors: Sam Hocevar * Ethan C. Baldridge * Hans-Peter Jansen * Gildas Bazin + * Rémi Denis-Courmont * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -28,222 +29,20 @@ # include "config.h" #endif -#include -#include -#include -#include "libvlc.h" - -#include /* free(), strtol() */ -#include /* sprintf() */ -#include /* strdup() */ -#include - -#ifdef HAVE_DIRENT_H -# include -#endif - -#ifdef HAVE_SYS_TYPES_H -# include -#endif -#ifdef HAVE_SYS_STAT_H -# include -#endif -#ifdef HAVE_UNISTD_H -# include -#endif - -#if !defined(HAVE_DYNAMIC_PLUGINS) - /* no support for plugins */ -#elif defined(HAVE_DL_DYLD) -# if defined(HAVE_MACH_O_DYLD_H) -# include -# endif -#elif defined(HAVE_DL_BEOS) -# if defined(HAVE_IMAGE_H) -# include -# endif -#elif defined(HAVE_DL_WINDOWS) -# include -#elif defined(HAVE_DL_DLOPEN) -# if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */ -# include -# endif -# if defined(HAVE_SYS_DL_H) -# include -# endif -#elif defined(HAVE_DL_SHL_LOAD) -# if defined(HAVE_DL_H) -# include -# endif +#include +#include +#ifdef ENABLE_NLS +# include #endif +#include +#include +#include +#include "libvlc.h" #include "config/configuration.h" - -#include "vlc_charset.h" #include "vlc_arrays.h" -#include - #include "modules/modules.h" -static module_bank_t *p_module_bank = NULL; -static vlc_mutex_t module_lock = VLC_STATIC_MUTEX; - -int vlc_entry__main( module_t * ); - -/***************************************************************************** - * Local prototypes - *****************************************************************************/ -#ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( vlc_object_t *, module_bank_t * ); -static void AllocatePluginDir( vlc_object_t *, module_bank_t *, const char *, - unsigned ); -static int AllocatePluginFile( vlc_object_t *, module_bank_t *, const char *, - int64_t, int64_t ); -static module_t * AllocatePlugin( vlc_object_t *, const char * ); -#endif -static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); -static void DeleteModule ( module_bank_t *, module_t * ); -#ifdef HAVE_DYNAMIC_PLUGINS -static void DupModule ( module_t * ); -static void UndupModule ( module_t * ); -#endif - -/** - * Init bank - * - * Creates a module bank structure which will be filled later - * on with all the modules found. - * \param p_this vlc object structure - * \return nothing - */ -void __module_InitBank( vlc_object_t *p_this ) -{ - module_bank_t *p_bank = NULL; - - vlc_mutex_lock( &module_lock ); - - if( p_module_bank == NULL ) - { - p_bank = calloc (1, sizeof(*p_bank)); - p_bank->i_usage = 1; - p_bank->i_cache = p_bank->i_loaded_cache = 0; - p_bank->pp_cache = p_bank->pp_loaded_cache = NULL; - p_bank->b_cache = p_bank->b_cache_dirty = false; - p_bank->head = NULL; - - /* Everything worked, attach the object */ - p_module_bank = p_bank; - - /* Fills the module bank structure with the main module infos. - * This is very useful as it will allow us to consider the main - * library just as another module, and for instance the configuration - * options of main will be available in the module bank structure just - * as for every other module. */ - AllocateBuiltinModule( p_this, vlc_entry__main ); - } - else - p_module_bank->i_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 main (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( &module_lock );*/ -} - -#undef module_EndBank -/** - * Unloads all unused plugin modules and empties the module - * bank in case of success. - * \param p_this vlc object structure - * \return nothing - */ -void module_EndBank( vlc_object_t *p_this, bool b_plugins ) -{ - module_bank_t *p_bank = p_module_bank; - - assert (p_bank != NULL); - - /* Save the configuration */ - if( !config_GetInt( p_this, "ignore-config" ) ) - config_AutoSaveConfigFile( p_this ); - - /* If plugins were _not_ loaded, then the caller still has the bank lock - * from module_InitBank(). */ - if( b_plugins ) - vlc_mutex_lock( &module_lock ); - /*else - vlc_assert_locked( &module_lock ); not for static mutexes :( */ - - if( --p_bank->i_usage > 0 ) - { - vlc_mutex_unlock( &module_lock ); - return; - } - p_module_bank = NULL; - vlc_mutex_unlock( &module_lock ); - -#ifdef HAVE_DYNAMIC_PLUGINS - if( p_bank->b_cache ) - CacheSave( p_this, p_bank ); - while( p_bank->i_loaded_cache-- ) - { - if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ) - { - DeleteModule( p_bank, - p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module ); - free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file ); - free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ); - } - } - free( p_bank->pp_loaded_cache ); - while( p_bank->i_cache-- ) - { - free( p_bank->pp_cache[p_bank->i_cache]->psz_file ); - free( p_bank->pp_cache[p_bank->i_cache] ); - } - free( p_bank->pp_cache ); -#endif - - while( p_bank->head != NULL ) - DeleteModule( p_bank, p_bank->head ); - - free( p_bank ); -} - -#undef module_LoadPlugins -/** - * Loads module descriptions for all available plugins. - * Fills the module bank structure with the plugin modules. - * - * \param p_this vlc object structure - * \return nothing - */ -void module_LoadPlugins( vlc_object_t * p_this, bool b_cache_delete ) -{ - module_bank_t *p_bank = p_module_bank; - - assert( p_bank ); - /*vlc_assert_locked( &module_lock ); not for static mutexes :( */ - -#ifdef HAVE_DYNAMIC_PLUGINS - if( p_bank->i_usage == 1 ) - { - msg_Dbg( p_this, "checking plugin modules" ); - p_module_bank->b_cache = config_GetInt( p_this, "plugins-cache" ) > 0; - - if( p_module_bank->b_cache || b_cache_delete ) - CacheLoad( p_this, p_module_bank, b_cache_delete ); - AllocateAllPlugins( p_this, p_module_bank ); - } -#endif - p_module_bank->b_plugins = true; - vlc_mutex_unlock( &module_lock ); -} - /** * Checks whether a module implements a capability. * @@ -253,6 +52,8 @@ void module_LoadPlugins( vlc_object_t * p_this, bool b_cache_delete ) */ bool module_provides( const module_t *m, const char *cap ) { + if (unlikely(m->psz_capability == NULL)) + return false; return !strcmp( m->psz_capability, cap ); } @@ -264,7 +65,9 @@ bool module_provides( const module_t *m, const char *cap ) */ const char *module_get_object( const module_t *m ) { - return m->psz_object_name; + if (unlikely(m->i_shortcuts == 0)) + return "unnamed"; + return m->pp_shortcuts[0]; } /** @@ -279,7 +82,9 @@ const char *module_get_name( const module_t *m, bool long_name ) if( long_name && ( m->psz_longname != NULL) ) return m->psz_longname; - return m->psz_shortname ? m->psz_shortname : m->psz_object_name; + if (m->psz_shortname != NULL) + return m->psz_shortname; + return module_get_object (m); } /** @@ -315,66 +120,43 @@ int module_get_score( const module_t *m ) return m->i_score; } -module_t *module_hold (module_t *m) -{ - vlc_hold (&m->vlc_gc_data); - return m; -} - -void module_release (module_t *m) +/** + * Translate a string using the module's text domain + * + * \param m the module + * \param str the American English ASCII string to localize + * \return the gettext-translated string + */ +const char *module_gettext (const module_t *m, const char *str) { - vlc_release (&m->vlc_gc_data); + if (m->parent != NULL) + m = m->parent; + if (unlikely(str == NULL || *str == '\0')) + return ""; +#ifdef ENABLE_NLS + const char *domain = m->domain; + return dgettext ((domain != NULL) ? domain : PACKAGE_NAME, str); +#else + (void)m; + return str; +#endif } -/** - * Frees the flat list of VLC modules. - * @param list list obtained by module_list_get() - * @param length number of items on the list - * @return nothing. - */ -void module_list_free (module_t **list) +#undef module_start +int module_start (vlc_object_t *obj, const module_t *m) { - if (list == NULL) - return; + int (*activate) (vlc_object_t *) = m->pf_activate; - for (size_t i = 0; list[i] != NULL; i++) - module_release (list[i]); - free (list); + return (activate != NULL) ? activate (obj) : VLC_SUCCESS; } -/** - * Gets the flat list of VLC modules. - * @param n [OUT] pointer to the number of modules or NULL - * @return NULL-terminated table of module pointers - * (release with module_list_free()), or NULL in case of error. - */ -module_t **module_list_get (size_t *n) +#undef module_stop +void module_stop (vlc_object_t *obj, const module_t *m) { - /* TODO: this whole module lookup is quite inefficient */ - /* Remove this and improve module_need */ - module_t **tab = NULL; - size_t i = 0; + void (*deactivate) (vlc_object_t *) = m->pf_deactivate; - assert (p_module_bank); - for (module_t *mod = p_module_bank->head; mod; mod = mod->next) - { - module_t **nt; - nt = realloc (tab, (i + 2 + mod->submodule_count) * sizeof (*tab)); - if (nt == NULL) - { - module_list_free (tab); - return NULL; - } - - tab = nt; - tab[i++] = module_hold (mod); - for (module_t *subm = mod->submodule; subm; subm = subm->next) - tab[i++] = module_hold (subm); - tab[i] = NULL; - } - if (n != NULL) - *n = i; - return tab; + if (deactivate != NULL) + deactivate (obj); } typedef struct module_list_t @@ -392,20 +174,30 @@ static int modulecmp (const void *a, const void *b) return lb->i_score - la->i_score; } +#undef vlc_module_load /** - * module Need + * Finds and instantiates the best module of a certain type. + * All candidates modules having the specified capability and name will be + * sorted in decreasing order of priority. Then the probe callback will be + * invoked for each module, until it succeeds (returns 0), or all candidate + * module failed to initialize. * - * Return the best module function, given a capability list. + * The probe callback first parameter is the address of the module entry point. + * Further parameters are passed as an argument list; it corresponds to the + * variable arguments passed to this function. This scheme is meant to + * support arbitrary prototypes for the module entry point. * - * \param p_this the vlc object - * \param psz_capability list of capabilities needed - * \param psz_name name of the module asked + * \param p_this VLC object + * \param psz_capability capability, i.e. class of module + * \param psz_name name name of the module asked, if any * \param b_strict if true, do not fallback to plugin with a different name * but the same capability + * \param probe module probe callback * \return the module or NULL in case of a failure */ -module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, - const char *psz_name, bool b_strict ) +module_t *vlc_module_load(vlc_object_t *p_this, const char *psz_capability, + const char *psz_name, bool b_strict, + vlc_activate_t probe, ...) { stats_TimerStart( p_this, "module_need()", STATS_TIMER_MODULE_NEED ); @@ -466,7 +258,6 @@ module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, size_t count; module_t **p_all = module_list_get (&count); p_list = malloc( count * sizeof( module_list_t ) ); - unsigned i_cpu = vlc_CPU(); /* Parse the module list for capabilities and probe each of them */ count = 0; @@ -477,9 +268,6 @@ module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, /* Test that this module can do what we need */ if( !module_provides( p_module, psz_capability ) ) continue; - /* Test if we have the required CPU */ - if( (p_module->i_cpu & i_cpu) != p_module->i_cpu ) - continue; /* If we required a shortcut, check this plugin provides it. */ if( i_shortcuts > 0 ) @@ -488,7 +276,7 @@ module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- ) { - for( unsigned i = 0; p_module->pp_shortcuts[i]; i++ ) + for( unsigned i = 0; i < p_module->i_shortcuts; i++ ) { char *c; if( ( c = strchr( name, '@' ) ) @@ -521,7 +309,7 @@ module_t * __module_need( vlc_object_t *p_this, const char *psz_capability, found_shortcut: /* Store this new module */ - p_list[count].p_module = module_hold (p_module); + p_list[count].p_module = p_module; p_list[count].i_score = p_module->i_score + i_shortcut_bonus; p_list[count].b_force = i_shortcut_bonus && b_strict; count++; @@ -536,35 +324,33 @@ found_shortcut: count, count == 1 ? "" : "s" ); /* Parse the linked list and use the first successful module */ + va_list args; + + va_start(args, probe); p_module = NULL; + for (size_t i = 0; (i < count) && (p_module == NULL); i++) { module_t *p_cand = p_list[i].p_module; -#ifdef HAVE_DYNAMIC_PLUGINS - /* Make sure the module is loaded in mem */ - module_t *p_real = p_cand->b_submodule ? p_cand->parent : p_cand; - if( !p_real->b_builtin && !p_real->b_loaded ) + if (module_Map (p_this, p_cand)) + continue; + p_this->b_force = p_list[i].b_force; + + int ret; + + if (likely(p_cand->pf_activate != NULL)) { - module_t *p_new_module = - AllocatePlugin( p_this, p_real->psz_filename ); - if( p_new_module == NULL ) - { /* Corrupted module */ - msg_Err( p_this, "possibly corrupt module cache" ); - module_release( p_cand ); - continue; - } - CacheMerge( p_this, p_real, p_new_module ); - DeleteModule( p_module_bank, p_new_module ); - } -#endif + va_list ap; - p_this->b_force = p_list[i].b_force; + va_copy(ap, args); + ret = probe(p_cand->pf_activate, ap); + va_end(ap); + } + else + ret = VLC_SUCCESS; - int ret = VLC_SUCCESS; - if( p_cand->pf_activate ) - ret = p_cand->pf_activate( p_this ); - switch( ret ) + switch (ret) { case VLC_SUCCESS: /* good module! */ @@ -573,54 +359,30 @@ found_shortcut: case VLC_ETIMEOUT: /* good module, but aborted */ - module_release( p_cand ); break; default: /* bad module */ - module_release( p_cand ); continue; } - - /* Release the remaining modules */ - while (++i < count) - module_release (p_list[i].p_module); } + va_end (args); free( p_list ); p_this->b_force = b_force_backup; if( p_module != NULL ) { msg_Dbg( p_this, "using %s module \"%s\"", - psz_capability, p_module->psz_object_name ); + psz_capability, module_get_object(p_module) ); vlc_object_set_name( p_this, psz_alias ? psz_alias - : p_module->psz_object_name ); + : module_get_object(p_module) ); } else if( count == 0 ) - { - if( !strcmp( psz_capability, "access_demux" ) - || !strcmp( psz_capability, "stream_filter" ) - || !strcmp( psz_capability, "vout_window" ) ) - { - msg_Dbg( p_this, "no %s module matched \"%s\"", - psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); - } - else - { - msg_Err( p_this, "no %s module matched \"%s\"", - psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); - - msg_StackSet( VLC_EGENERIC, "no %s module matched \"%s\"", + msg_Dbg( p_this, "no %s module matched \"%s\"", psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); - } - } - else if( psz_name != NULL && *psz_name ) - { - msg_Warn( p_this, "no %s module matching \"%s\" could be loaded", - psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); - } else - msg_StackSet( VLC_EGENERIC, "no suitable %s module", psz_capability ); + msg_Dbg( p_this, "no %s module matching \"%s\" could be loaded", + psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); free( psz_shortcuts ); free( psz_var ); @@ -633,51 +395,76 @@ found_shortcut: return p_module; } + /** - * Module unneed - * - * This function must be called by the thread that called module_need, to - * decrease the reference count and allow for hiding of modules. - * \param p_this vlc object structure - * \param p_module the module structure - * \return nothing + * Deinstantiates a module. + * \param module the module pointer as returned by vlc_module_load() + * \param deinit deactivation callback */ -void __module_unneed( vlc_object_t * p_this, module_t * p_module ) +void vlc_module_unload(module_t *module, vlc_deactivate_t deinit, ...) { - /* Use the close method */ - if( p_module->pf_deactivate ) + if (module->pf_deactivate != NULL) { - p_module->pf_deactivate( p_this ); + va_list ap; + + va_start(ap, deinit); + deinit(module->pf_deactivate, ap); + va_end(ap); } +} + + +static int generic_start(void *func, va_list ap) +{ + vlc_object_t *obj = va_arg(ap, vlc_object_t *); + int (*activate)(vlc_object_t *) = func; + + return activate(obj); +} + +static void generic_stop(void *func, va_list ap) +{ + vlc_object_t *obj = va_arg(ap, vlc_object_t *); + void (*deactivate)(vlc_object_t *) = func; + + deactivate(obj); +} - msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name ); +#undef module_need +module_t *module_need(vlc_object_t *obj, const char *cap, const char *name, + bool strict) +{ + return vlc_module_load(obj, cap, name, strict, generic_start, obj); +} - module_release( p_module ); +#undef module_unneed +void module_unneed(vlc_object_t *obj, module_t *module) +{ + msg_Dbg(obj, "removing module \"%s\"", module_get_object(module)); + vlc_module_unload(module, generic_stop, obj); } /** * Get a pointer to a module_t given it's name. * - * \param psz_name the name of the module + * \param name the name of the module * \return a pointer to the module or NULL in case of a failure */ -module_t *module_find( const char * psz_name ) +module_t *module_find (const char *name) { module_t **list, *module; + assert (name != NULL); list = module_list_get (NULL); if (!list) return NULL; for (size_t i = 0; (module = list[i]) != NULL; i++) { - const char *psz_module_name = module->psz_object_name; - - if( psz_module_name && !strcmp( psz_module_name, psz_name ) ) - { - module_hold (module); + if (unlikely(module->i_shortcuts == 0)) + continue; + if (!strcmp (module->pp_shortcuts[0], name)) break; - } } module_list_free (list); return module; @@ -691,10 +478,7 @@ module_t *module_find( const char * psz_name ) */ bool module_exists (const char * psz_name) { - module_t *p_module = module_find (psz_name); - if( p_module ) - module_release (p_module); - return p_module != NULL; + return module_find (psz_name) != NULL; } /** @@ -715,18 +499,9 @@ module_t *module_find_by_shortcut (const char *psz_shortcut) return NULL; for (size_t i = 0; (module = list[i]) != NULL; i++) - { - for (size_t j = 0; - (module->pp_shortcuts[j] != NULL) && (j < MODULE_SHORTCUT_MAX); - j++) - { + for (size_t j = 0; j < module->i_shortcuts; j++) if (!strcmp (module->pp_shortcuts[j], psz_shortcut)) - { - module_hold (module); goto out; - } - } - } out: module_list_free (list); return module; @@ -755,7 +530,6 @@ module_config_t *module_config_get( const module_t *module, unsigned *restrict p { const module_config_t *item = module->p_config + i; if( item->b_internal /* internal option */ - || item->b_unsaveable /* non-modifiable option */ || item->b_removed /* removed option */ ) continue; @@ -777,425 +551,3 @@ void module_config_free( module_config_t *config ) { free( config ); } - -/***************************************************************************** - * Following functions are local. - *****************************************************************************/ - - /***************************************************************************** - * copy_next_paths_token: from a PATH_SEP_CHAR (a ':' or a ';') separated paths - * return first path. - *****************************************************************************/ -static char * copy_next_paths_token( char * paths, char ** remaining_paths ) -{ - char * path; - int i, done; - bool escaped = false; - - assert( paths ); - - /* Alloc a buffer to store the path */ - path = malloc( strlen( paths ) + 1 ); - if( !path ) return NULL; - - /* Look for PATH_SEP_CHAR (a ':' or a ';') */ - for( i = 0, done = 0 ; paths[i]; i++ ) - { - /* Take care of \\ and \: or \; escapement */ - if( escaped ) - { - escaped = false; - path[done++] = paths[i]; - } -#ifdef WIN32 - else if( paths[i] == '/' ) - escaped = true; -#else - else if( paths[i] == '\\' ) - escaped = true; -#endif - else if( paths[i] == PATH_SEP_CHAR ) - break; - else - path[done++] = paths[i]; - } - path[done] = 0; - - /* Return the remaining paths */ - if( remaining_paths ) { - *remaining_paths = paths[i] ? &paths[i]+1 : NULL; - } - - return path; -} - -char *psz_vlcpath = NULL; - -/***************************************************************************** - * AllocateAllPlugins: load all plugin modules we can find. - *****************************************************************************/ -#ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( vlc_object_t *p_this, module_bank_t *p_bank ) -{ - const char *vlcpath = psz_vlcpath; - int count,i; - char * path; - vlc_array_t *arraypaths = vlc_array_new(); - - /* Contruct the special search path for system that have a relocatable - * executable. Set it to /modules and /plugins. */ - - if( vlcpath && asprintf( &path, "%s" DIR_SEP "modules", vlcpath ) != -1 ) - vlc_array_append( arraypaths, path ); - if( vlcpath && asprintf( &path, "%s" DIR_SEP "plugins", vlcpath ) != -1 ) - vlc_array_append( arraypaths, path ); -#ifndef WIN32 - vlc_array_append( arraypaths, strdup( PLUGIN_PATH ) ); -#endif - - /* If the user provided a plugin path, we add it to the list */ - char *userpaths = config_GetPsz( p_this, "plugin-path" ); - char *paths_iter; - - for( paths_iter = userpaths; paths_iter; ) - { - path = copy_next_paths_token( paths_iter, &paths_iter ); - if( path ) - vlc_array_append( arraypaths, path ); - } - - count = vlc_array_count( arraypaths ); - for( i = 0 ; i < count ; i++ ) - { - path = vlc_array_item_at_index( arraypaths, i ); - if( !path ) - continue; - - msg_Dbg( p_this, "recursively browsing `%s'", path ); - - /* Don't go deeper than 5 subdirectories */ - AllocatePluginDir( p_this, p_bank, path, 5 ); - - free( path ); - } - - vlc_array_destroy( arraypaths ); - free( userpaths ); -} - -/***************************************************************************** - * AllocatePluginDir: recursively parse a directory to look for plugins - *****************************************************************************/ -static void AllocatePluginDir( vlc_object_t *p_this, module_bank_t *p_bank, - const char *psz_dir, unsigned i_maxdepth ) -{ - if( i_maxdepth == 0 ) - return; - - DIR *dh = utf8_opendir (psz_dir); - if (dh == NULL) - return; - - /* Parse the directory and try to load all files it contains. */ - for (;;) - { - char *file = utf8_readdir (dh), *path; - struct stat st; - - if (file == NULL) - break; - - /* Skip ".", ".." */ - if (!strcmp (file, ".") || !strcmp (file, "..") - /* Skip directories for unsupported optimizations */ - || !vlc_CPU_CheckPluginDir (file)) - { - free (file); - continue; - } - - const int pathlen = asprintf (&path, "%s"DIR_SEP"%s", psz_dir, file); - free (file); - if (pathlen == -1 || utf8_stat (path, &st)) - continue; - - if (S_ISDIR (st.st_mode)) - /* Recurse into another directory */ - AllocatePluginDir (p_this, p_bank, path, i_maxdepth - 1); - else - if (S_ISREG (st.st_mode) - && ((size_t)pathlen >= strlen (LIBEXT)) - && !strncasecmp (path + pathlen - strlen (LIBEXT), LIBEXT, - strlen (LIBEXT))) - /* ^^ We only load files ending with LIBEXT */ - AllocatePluginFile (p_this, p_bank, path, st.st_mtime, st.st_size); - - free (path); - } - closedir (dh); -} - -/***************************************************************************** - * AllocatePluginFile: load a module into memory and initialize it. - ***************************************************************************** - * This function loads a dynamically loadable module and allocates a structure - * for its information data. The module can then be handled by module_need - * and module_unneed. It can be removed by DeleteModule. - *****************************************************************************/ -static int AllocatePluginFile( vlc_object_t * p_this, module_bank_t *p_bank, - const char *psz_file, - int64_t i_file_time, int64_t i_file_size ) -{ - module_t * p_module = NULL; - module_cache_t *p_cache_entry = NULL; - - /* - * Check our plugins cache first then load plugin if needed - */ - p_cache_entry = CacheFind( p_bank, psz_file, i_file_time, i_file_size ); - if( !p_cache_entry ) - { - p_module = AllocatePlugin( p_this, psz_file ); - } - else - /* If junk dll, don't try to load it */ - if( p_cache_entry->b_junk ) - return -1; - else - { - module_config_t *p_item = NULL, *p_end = NULL; - - p_module = p_cache_entry->p_module; - p_module->b_loaded = false; - - /* For now we force loading if the module's config contains - * callbacks or actions. - * Could be optimized by adding an API call.*/ - for( p_item = p_module->p_config, p_end = p_item + p_module->confsize; - p_item < p_end; p_item++ ) - { - if( p_item->pf_callback || p_item->i_action ) - { - p_module = AllocatePlugin( p_this, psz_file ); - break; - } - } - if( p_module == p_cache_entry->p_module ) - p_cache_entry->b_used = true; - } - - if( p_module == NULL ) - return -1; - - /* Everything worked fine ! - * The module is ready to be added to the list. */ - p_module->b_builtin = false; - - /* msg_Dbg( p_this, "plugin \"%s\", %s", - p_module->psz_object_name, p_module->psz_longname ); */ - p_module->next = p_bank->head; - p_bank->head = p_module; - - if( !p_module_bank->b_cache ) - return 0; - - /* Add entry to cache */ - module_cache_t **pp_cache = p_bank->pp_cache; - - pp_cache = realloc_or_free( pp_cache, (p_bank->i_cache + 1) * sizeof(void *) ); - if( pp_cache == NULL ) - return -1; - pp_cache[p_bank->i_cache] = malloc( sizeof(module_cache_t) ); - if( pp_cache[p_bank->i_cache] == NULL ) - return -1; - pp_cache[p_bank->i_cache]->psz_file = strdup( psz_file ); - pp_cache[p_bank->i_cache]->i_time = i_file_time; - pp_cache[p_bank->i_cache]->i_size = i_file_size; - pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1; - pp_cache[p_bank->i_cache]->b_used = true; - pp_cache[p_bank->i_cache]->p_module = p_module; - p_bank->pp_cache = pp_cache; - p_bank->i_cache++; - return 0; -} - -/***************************************************************************** - * AllocatePlugin: load a module into memory and initialize it. - ***************************************************************************** - * This function loads a dynamically loadable module and allocates a structure - * for its information data. The module can then be handled by module_need - * and module_unneed. It can be removed by DeleteModule. - *****************************************************************************/ -static module_t * AllocatePlugin( vlc_object_t * p_this, const char *psz_file ) -{ - module_t * p_module = NULL; - module_handle_t handle; - - if( module_Load( p_this, psz_file, &handle ) ) - return NULL; - - /* Now that we have successfully loaded the module, we can - * allocate a structure for it */ - p_module = vlc_module_create( p_this ); - if( p_module == NULL ) - { - module_Unload( handle ); - return NULL; - } - - p_module->psz_filename = strdup( psz_file ); - p_module->handle = handle; - p_module->b_loaded = true; - - /* Initialize the module: fill p_module, default config */ - if( module_Call( p_this, p_module ) != 0 ) - { - /* We couldn't call module_init() */ - free( p_module->psz_filename ); - module_release( p_module ); - module_Unload( handle ); - return NULL; - } - - DupModule( p_module ); - - /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = false; - - return p_module; -} - -/***************************************************************************** - * DupModule: make a plugin module standalone. - ***************************************************************************** - * This function duplicates all strings in the module, so that the dynamic - * object can be unloaded. It acts recursively on submodules. - *****************************************************************************/ -static void DupModule( module_t *p_module ) -{ - char **pp_shortcut; - - for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) - { - *pp_shortcut = strdup( *pp_shortcut ); - } - - /* We strdup() these entries so that they are still valid when the - * module is unloaded. */ - p_module->psz_capability = strdup( p_module->psz_capability ); - p_module->psz_shortname = p_module->psz_shortname ? - strdup( p_module->psz_shortname ) : NULL; - p_module->psz_longname = strdup( p_module->psz_longname ); - p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help ) - : NULL; - - for (module_t *subm = p_module->submodule; subm; subm = subm->next) - DupModule (subm); -} - -/***************************************************************************** - * UndupModule: free a duplicated module. - ***************************************************************************** - * This function frees the allocations done in DupModule(). - *****************************************************************************/ -static void UndupModule( module_t *p_module ) -{ - char **pp_shortcut; - - for (module_t *subm = p_module->submodule; subm; subm = subm->next) - UndupModule (subm); - - for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) - { - free( *pp_shortcut ); - } - - free( p_module->psz_capability ); - FREENULL( p_module->psz_shortname ); - free( p_module->psz_longname ); - FREENULL( p_module->psz_help ); -} - -#endif /* HAVE_DYNAMIC_PLUGINS */ - -/***************************************************************************** - * AllocateBuiltinModule: initialize a builtin module. - ***************************************************************************** - * This function registers a builtin module and allocates a structure - * for its information data. The module can then be handled by module_need - * and module_unneed. It can be removed by DeleteModule. - *****************************************************************************/ -static int AllocateBuiltinModule( vlc_object_t * p_this, - int ( *pf_entry ) ( module_t * ) ) -{ - module_t * p_module; - - /* Now that we have successfully loaded the module, we can - * allocate a structure for it */ - p_module = vlc_module_create( p_this ); - if( p_module == NULL ) - return -1; - - /* Initialize the module : fill p_module->psz_object_name, etc. */ - if( pf_entry( p_module ) != 0 ) - { - /* With a well-written module we shouldn't have to print an - * additional error message here, but just make sure. */ - msg_Err( p_this, "failed calling entry point in builtin module" ); - module_release( p_module ); - return -1; - } - - /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = true; - /* LOCK */ - p_module->next = p_module_bank->head; - p_module_bank->head = p_module; - /* UNLOCK */ - - /* msg_Dbg( p_this, "builtin \"%s\", %s", - p_module->psz_object_name, p_module->psz_longname ); */ - - return 0; -} - -/***************************************************************************** - * DeleteModule: delete a module and its structure. - ***************************************************************************** - * This function can only be called if the module isn't being used. - *****************************************************************************/ -static void DeleteModule( module_bank_t *p_bank, module_t * p_module ) -{ - assert( p_module ); - - /* Unlist the module (if it is in the list) */ - module_t **pp_self = &p_bank->head; - while (*pp_self != NULL && *pp_self != p_module) - pp_self = &((*pp_self)->next); - if (*pp_self) - *pp_self = p_module->next; - - /* We free the structures that we strdup()ed in Allocate*Module(). */ -#ifdef HAVE_DYNAMIC_PLUGINS - if( !p_module->b_builtin ) - { - if( p_module->b_loaded && p_module->b_unloadable ) - { - module_Unload( p_module->handle ); - } - UndupModule( p_module ); - free( p_module->psz_filename ); - } -#endif - - /* Free and detach the object's children */ - while (p_module->submodule) - { - module_t *submodule = p_module->submodule; - p_module->submodule = submodule->next; - module_release (submodule); - } - - config_Free( p_module ); - module_release( p_module ); -}