X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmodules%2Fmodules.c;h=9ff601b3a6aa5916a564b14758292fdc99d412df;hb=6903d514d3ea8113f91b1bedde862607f7efc92a;hp=cc9570faa3cb02b2e5b1f28db6f38d4ea0e6327b;hpb=a9eeb55307274d9510a55d29e1613ede8895d9bf;p=vlc diff --git a/src/modules/modules.c b/src/modules/modules.c index cc9570faa3..9ff601b3a6 100644 --- a/src/modules/modules.c +++ b/src/modules/modules.c @@ -28,7 +28,8 @@ # include "config.h" #endif -#include +#include +#include #include "libvlc.h" /* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS @@ -84,6 +85,7 @@ #include "config/configuration.h" #include "vlc_charset.h" +#include "vlc_arrays.h" #include "modules/modules.h" #include "modules/builtin.h" @@ -98,87 +100,82 @@ static int AllocatePluginFile ( vlc_object_t *, char *, int64_t, int64_t ); static module_t * AllocatePlugin( vlc_object_t *, char * ); #endif static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); -static int DeleteModule ( module_t *, vlc_bool_t ); +static void DeleteModule ( module_t *, bool ); #ifdef HAVE_DYNAMIC_PLUGINS static void DupModule ( module_t * ); static void UndupModule ( module_t * ); #endif -static void module_LoadMain( vlc_object_t *p_this ); - -/***************************************************************************** - * module_InitBank: create the module bank. - ***************************************************************************** - * This function creates a module bank structure which will be filled later +/** + * 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_value_t lockval; libvlc_global_data_t *p_libvlc_global = vlc_global(); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank ) + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); + + if( p_libvlc_global->p_module_bank == NULL ) { - p_libvlc_global->p_module_bank->i_usage++; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - return; + p_bank = vlc_custom_create( p_this, sizeof(module_bank_t), + VLC_OBJECT_GENERIC, "module 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 = + p_bank->b_cache_delete = false; + + /* Everything worked, attach the object */ + p_libvlc_global->p_module_bank = p_bank; + vlc_object_attach( p_bank, p_libvlc_global ); + + /* 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 ); } - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + else + p_libvlc_global->p_module_bank->i_usage++; - p_bank = vlc_object_create( p_this, sizeof(module_bank_t) ); - if( !p_bank ) - return; - p_bank->psz_object_name = "module 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 = - p_bank->b_cache_delete = VLC_FALSE; - - /* Everything worked, attach the object */ - p_libvlc_global->p_module_bank = p_bank; - vlc_object_attach( p_bank, p_libvlc_global ); - - module_LoadMain( p_this ); + vlc_mutex_unlock( lock ); } -/***************************************************************************** - * module_EndBank: empty the module bank. - ***************************************************************************** - * This function unloads all unused plugin modules and empties the module +/** + * End bank + * + * 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 ) { module_t * p_next = NULL; - vlc_value_t lockval; libvlc_global_data_t *p_libvlc_global = vlc_global(); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); if( !p_libvlc_global->p_module_bank ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } if( --p_libvlc_global->p_module_bank->i_usage ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); + /* Save the configuration */ config_AutoSaveConfigFile( p_this ); #ifdef HAVE_DYNAMIC_PLUGINS @@ -188,8 +185,9 @@ void __module_EndBank( vlc_object_t *p_this ) { if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ) { - DeleteModule( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module, - p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used ); + DeleteModule( + p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module, + p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used ); free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file ); free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] ); p_bank->pp_loaded_cache[p_bank->i_loaded_cache] = NULL; @@ -216,110 +214,66 @@ void __module_EndBank( vlc_object_t *p_this ) vlc_object_detach( p_libvlc_global->p_module_bank ); - while( p_libvlc_global->p_module_bank->i_children ) + while( vlc_internals( p_libvlc_global->p_module_bank )->i_children ) { - p_next = (module_t *)p_libvlc_global->p_module_bank->pp_children[0]; - - if( DeleteModule( p_next, VLC_TRUE ) ) - { - /* Module deletion failed */ - msg_Err( p_this, "module \"%s\" can't be removed, trying harder", - p_next->psz_object_name ); - - /* We just free the module by hand. Niahahahahaha. */ - vlc_object_detach( p_next ); - vlc_object_destroy( p_next ); - } + p_next = (module_t *)vlc_internals( p_libvlc_global->p_module_bank )->pp_children[0]; + DeleteModule( p_next, true ); } - vlc_object_destroy( p_libvlc_global->p_module_bank ); + vlc_object_release( p_libvlc_global->p_module_bank ); p_libvlc_global->p_module_bank = NULL; } -/***************************************************************************** - * module_LoadMain: load the main program info into the module bank. - ***************************************************************************** - * This function fills the module bank structure with the main module infos. - * This is very useful as it will allow us to consider the main program 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. - *****************************************************************************/ -static void module_LoadMain( vlc_object_t *p_this ) -{ - vlc_value_t lockval; - libvlc_global_data_t *p_libvlc_global = vlc_global(); - - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); - if( p_libvlc_global->p_module_bank->b_main ) - { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - return; - } - p_libvlc_global->p_module_bank->b_main = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); - - AllocateBuiltinModule( p_this, vlc_entry__main ); -} - -/***************************************************************************** - * module_LoadBuiltins: load all modules which we built with. - ***************************************************************************** - * This function fills the module bank structure with the builtin modules. - *****************************************************************************/ +/** + * Load all modules which we built with. + * + * Fills the module bank structure with the builtin modules. + * \param p_this vlc object structure + * \return nothing + */ void __module_LoadBuiltins( vlc_object_t * p_this ) { - vlc_value_t lockval; libvlc_global_data_t *p_libvlc_global = vlc_global(); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); if( p_libvlc_global->p_module_bank->b_builtins ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - p_libvlc_global->p_module_bank->b_builtins = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + p_libvlc_global->p_module_bank->b_builtins = true; + vlc_mutex_unlock( lock ); msg_Dbg( p_this, "checking builtin modules" ); ALLOCATE_ALL_BUILTINS(); } -/***************************************************************************** - * module_LoadPlugins: load all plugin modules we can find. - ***************************************************************************** - * This function fills the module bank structure with the plugin modules. - *****************************************************************************/ +/** + * Load all plugins + * + * Load all plugin modules we can find. + * 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 ) { #ifdef HAVE_DYNAMIC_PLUGINS - vlc_value_t lockval; libvlc_global_data_t *p_libvlc_global = vlc_global(); - var_Create( p_libvlc_global, "libvlc", VLC_VAR_MUTEX ); - var_Get( p_libvlc_global, "libvlc", &lockval ); - vlc_mutex_lock( lockval.p_address ); + vlc_mutex_t *lock = var_AcquireMutex( "libvlc" ); if( p_libvlc_global->p_module_bank->b_plugins ) { - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + vlc_mutex_unlock( lock ); return; } - p_libvlc_global->p_module_bank->b_plugins = VLC_TRUE; - vlc_mutex_unlock( lockval.p_address ); - var_Destroy( p_libvlc_global, "libvlc" ); + p_libvlc_global->p_module_bank->b_plugins = true; + vlc_mutex_unlock( lock ); msg_Dbg( p_this, "checking plugin modules" ); if( config_GetInt( p_this, "plugins-cache" ) ) - p_libvlc_global->p_module_bank->b_cache = VLC_TRUE; + p_libvlc_global->p_module_bank->b_cache = true; if( p_libvlc_global->p_module_bank->b_cache || p_libvlc_global->p_module_bank->b_cache_delete ) CacheLoad( p_this ); @@ -328,53 +282,77 @@ void __module_LoadPlugins( vlc_object_t * p_this ) #endif } -/***************************************************************************** - * module_IsCapable: checks whether a module implements a capability. - *****************************************************************************/ -vlc_bool_t module_IsCapable( const module_t *m, const char *cap ) +/** + * Checks whether a module implements a capability. + * + * \param m the module + * \param cap the capability to check + * \return TRUE if the module have the capability + */ +bool module_IsCapable( const module_t *m, const char *cap ) { return !strcmp( m->psz_capability, cap ); } -/***************************************************************************** - * module_GetObjName: internal name of a module. - *****************************************************************************/ +/** + * Get the internal name of a module + * + * \param m the module + * \return the module name + */ const char *module_GetObjName( const module_t *m ) { return m->psz_object_name; } -/***************************************************************************** - * module_GetName: human-friendly name of a module. - *****************************************************************************/ -const char *module_GetName( const module_t *m, vlc_bool_t long_name ) +/** + * Get the human-friendly name of a module. + * + * \param m the module + * \param long_name TRUE to have the long name of the module + * \return the short or long name of the module + */ +const char *module_GetName( const module_t *m, bool long_name ) { if( long_name && ( m->psz_longname != NULL) ) return m->psz_longname; - + return m->psz_shortname ?: m->psz_object_name; } +/** + * Get the help for a module + * + * \param m the module + * \return the help + */ const char *module_GetHelp( const module_t *m ) { return m->psz_help; } -/***************************************************************************** - * module_Need: return the best module function, given a capability list. - ***************************************************************************** - * This function returns the module that best fits the asked capabilities. - *****************************************************************************/ +/** + * module Need + * + * Return the best module function, given a capability list. + * \param p_this the vlc object + * \param psz_capability list of capabilities needed + * \param psz_name name of the module asked + * \param b_strict TRUE yto use the strict mode + * \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, vlc_bool_t b_strict ) + const char *psz_name, bool b_strict ) { typedef struct module_list_t module_list_t; + stats_TimerStart( p_this, "module_Need()", STATS_TIMER_MODULE_NEED ); + struct module_list_t { module_t *p_module; int i_score; - vlc_bool_t b_force; + bool b_force; module_list_t *p_next; }; @@ -387,17 +365,13 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, int i_shortcuts = 0; char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL; - vlc_bool_t b_force_backup = p_this->b_force; + bool b_force_backup = p_this->b_force; /* Deal with variables */ if( psz_name && psz_name[0] == '$' ) { - vlc_value_t val; - var_Create( p_this, psz_name + 1, VLC_VAR_MODULE | VLC_VAR_DOINHERIT ); - var_Get( p_this, psz_name + 1, &val ); - psz_var = val.psz_string; - psz_name = psz_var; + psz_name = psz_var = var_CreateGetString( p_this, psz_name + 1 ); } /* Count how many different shortcuts were asked for */ @@ -409,6 +383,9 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, if( !strcmp( psz_name, "none" ) ) { free( psz_var ); + stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED ); return NULL; } @@ -430,12 +407,12 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, { if( !strcmp(psz_last_shortcut, "none") ) { - b_strict = VLC_TRUE; + b_strict = true; i_shortcuts--; } else if( !strcmp(psz_last_shortcut, "any") ) { - b_strict = VLC_FALSE; + b_strict = false; i_shortcuts--; } } @@ -471,7 +448,7 @@ module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, /* If we required a shortcut, check this plugin provides it. */ if( i_shortcuts > 0 ) { - vlc_bool_t b_trash; + bool b_trash; const char *psz_name = psz_shortcuts; /* Let's drop modules with a <= 0 score (unless they are @@ -585,7 +562,7 @@ found_shortcut: { CacheMerge( p_this, p_module, p_new_module ); vlc_object_attach( p_new_module, p_module ); - DeleteModule( p_new_module, VLC_TRUE ); + DeleteModule( p_new_module, true ); } } #endif @@ -665,16 +642,23 @@ found_shortcut: free( psz_shortcuts ); free( psz_var ); + stats_TimerStop( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerDump( p_this, STATS_TIMER_MODULE_NEED ); + stats_TimerClean( p_this, STATS_TIMER_MODULE_NEED ); + /* Don't forget that the module is still locked */ return p_module; } -/***************************************************************************** - * module_Unneed: decrease the usage count of a 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 + */ void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) { /* Use the close method */ @@ -686,13 +670,15 @@ void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name ); vlc_object_release( p_module ); - - return; } -/***************************************************************************** - * module_Find: get a pointer to a module_t given it's name. - *****************************************************************************/ +/** + * Get a pointer to a module_t given it's name. + * + * \param p_this vlc object structure + * \param psz_name the name of the module + * \return a pointer to the module or NULL in case of a failure + */ module_t *__module_Find( vlc_object_t *p_this, const char * psz_name ) { vlc_list_t *p_list; @@ -715,48 +701,60 @@ module_t *__module_Find( vlc_object_t *p_this, const char * psz_name ) } -/***************************************************************************** - * module_Put: release a module_t pointer from module_Find(). - *****************************************************************************/ -void module_Put ( module_t *module ) +/** + * Release a module_t pointer from module_Find(). + * + * \param module the module to release + * \return nothing + */ +void module_Put( module_t *module ) { - vlc_object_release ( module ); + vlc_object_release( module ); } -/***************************************************************************** - * module_Exists: tell if a module exists. - ***************************************************************************** - * This function is a boolean function that tells if a module exist or not. - *****************************************************************************/ -vlc_bool_t __module_Exists( vlc_object_t *p_this, const char * psz_name ) +/** + * Tell if a module exists and release it in thic case + * + * \param p_this vlc object structure + * \param psz_name th name of the module + * \return TRUE if the module exists + */ +bool __module_Exists( vlc_object_t *p_this, const char * psz_name ) { module_t *p_module = __module_Find( p_this, psz_name ); if( p_module ) { module_Put( p_module ); - return VLC_TRUE; + return true; } else { - return VLC_FALSE; + return false; } } -/***************************************************************************** - * module_GetModuleNamesForCapability: Return a NULL terminated array with the - * names of the modules that have a certain capability. +/** + * GetModuleNamesForCapability + * + * Return a NULL terminated array with the names of the modules + * that have a certain capability. * Free after uses both the string and the table. - *****************************************************************************/ + * \param p_this vlc object structure + * \param psz_capability the capability asked + * \param pppsz_longname an pointer to an array of string to contain + the long names of the modules. If set to NULL the function don't use it. + * \return the NULL terminated array + */ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, - const char * psz_capability, + const char *psz_capability, char ***pppsz_longname ) { vlc_list_t *p_list; int i, j, count = 0; - char ** psz_ret; + char **psz_ret; - /* Do it in two passes */ + /* Do it in two passes : count the number of modules before */ p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); for( i = 0 ; i < p_list->i_count; i++) { @@ -765,9 +763,19 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, if( psz_module_capability && !strcmp( psz_module_capability, psz_capability ) ) count++; } + psz_ret = malloc( sizeof(char*) * (count+1) ); if( pppsz_longname ) *pppsz_longname = malloc( sizeof(char*) * (count+1) ); + if( !psz_ret || ( pppsz_longname && *pppsz_longname == NULL ) ) + { + free( psz_ret ); + free( *pppsz_longname ); + *pppsz_longname = NULL; + vlc_list_release( p_list ); + return NULL; + } + j = 0; for( i = 0 ; i < p_list->i_count; i++) { @@ -784,7 +792,7 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, psz_ret[j] = strdup( k>=0?p_module->pp_shortcuts[k] :p_module->psz_object_name ); if( pppsz_longname ) - (*pppsz_longname)[j] = strdup( module_GetName( p_module, VLC_TRUE ) ); + (*pppsz_longname)[j] = strdup( module_GetName( p_module, true ) ); j++; } } @@ -795,96 +803,153 @@ char ** __module_GetModulesNamesForCapability( vlc_object_t *p_this, return psz_ret; } - -module_config_t *module_GetConfig (const module_t *module, unsigned *restrict psize) +/** + * Get the configuration of a module + * + * \param module the module + * \param psize the size of the configuration returned + * \return the configuration as an array + */ +module_config_t *module_GetConfig( const module_t *module, unsigned *restrict psize ) { + unsigned i,j; unsigned size = module->confsize; - module_config_t *config = malloc (size * sizeof (*config)); + module_config_t *config = malloc( size * sizeof( *config ) ); - assert (psize != NULL); + assert( psize != NULL ); *psize = 0; - for (unsigned i = 0, j = 0; i < size; i++) + if( !config ) + return NULL; + + for( i = 0, j = 0; i < size; i++ ) { const module_config_t *item = module->p_config + i; - if (item->b_internal /* internal option */ + if( item->b_internal /* internal option */ || item->b_unsaveable /* non-modifiable option */ - || item->b_removed /* removed option */) + || item->b_removed /* removed option */ ) continue; - if (config != NULL) - memcpy (config + j, item, sizeof (*config)); - *psize = ++j; + memcpy( config + j, item, sizeof( *config ) ); + j++; } + *psize = j; return config; } -void module_PutConfig (module_config_t *config) +/** + * Release the configuration + * + * \param the configuration + * \return nothing + */ +void module_PutConfig( module_config_t *config ) { - free (config); + free( config ); } /***************************************************************************** * Following functions are local. *****************************************************************************/ -/***************************************************************************** - * AllocateAllPlugins: load all plugin modules we can find. + /***************************************************************************** + * copy_next_paths_token: from a PATH_SEP_CHAR (a ':' or a ';') separated paths + * return first path. *****************************************************************************/ -#ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( vlc_object_t *p_this ) +static char * copy_next_paths_token( char * paths, char ** remaining_paths ) { - /* Yes, there are two NULLs because we replace one with "plugin-path". */ -#if defined( WIN32 ) || defined( UNDER_CE ) - const char *path[] = { "modules", "", "plugins", NULL, NULL }; -#else - const char *path[] = { "modules", PLUGIN_PATH, "plugins", NULL, NULL }; -#endif + char * path; + int i, done; + bool escaped = false; - const char *const *ppsz_path; + assert( paths ); - /* If the user provided a plugin path, we add it to the list */ - char *userpath = config_GetPsz( p_this, "plugin-path" ); - path[sizeof(path)/sizeof(path[0]) - 2] = userpath; + /* Alloc a buffer to store the path */ + path = malloc( strlen( paths ) + 1 ); + if( !path ) return NULL; - for (ppsz_path = path; *ppsz_path != NULL; ppsz_path++) + /* Look for PATH_SEP_CHAR (a ':' or a ';') */ + for( i = 0, done = 0 ; paths[i]; i++ ) { - char *psz_fullpath; - - if (!**ppsz_path) continue; - -#if defined( SYS_BEOS ) || defined( __APPLE__ ) || defined( WIN32 ) - - /* Handle relative as well as absolute paths */ + /* Take care of \\ and \: or \; escapement */ + if( escaped ) + { + escaped = false; + path[done++] = paths[i]; + } #ifdef WIN32 - if( (*ppsz_path)[0] != '\\' && (*ppsz_path)[0] != '/' && - (*ppsz_path)[1] != ':' ) + else if( paths[i] == '/' ) + escaped = true; #else - if( (*ppsz_path)[0] != '/' ) + else if( paths[i] == '\\' ) + escaped = true; #endif - { - if( 0>= asprintf( &psz_fullpath, "%s"DIR_SEP"%s", - vlc_global()->psz_vlcpath, *ppsz_path) ) - psz_fullpath = NULL; - } + 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; +} + +/***************************************************************************** + * AllocateAllPlugins: load all plugin modules we can find. + *****************************************************************************/ +#ifdef HAVE_DYNAMIC_PLUGINS +static void AllocateAllPlugins( vlc_object_t *p_this ) +{ + const char *vlcpath = vlc_global()->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 - psz_fullpath = strdup( *ppsz_path ); - if( psz_fullpath == NULL ) + /* 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'", psz_fullpath ); + msg_Dbg( p_this, "recursively browsing `%s'", path ); /* Don't go deeper than 5 subdirectories */ - AllocatePluginDir( p_this, psz_fullpath, 5 ); + AllocatePluginDir( p_this, path, 5 ); - free( psz_fullpath ); + free( path ); } - /* Free plugin-path */ - free( userpath ); + vlc_array_destroy( arraypaths ); + free( userpaths ); } /***************************************************************************** @@ -1020,7 +1085,7 @@ static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, i_dirlen = strlen( psz_dir ); /* Parse the directory and try to load all files it contains. */ - while( !p_this->p_libvlc->b_die && (file = readdir( dir )) ) + while( !p_this->p_libvlc->b_die && ( file = readdir( dir ) ) ) { struct stat statbuf; unsigned int i_len; @@ -1102,7 +1167,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, module_config_t *p_item = NULL, *p_end = NULL; p_module = p_cache_entry->p_module; - p_module->b_loaded = VLC_FALSE; + p_module->b_loaded = false; /* For now we force loading if the module's config contains * callbacks or actions. @@ -1117,7 +1182,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, } } if( p_module == p_cache_entry->p_module ) - p_cache_entry->b_used = VLC_TRUE; + p_cache_entry->b_used = true; } } @@ -1127,7 +1192,7 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, /* Everything worked fine ! * The module is ready to be added to the list. */ - p_module->b_builtin = VLC_FALSE; + p_module->b_builtin = false; /* msg_Dbg( p_this, "plugin \"%s\", %s", p_module->psz_object_name, p_module->psz_longname ); */ @@ -1148,9 +1213,10 @@ static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file, p_bank->pp_cache[p_bank->i_cache]->i_time = i_file_time; p_bank->pp_cache[p_bank->i_cache]->i_size = i_file_size; p_bank->pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1; - p_bank->pp_cache[p_bank->i_cache]->b_used = VLC_TRUE; + p_bank->pp_cache[p_bank->i_cache]->b_used = true; p_bank->pp_cache[p_bank->i_cache]->p_module = p_module; p_bank->i_cache++; +#undef p_bank } return p_module ? 0 : -1; @@ -1176,7 +1242,6 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) p_module = vlc_module_create( p_this ); if( p_module == NULL ) { - msg_Err( p_this, "out of memory" ); module_Unload( handle ); return NULL; } @@ -1184,13 +1249,13 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) /* We need to fill these since they may be needed by module_Call() */ p_module->psz_filename = psz_file; p_module->handle = handle; - p_module->b_loaded = VLC_TRUE; + p_module->b_loaded = true; /* Initialize the module: fill p_module, default config */ if( module_Call( p_module ) != 0 ) { /* We couldn't call module_init() */ - vlc_object_destroy( p_module ); + vlc_object_release( p_module ); module_Unload( handle ); return NULL; } @@ -1199,7 +1264,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) p_module->psz_filename = strdup( p_module->psz_filename ); /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = VLC_FALSE; + p_module->b_builtin = false; return p_module; } @@ -1212,7 +1277,7 @@ static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file ) *****************************************************************************/ static void DupModule( module_t *p_module ) { - const char **pp_shortcut; + char **pp_shortcut; int i_submodule; for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) @@ -1222,7 +1287,6 @@ static void DupModule( module_t *p_module ) /* We strdup() these entries so that they are still valid when the * module is unloaded. */ - p_module->psz_object_name = strdup( p_module->psz_object_name ); p_module->psz_capability = strdup( p_module->psz_capability ); p_module->psz_shortname = p_module->psz_shortname ? strdup( p_module->psz_shortname ) : NULL; @@ -1230,9 +1294,9 @@ static void DupModule( module_t *p_module ) p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help ) : NULL; - for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) + for( i_submodule = 0; i_submodule < vlc_internals( p_module )->i_children; i_submodule++ ) { - DupModule( (module_t*)p_module->pp_children[ i_submodule ] ); + DupModule( (module_t*)vlc_internals( p_module )->pp_children[ i_submodule ] ); } } @@ -1243,24 +1307,24 @@ static void DupModule( module_t *p_module ) *****************************************************************************/ static void UndupModule( module_t *p_module ) { - const char **pp_shortcut; + char **pp_shortcut; int i_submodule; - for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) + for( i_submodule = 0; i_submodule < vlc_internals( p_module )->i_children; i_submodule++ ) { - UndupModule( (module_t*)p_module->pp_children[ i_submodule ] ); + UndupModule( (module_t*)vlc_internals( p_module )->pp_children[ i_submodule ] ); } for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { - free( (void*)*pp_shortcut ); + free( *pp_shortcut ); } - free( (void*)p_module->psz_object_name ); + FREENULL( p_module->psz_object_name ); free( p_module->psz_capability ); - free( (void*)p_module->psz_shortname ); - free( (void*)p_module->psz_longname ); - free( (void*)p_module->psz_help ); + free( p_module->psz_shortname ); + free( p_module->psz_longname ); + free( p_module->psz_help ); } #endif /* HAVE_DYNAMIC_PLUGINS */ @@ -1281,10 +1345,7 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, * allocate a structure for it */ p_module = vlc_module_create( p_this ); if( p_module == NULL ) - { - msg_Err( p_this, "out of memory" ); return -1; - } /* Initialize the module : fill p_module->psz_object_name, etc. */ if( pf_entry( p_module ) != 0 ) @@ -1292,12 +1353,12 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, /* 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" ); - vlc_object_destroy( p_module ); + vlc_object_release( p_module ); return -1; } /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->b_builtin = VLC_TRUE; + p_module->b_builtin = true; /* msg_Dbg( p_this, "builtin \"%s\", %s", p_module->psz_object_name, p_module->psz_longname ); */ @@ -1312,9 +1373,10 @@ static int AllocateBuiltinModule( vlc_object_t * p_this, ***************************************************************************** * This function can only be called if the module isn't being used. *****************************************************************************/ -static int DeleteModule( module_t * p_module, vlc_bool_t b_detach ) +static void DeleteModule( module_t * p_module, bool b_detach ) { - if( !p_module ) return VLC_EGENERIC; + assert( p_module ); + if( b_detach ) vlc_object_detach( p_module ); @@ -1332,15 +1394,13 @@ static int DeleteModule( module_t * p_module, vlc_bool_t b_detach ) #endif /* Free and detach the object's children */ - while( p_module->i_children ) + while( vlc_internals( p_module )->i_children ) { - vlc_object_t *p_this = p_module->pp_children[0]; + vlc_object_t *p_this = vlc_internals( p_module )->pp_children[0]; vlc_object_detach( p_this ); - vlc_object_destroy( p_this ); + vlc_object_release( p_this ); } config_Free( p_module ); - vlc_object_destroy( p_module ); - p_module = NULL; - return 0; + vlc_object_release( p_module ); }