X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fmodules.c;h=05e1c9f3a1ee4932d8ba01e0267ea5fedb91fd59;hb=51c3c7d717e1dec9c3b72bdb5c02a64a26759f0c;hp=965663200ec281f7c7fad72ed90f124763a48201;hpb=4f551c2bf0d189405e96cbbb8234ed3edd9d6d3e;p=vlc diff --git a/src/misc/modules.c b/src/misc/modules.c index 965663200e..71c5a0f5bd 100644 --- a/src/misc/modules.c +++ b/src/misc/modules.c @@ -1,11 +1,12 @@ /***************************************************************************** - * modules.c : Built-in and dynamic modules management functions + * modules.c : Builtin and plugin modules management functions ***************************************************************************** * Copyright (C) 2001 VideoLAN - * $Id: modules.c,v 1.19 2001/03/21 13:42:34 sam Exp $ + * $Id: modules.c,v 1.123 2003/06/26 12:19:59 sam Exp $ * * Authors: Samuel Hocevar * Ethan C. Baldridge + * Hans-Peter Jansen * * 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 @@ -21,9 +22,6 @@ * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. *****************************************************************************/ -#include "defs.h" - -#include "config.h" /* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS * is set to 64. Don't try to be cleverer. */ @@ -34,233 +32,205 @@ #include /* free(), strtol() */ #include /* sprintf() */ #include /* strdup() */ -#include - -#if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */ -#include /* dlopen(), dlsym(), dlclose() */ -#elif defined(HAVE_IMAGE_H) /* BeOS */ -#include +#include +#ifdef HAVE_DIRENT_H +# include +#elif defined( UNDER_CE ) +# include /* GetFileAttributes() */ #else -/* FIXME: this isn't supposed to be an error */ -#error no dynamic plugins available on your system ! +# include "../extras/dirent.h" #endif -#ifdef SYS_BEOS -#include "beos_specific.h" +#ifdef HAVE_SYS_TYPES_H +# include +#endif +#ifdef HAVE_SYS_STAT_H +# include +#endif +#ifdef HAVE_UNISTD_H +# include #endif -#include "common.h" -#include "threads.h" +#if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */ +# include /* dlopen(), dlsym(), dlclose() */ +# define HAVE_DYNAMIC_PLUGINS +#elif defined(HAVE_IMAGE_H) /* BeOS */ +# include +# define HAVE_DYNAMIC_PLUGINS +#elif defined(UNDER_CE) +# define HAVE_DYNAMIC_PLUGINS +#elif defined(WIN32) +# define HAVE_DYNAMIC_PLUGINS +#else +# undef HAVE_DYNAMIC_PLUGINS +#endif -#include "intf_msg.h" -#include "modules.h" -#include "modules_core.h" +#include "error.h" -/* Local prototypes */ -static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename ); -static int HideModule( module_t * p_module ); -static int FreeModule( module_bank_t * p_bank, module_t * p_module ); -static int LockModule( module_t * p_module ); -static int UnlockModule( module_t * p_module ); -static int CallSymbol( module_t * p_module, char * psz_name ); +#include "vlc_interface.h" +#include "vlc_playlist.h" +#include "intf_eject.h" -/***************************************************************************** - * module_CreateBank: create the module bank. - ***************************************************************************** - * This function creates a module bank structure. - *****************************************************************************/ -module_bank_t * module_CreateBank( void ) -{ - module_bank_t * p_bank; - - p_bank = malloc( sizeof( module_bank_t ) ); +#include "stream_control.h" +#include "input_ext-intf.h" +#include "input_ext-dec.h" +#include "input_ext-plugins.h" - return( p_bank ); -} +#include "vlc_video.h" +#include "video_output.h" +#include "vout_synchro.h" -/***************************************************************************** - * module_InitBank: create the module bank. - ***************************************************************************** - * This function creates a module bank structure and fills it with the - * built-in modules, as well as all the dynamic modules it can find. - *****************************************************************************/ -void module_InitBank( module_bank_t * p_bank ) -{ - static char * path[] = { ".", "lib", PLUGIN_PATH, NULL }; +#include "audio_output.h" +#include "aout_internal.h" - char ** ppsz_path = path; - char * psz_fullpath; - char * psz_file; -#ifdef SYS_BEOS - char * psz_vlcpath = beos_GetProgramPath(); - int i_vlclen = strlen( psz_vlcpath ); - boolean_t b_notinroot; -#endif - DIR * dir; - struct dirent * file; +#include "stream_output.h" +#include "announce.h" - p_bank->first = NULL; - vlc_mutex_init( &p_bank->lock ); +#include "iso_lang.h" - intf_WarnMsg( 1, "module: module bank initialized" ); - - for( ; *ppsz_path != NULL ; ppsz_path++ ) - { - /* Store strlen(*ppsz_path) for later use. */ - int i_dirlen = strlen( *ppsz_path ); - -#ifdef SYS_BEOS - b_notinroot = 0; - /* Under BeOS, we need to add beos_GetProgramPath() to access - * files under the current directory */ - if( ( i_dirlen > 1 ) && strncmp( *ppsz_path, "/", 1 ) ) - { - i_dirlen += i_vlclen + 2; - b_notinroot = 1; +#if defined( UNDER_CE ) +# define MYCHAR wchar_t +#else +# define MYCHAR char +#endif - psz_fullpath = malloc( i_dirlen ); - if( psz_fullpath == NULL ) - { - continue; - } - sprintf( psz_fullpath, "%s/%s", psz_vlcpath, *ppsz_path ); - } - else +#ifdef HAVE_DYNAMIC_PLUGINS +# include "modules_plugin.h" #endif - { - psz_fullpath = *ppsz_path; - } - intf_WarnMsgImm( 2, "module: browsing %s", psz_fullpath ); +#if defined( UNDER_CE ) +# include "modules_builtin_evc.h" +#elif defined( _MSC_VER ) +# include "modules_builtin_msvc.h" +#else +# include "modules_builtin.h" +#endif - if( (dir = opendir( psz_fullpath )) ) - { - /* Parse the directory and try to load all files it contains. */ - while( (file = readdir( dir )) ) - { - int i_filelen = strlen( file->d_name ); +/***************************************************************************** + * Local prototypes + *****************************************************************************/ +#ifdef HAVE_DYNAMIC_PLUGINS +static void AllocateAllPlugins ( vlc_object_t * ); +static void AllocatePluginDir ( vlc_object_t *, const MYCHAR *, int ); +static int AllocatePluginFile ( vlc_object_t *, MYCHAR * ); +#endif +static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); +static int DeleteModule ( module_t * ); +#ifdef HAVE_DYNAMIC_PLUGINS +static void DupModule ( module_t * ); +static void UndupModule ( module_t * ); +static int CallEntry ( module_t * ); +#endif - /* We only load files ending with ".so" */ - if( i_filelen > 3 - && !strncmp( file->d_name + i_filelen - 3, ".so", 3 ) ) - { - psz_file = malloc( i_dirlen + i_filelen + 2 ); - if( psz_file == NULL ) - { - continue; - } - sprintf( psz_file, "%s/%s", psz_fullpath, file->d_name ); +/***************************************************************************** + * module_InitBank: create the module bank. + ***************************************************************************** + * This function creates a module bank structure which will be filled later + * on with all the modules found. + *****************************************************************************/ +void __module_InitBank( vlc_object_t *p_this ) +{ + module_bank_t *p_bank; - /* We created a nice filename -- now we just try to load - * it as a dynamic module. */ - AllocateDynModule( p_bank, psz_file ); + p_bank = vlc_object_create( p_this, sizeof(module_bank_t) ); + p_bank->psz_object_name = "module bank"; - /* We don't care if the allocation succeeded */ - free( psz_file ); - } - } + /* + * Store the symbols to be exported + */ +#ifdef HAVE_DYNAMIC_PLUGINS + STORE_SYMBOLS( &p_bank->symbols ); +#endif - /* Close the directory if successfully opened */ - closedir( dir ); - } + /* Everything worked, attach the object */ + p_this->p_libvlc->p_module_bank = p_bank; + vlc_object_attach( p_bank, p_this->p_libvlc ); -#ifdef SYS_BEOS - if( b_notinroot ) - { - free( psz_fullpath ); - } -#endif - } + return; +} +/***************************************************************************** + * module_ResetBank: reset the module bank. + ***************************************************************************** + * This function resets the module bank by unloading all unused plugin + * modules. + *****************************************************************************/ +void __module_ResetBank( vlc_object_t *p_this ) +{ + msg_Err( p_this, "FIXME: module_ResetBank unimplemented" ); return; } /***************************************************************************** - * module_DestroyBank: destroy the module bank. + * module_EndBank: empty the module bank. ***************************************************************************** - * This function unloads all unused dynamic modules and removes the module + * This function unloads all unused plugin modules and empties the module * bank in case of success. *****************************************************************************/ -void module_DestroyBank( module_bank_t * p_bank ) +void __module_EndBank( vlc_object_t *p_this ) { module_t * p_next; - while( p_bank->first != NULL ) + vlc_object_detach( p_this->p_libvlc->p_module_bank ); + + while( p_this->p_libvlc->p_module_bank->i_children ) { - if( FreeModule( p_bank, p_bank->first ) ) + p_next = (module_t *)p_this->p_libvlc->p_module_bank->pp_children[0]; + + if( DeleteModule( p_next ) ) { /* Module deletion failed */ - intf_ErrMsg( "module error: `%s' can't be removed. trying harder.", - p_bank->first->psz_name ); + 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. */ - p_next = p_bank->first->next; - free(p_bank->first); - p_bank->first = p_next; + vlc_object_detach( p_next ); + vlc_object_destroy( p_next ); } } - /* Destroy the lock */ - vlc_mutex_destroy( &p_bank->lock ); - - /* We can free the module bank */ - free( p_bank ); + vlc_object_destroy( p_this->p_libvlc->p_module_bank ); return; } /***************************************************************************** - * module_ResetBank: reset the module bank. + * module_LoadMain: load the main program info into the module bank. ***************************************************************************** - * This function resets the module bank by unloading all unused dynamic - * modules. + * 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. *****************************************************************************/ -void module_ResetBank( module_bank_t * p_bank ) +void __module_LoadMain( vlc_object_t *p_this ) { - intf_ErrMsg( "FIXME: module_ResetBank unimplemented" ); - return; + AllocateBuiltinModule( p_this, vlc_entry__main ); } /***************************************************************************** - * module_ManageBank: manage the module bank. + * module_LoadBuiltins: load all modules which we built with. ***************************************************************************** - * This function parses the module bank and hides modules that have been - * unused for a while. + * This function fills the module bank structure with the builtin modules. *****************************************************************************/ -void module_ManageBank( module_bank_t * p_bank ) +void __module_LoadBuiltins( vlc_object_t * p_this ) { - module_t * p_module; - - /* We take the global lock */ - vlc_mutex_lock( &p_bank->lock ); - - /* Parse the module list to see if any modules need to be unloaded */ - for( p_module = p_bank->first ; - p_module != NULL ; - p_module = p_module->next ) - { - /* If the module is unused and if it is a dynamic module... */ - if( p_module->i_usage == 0 && !p_module->b_builtin ) - { - if( p_module->i_unused_delay < MODULE_HIDE_DELAY ) - { - p_module->i_unused_delay++; - } - else - { - intf_WarnMsg( 1, "module: hiding unused module `%s'", - p_module->psz_name ); - HideModule( p_module ); - } - } - } - - /* We release the global lock */ - vlc_mutex_unlock( &p_bank->lock ); + msg_Dbg( p_this, "checking builtin modules" ); + ALLOCATE_ALL_BUILTINS(); +} - return; +/***************************************************************************** + * module_LoadPlugins: load all plugin modules we can find. + ***************************************************************************** + * This function fills the module bank structure with the plugin modules. + *****************************************************************************/ +void __module_LoadPlugins( vlc_object_t * p_this ) +{ +#ifdef HAVE_DYNAMIC_PLUGINS + msg_Dbg( p_this, "checking plugin modules" ); + AllocateAllPlugins( p_this ); +#endif } /***************************************************************************** @@ -268,80 +238,298 @@ void module_ManageBank( module_bank_t * p_bank ) ***************************************************************************** * This function returns the module that best fits the asked capabilities. *****************************************************************************/ -module_t * module_Need( module_bank_t *p_bank, - int i_capabilities, void *p_data ) +module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, + const char *psz_name ) { - module_t * p_module; - module_t * p_bestmodule = NULL; - int i_score, i_totalscore, i_bestscore = 0; - int i_index; + typedef struct module_list_t module_list_t; + + struct module_list_t + { + module_t *p_module; + int i_score; + module_list_t *p_next; + }; + + module_list_t *p_list, *p_first, *p_tmp; + vlc_list_t *p_all; + + int i_which_module, i_index = 0; + vlc_bool_t b_intf = VLC_FALSE; - /* We take the global lock */ - vlc_mutex_lock( &p_bank->lock ); + module_t *p_module; + + int i_shortcuts = 0; + char *psz_shortcuts = NULL, *psz_var = NULL; + + msg_Dbg( p_this, "looking for %s module", psz_capability ); + + /* Deal with variables */ + if( psz_name && psz_name[0] == '$' ) + { + psz_var = config_GetPsz( p_this, psz_name + 1 ); + psz_name = psz_var; + } + + /* Count how many different shortcuts were asked for */ + if( psz_name && *psz_name ) + { + char *psz_parser; + + /* If the user wants none, give him none. */ + if( !strcmp( psz_name, "none" ) ) + { + if( psz_var ) free( psz_var ); + return NULL; + } + + i_shortcuts++; + psz_shortcuts = strdup( psz_name ); + + for( psz_parser = psz_shortcuts; *psz_parser; psz_parser++ ) + { + if( *psz_parser == ',' ) + { + *psz_parser = '\0'; + i_shortcuts++; + } + } + } + + /* Sort the modules and test them */ + p_all = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE ); + p_list = malloc( p_all->i_count * sizeof( module_list_t ) ); + p_first = NULL; /* Parse the module list for capabilities and probe each of them */ - for( p_module = p_bank->first ; - p_module != NULL ; - p_module = p_module->next ) + for( i_which_module = 0; i_which_module < p_all->i_count; i_which_module++ ) { - /* Test that this module can do everything we need */ - if( ( p_module->i_capabilities & i_capabilities ) == i_capabilities ) + module_t * p_submodule = NULL; + int i_shortcut_bonus = 0, i_submodule; + + p_module = (module_t *)p_all->p_values[i_which_module].p_object; + + /* Test that this module can do what we need */ + if( strcmp( p_module->psz_capability, psz_capability ) ) + { + for( i_submodule = 0; + i_submodule < p_module->i_children; + i_submodule++ ) + { + if( !strcmp( ((module_t*)p_module->pp_children[ i_submodule ]) + ->psz_capability, psz_capability ) ) + { + p_submodule = + (module_t*)p_module->pp_children[ i_submodule ]; + break; + } + } + + if( p_submodule == NULL ) + { + continue; + } + + p_module = p_submodule; + } + + /* Test if we have the required CPU */ + if( (p_module->i_cpu & p_this->p_libvlc->i_cpu) != p_module->i_cpu ) + { + continue; + } + + /* If we required a shortcut, check this plugin provides it. */ + if( i_shortcuts ) { - i_totalscore = 0; + vlc_bool_t b_trash; + int i_dummy, i_short = i_shortcuts; + char *psz_name = psz_shortcuts; - LockModule( p_module ); + /* Let's drop modules with a 0 score (unless they are + * explicitly requested) */ + b_trash = !p_module->i_score; - /* Parse all the requested capabilities and test them */ - for( i_index = 0 ; (1 << i_index) <= i_capabilities ; i_index++ ) + while( i_short ) { - if( ( (1 << i_index) & i_capabilities ) ) + /* If the last given shortcut is "none" and we couldn't + * find the module in the list of provided shortcuts, + * then kick the bastard out of here!!! */ + if( (i_short == 1) && !strcmp(psz_name, "none") ) { - i_score = ( (function_list_t *)p_module->p_functions) - [i_index].pf_probe( p_data ); + b_trash = VLC_TRUE; + break; + } - if( i_score ) - { - i_totalscore += i_score; - } - else + for( i_dummy = 0; p_module->pp_shortcuts[i_dummy]; i_dummy++ ) + { + if( !strcmp( psz_name, + p_module->pp_shortcuts[i_dummy] ) ) { + /* Found it */ + b_trash = VLC_FALSE; + i_shortcut_bonus = i_short * 10000; break; } } - } - /* If the high score was broken, we have a new champion */ - if( i_totalscore > i_bestscore ) - { - /* Keep the current module locked, but release the previous */ - if( p_bestmodule != NULL ) + if( i_shortcut_bonus ) + { + /* We found it... remember ? */ + break; + } + + /* Go to the next shortcut... This is so lame! */ + while( *psz_name ) { - UnlockModule( p_bestmodule ); + psz_name++; } + psz_name++; + i_short--; + } + + if( b_trash ) + { + continue; + } + } + /* If we didn't require a shortcut, trash zero-scored plugins */ + else if( !p_module->i_score ) + { + continue; + } + + /* Special case: test if we requested a particular intf plugin */ + if( p_module->psz_program + && !strcmp( p_module->psz_program, + p_this->p_vlc->psz_object_name ) ) + { + if( !b_intf ) + { + /* Remove previous non-matching plugins */ + i_index = 0; + b_intf = VLC_TRUE; + } + } + else if( b_intf ) + { + /* This one doesn't match */ + continue; + } + + /* Store this new module */ + p_list[ i_index ].p_module = p_module; + p_list[ i_index ].i_score = p_module->i_score + i_shortcut_bonus; - /* This is the new best module */ - i_bestscore = i_totalscore; - p_bestmodule = p_module; + /* Add it to the modules-to-probe list */ + if( i_index == 0 ) + { + p_list[ 0 ].p_next = NULL; + p_first = p_list; + } + else + { + /* Ok, so at school you learned that quicksort is quick, and + * bubble sort sucks raw eggs. But that's when dealing with + * thousands of items. Here we have barely 50. */ + module_list_t *p_newlist = p_first; + + if( p_first->i_score < p_list[ i_index ].i_score ) + { + p_list[ i_index ].p_next = p_first; + p_first = &p_list[ i_index ]; } else { - /* This module wasn't interesting, unlock it and forget it */ - UnlockModule( p_module ); + while( p_newlist->p_next != NULL && + p_newlist->p_next->i_score >= p_list[ i_index ].i_score ) + { + p_newlist = p_newlist->p_next; + } + + p_list[ i_index ].p_next = p_newlist->p_next; + p_newlist->p_next = &p_list[ i_index ]; } } + + i_index++; + } + + msg_Dbg( p_this, "probing %i candidate%s", + i_index, i_index == 1 ? "" : "s" ); + + /* Lock all candidate modules */ + p_tmp = p_first; + while( p_tmp != NULL ) + { + vlc_object_yield( p_tmp->p_module ); + p_tmp = p_tmp->p_next; } - /* We release the global lock */ - vlc_mutex_unlock( &p_bank->lock ); + /* We can release the list, interesting modules were yielded */ + vlc_list_release( p_all ); + + /* Parse the linked list and use the first successful module */ + p_tmp = p_first; + while( p_tmp != NULL ) + { + if( p_tmp->p_module->pf_activate + && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS ) + { + break; + } + + vlc_object_release( p_tmp->p_module ); + p_tmp = p_tmp->p_next; + } - if( p_bestmodule != NULL ) + /* Store the locked module value */ + if( p_tmp != NULL ) + { + p_module = p_tmp->p_module; + p_tmp = p_tmp->p_next; + } + else { - intf_WarnMsg( 1, "module: locking module `%s'", - p_bestmodule->psz_name ); + p_module = NULL; } - /* Don't forget that the module is still locked if bestmodule != NULL */ - return( p_bestmodule ); + /* Unlock the remaining modules */ + while( p_tmp != NULL ) + { + vlc_object_release( p_tmp->p_module ); + p_tmp = p_tmp->p_next; + } + + free( p_list ); + + if( p_module != NULL ) + { + msg_Dbg( p_module, "using %s module \"%s\"", + psz_capability, p_module->psz_object_name ); + } + else if( p_first == NULL ) + { + msg_Err( 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" ); + } + + if( psz_shortcuts ) + { + free( psz_shortcuts ); + } + + if( psz_var ) + { + free( psz_var ); + } + + /* Don't forget that the module is still locked */ + return p_module; } /***************************************************************************** @@ -350,19 +538,17 @@ module_t * module_Need( module_bank_t *p_bank, * This function must be called by the thread that called module_Need, to * decrease the reference count and allow for hiding of modules. *****************************************************************************/ -void module_Unneed( module_bank_t * p_bank, module_t * p_module ) +void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) { - /* We take the global lock */ - vlc_mutex_lock( &p_bank->lock ); - - /* Just unlock the module - we can't do anything if it fails, - * so there is no need to check the return value. */ - UnlockModule( p_module ); + /* Use the close method */ + if( p_module->pf_deactivate ) + { + p_module->pf_deactivate( p_this ); + } - intf_WarnMsg( 1, "module: unlocking module `%s'", p_module->psz_name ); + msg_Dbg( p_module, "unlocking module \"%s\"", p_module->psz_object_name ); - /* We release the global lock */ - vlc_mutex_unlock( &p_bank->lock ); + vlc_object_release( p_module ); return; } @@ -372,358 +558,491 @@ void module_Unneed( module_bank_t * p_bank, module_t * p_module ) *****************************************************************************/ /***************************************************************************** - * AllocateDynModule: 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, - * module_Unneed and HideModule. It can be removed by FreeModule. + * AllocateAllPlugins: load all plugin modules we can find. *****************************************************************************/ -static int AllocateDynModule( module_bank_t * p_bank, char * psz_filename ) +#ifdef HAVE_DYNAMIC_PLUGINS +static void AllocateAllPlugins( vlc_object_t *p_this ) { - module_t * p_module, * p_othermodule; - module_handle_t handle; + /* Yes, there are two NULLs because we replace one with "plugin-path". */ + char * path[] = { "modules", PLUGIN_PATH, "plugins", NULL, + NULL }; - /* Try to dynamically load the module. */ - if( module_load( psz_filename, &handle ) ) + char ** ppsz_path = path; + char * psz_fullpath; +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) \ + || ( defined( WIN32 ) && !defined( UNDER_CE ) ) + int i_vlclen = strlen( p_this->p_libvlc->psz_vlcpath ); + vlc_bool_t b_notinroot; +#endif + +#if defined( UNDER_CE ) + wchar_t psz_dir[MAX_PATH]; +#endif + + /* If the user provided a plugin path, we add it to the list */ + path[ sizeof(path)/sizeof(char*) - 2 ] = config_GetPsz( p_this, + "plugin-path" ); + +#if defined( WIN32 ) && !defined( UNDER_CE ) && !defined( _MSC_VER ) + /* If there is no 'plugins' nor 'modules' subdirectory, the user may have + * screwed up the unzipping stage, so we look into '.' instead */ + if( !opendir( "plugins" ) && !opendir( "modules" ) + && !strcmp( *ppsz_path, "modules" ) ) { - /* The dynamic module couldn't be opened */ - intf_WarnMsgImm( 1, "module warning: cannot open %s (%s)", - psz_filename, module_error() ); - return( -1 ); + *ppsz_path = "."; } +#endif - /* Now that we have successfully loaded the module, we can - * allocate a structure for it */ - p_module = malloc( sizeof( module_t ) ); - if( p_module == NULL ) + for( ; *ppsz_path != NULL ; ppsz_path++ ) { - intf_ErrMsg( "module error: can't allocate p_module" ); - module_unload( handle ); - return( -1 ); +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) \ + || ( defined( WIN32 ) && !defined( UNDER_CE ) ) + /* Store strlen(*ppsz_path) for later use. */ + int i_dirlen = strlen( *ppsz_path ); + + b_notinroot = VLC_FALSE; + /* Under BeOS, we need to add beos_GetProgramPath() to access + * files under the current directory */ +#ifdef WIN32 + if( i_dirlen < 3 || (*ppsz_path)[3] != '\\' ) +#else + if( (*ppsz_path)[0] != '/' ) +#endif + { + i_dirlen += i_vlclen + 2; + b_notinroot = VLC_TRUE; + + psz_fullpath = malloc( i_dirlen ); + if( psz_fullpath == NULL ) + { + continue; + } +#ifdef WIN32 + sprintf( psz_fullpath, "%s\\%s", + p_this->p_libvlc->psz_vlcpath, *ppsz_path ); +#else + sprintf( psz_fullpath, "%s/%s", + p_this->p_libvlc->psz_vlcpath, *ppsz_path ); +#endif + } + else +#endif + { + psz_fullpath = *ppsz_path; + } + + msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath ); + + /* Don't go deeper than 5 subdirectories */ +#if defined( UNDER_CE ) + MultiByteToWideChar( CP_ACP, 0, psz_fullpath, -1, psz_dir, MAX_PATH ); + AllocatePluginDir( p_this, psz_dir, 5 ); +#else + AllocatePluginDir( p_this, psz_fullpath, 5 ); +#endif + +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) + if( b_notinroot ) + { + free( psz_fullpath ); + } +#endif } - /* We need to fill these since they may be needed by CallSymbol() */ - p_module->psz_filename = psz_filename; - p_module->handle = handle; + /* Free plugin-path */ + if( path[ sizeof(path)/sizeof(char*) - 2 ] ) + free( path[ sizeof(path)/sizeof(char*) - 2 ] ); + path[ sizeof(path)/sizeof(char*) - 2 ] = NULL; +} + +/***************************************************************************** + * AllocatePluginDir: recursively parse a directory to look for plugins + *****************************************************************************/ +static void AllocatePluginDir( vlc_object_t *p_this, const MYCHAR *psz_dir, + int i_maxdepth ) +{ +#if defined( UNDER_CE ) || defined( _MSC_VER ) +#ifdef UNDER_CE + MYCHAR psz_path[MAX_PATH + 256]; +#else + char psz_path[MAX_PATH + 256]; +#endif + WIN32_FIND_DATA finddata; + HANDLE handle; + unsigned int rc; +#else + int i_dirlen; + DIR * dir; + char * psz_file; + struct dirent * file; +#endif - /* Initialize the module : fill p_module->psz_name, etc. */ - if( CallSymbol( p_module, "InitModule" ) != 0 ) + if( i_maxdepth < 0 ) { - /* We couldn't call InitModule() */ - free( p_module ); - module_unload( handle ); - return( -1 ); + return; } - /* Check that version numbers match */ - if( strcmp( VERSION, p_module->psz_version ) ) +#if defined( UNDER_CE ) || defined( _MSC_VER ) + rc = GetFileAttributes( psz_dir ); + if( !(rc & FILE_ATTRIBUTE_DIRECTORY) ) { - free( p_module ); - module_unload( handle ); - return( -1 ); + /* Not a directory */ + return; + } + + /* Parse all files in the directory */ +#ifdef UNDER_CE + swprintf( psz_path, L"%s\\*.*", psz_dir ); +#else + sprintf( psz_path, "%s\\*.*", psz_dir ); +#endif + handle = FindFirstFile( psz_path, &finddata ); + if( handle == INVALID_HANDLE_VALUE ) + { + /* Empty directory */ + return; } - /* Check that we don't already have a module with this name */ - for( p_othermodule = p_bank->first ; - p_othermodule != NULL ; - p_othermodule = p_othermodule->next ) + /* Parse the directory and try to load all files it contains. */ + do { - if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) ) +#ifdef UNDER_CE + unsigned int i_len = wcslen( finddata.cFileName ); + swprintf( psz_path, L"%s\\%s", psz_dir, finddata.cFileName ); +#else + unsigned int i_len = strlen( finddata.cFileName ); + /* Skip ".", ".." and anything starting with "." */ + if( !*finddata.cFileName || *finddata.cFileName == '.' ) + { + if( !FindNextFile( handle, &finddata ) ) break; + continue; + } + sprintf( psz_path, "%s\\%s", psz_dir, finddata.cFileName ); +#endif + + if( GetFileAttributes( psz_path ) & FILE_ATTRIBUTE_DIRECTORY ) + { + AllocatePluginDir( p_this, psz_path, i_maxdepth - 1 ); + } + else if( i_len > strlen( LIBEXT ) +#ifdef UNDER_CE + ) +#else + /* We only load files ending with LIBEXT */ + && !strncasecmp( psz_path + strlen( psz_path) + - strlen( LIBEXT ), + LIBEXT, strlen( LIBEXT ) ) ) +#endif { - free( p_module ); - module_unload( handle ); - return( -1 ); + AllocatePluginFile( p_this, psz_path ); } } + while( FindNextFile( handle, &finddata ) ); + + /* Close the directory */ + FindClose( handle ); - /* Activate the module : fill the capability structure, etc. */ - if( CallSymbol( p_module, "ActivateModule" ) != 0 ) +#else + dir = opendir( psz_dir ); + if( !dir ) { - /* We couldn't call ActivateModule() */ - free( p_module ); - module_unload( handle ); - return( -1 ); + return; } - /* We strdup() these entries so that they are still valid when the - * module is unloaded. */ - p_module->psz_filename = strdup( p_module->psz_filename ); - p_module->psz_name = strdup( p_module->psz_name ); - p_module->psz_longname = strdup( p_module->psz_longname ); - p_module->psz_version = strdup( p_module->psz_version ); - if( p_module->psz_filename == NULL - || p_module->psz_name == NULL - || p_module->psz_longname == NULL - || p_module->psz_version == NULL ) + i_dirlen = strlen( psz_dir ); + + /* Parse the directory and try to load all files it contains. */ + while( (file = readdir( dir )) ) { - intf_ErrMsg( "module error: can't duplicate strings" ); - free( p_module->psz_filename ); - free( p_module->psz_name ); - free( p_module->psz_longname ); - free( p_module->psz_version ); - free( p_module ); - module_unload( handle ); - return( -1 ); - } + struct stat statbuf; + unsigned int i_len; - /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->i_usage = 0; - p_module->i_unused_delay = 0; + /* Skip ".", ".." and anything starting with "." */ + if( !*file->d_name || *file->d_name == '.' ) + { + continue; + } - p_module->b_builtin = 0; + i_len = strlen( file->d_name ); + psz_file = malloc( i_dirlen + 1 + i_len + 1 ); +#ifdef WIN32 + sprintf( psz_file, "%s\\%s", psz_dir, file->d_name ); +#else + sprintf( psz_file, "%s/%s", psz_dir, file->d_name ); +#endif - /* Link module into the linked list */ - if( p_bank->first != NULL ) - { - p_bank->first->prev = p_module; + if( !stat( psz_file, &statbuf ) && statbuf.st_mode & S_IFDIR ) + { + AllocatePluginDir( p_this, psz_file, i_maxdepth - 1 ); + } + else if( i_len > strlen( LIBEXT ) + /* We only load files ending with LIBEXT */ + && !strncasecmp( file->d_name + i_len - strlen( LIBEXT ), + LIBEXT, strlen( LIBEXT ) ) ) + { + AllocatePluginFile( p_this, psz_file ); + } + + free( psz_file ); } - p_module->next = p_bank->first; - p_module->prev = NULL; - p_bank->first = p_module; - /* Immediate message so that a slow module doesn't make the user wait */ - intf_WarnMsgImm( 1, "module: dynamic module `%s', %s", - p_module->psz_name, p_module->psz_longname ); + /* Close the directory */ + closedir( dir ); - return( 0 ); +#endif } /***************************************************************************** - * HideModule: remove a module from memory but keep its structure. + * AllocatePluginFile: load a module into memory and initialize it. ***************************************************************************** - * This function can only be called if i_usage == 0. It will make a call - * to the module's inner DeactivateModule() symbol, and then unload it - * from memory. A call to module_Need() will automagically load it again. + * 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 HideModule( module_t * p_module ) +static int AllocatePluginFile( vlc_object_t * p_this, MYCHAR * psz_file ) { - if( p_module->b_builtin ) - { - /* A built-in module should never be hidden. */ - intf_ErrMsg( "module error: trying to hide built-in module `%s'", - p_module->psz_name ); - return( -1 ); - } + module_t * p_module; + module_handle_t handle; + +#ifdef UNDER_CE + char psz_filename[MAX_PATH]; + WideCharToMultiByte( CP_ACP, WC_DEFAULTCHAR, psz_file, -1, + psz_filename, MAX_PATH, NULL, NULL ); +#else + char * psz_filename = psz_file; +#endif - if( p_module->i_usage >= 1 ) + /* Try to dynamically load the module. */ + if( module_load( psz_file, &handle ) ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is still" - " in use", p_module->psz_name ); - return( -1 ); + char psz_buffer[256]; + + /* The plugin module couldn't be opened */ + msg_Warn( p_this, "cannot open `%s' (%s)", + psz_filename, module_error( psz_buffer ) ); + return -1; } - if( p_module->i_usage <= -1 ) + /* Now that we have successfully loaded the module, we can + * allocate a structure for it */ + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); + if( p_module == NULL ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is already" - " hidden", p_module->psz_name ); - return( -1 ); + msg_Err( p_this, "out of memory" ); + module_unload( handle ); + return -1; } - /* Deactivate the module : free the capability structure, etc. */ - if( CallSymbol( p_module, "DeactivateModule" ) != 0 ) + /* We need to fill these since they may be needed by CallEntry() */ + p_module->psz_filename = psz_filename; + p_module->handle = handle; + p_module->p_symbols = &p_this->p_libvlc->p_module_bank->symbols; + + /* Initialize the module: fill p_module->psz_object_name, default config */ + if( CallEntry( p_module ) != 0 ) { - /* We couldn't call DeactivateModule() -- looks nasty, but - * we can't do much about it. Just try to unload module anyway. */ - module_unload( p_module->handle ); - p_module->i_usage = -1; - return( -1 ); + /* We couldn't call module_init() */ + vlc_object_destroy( p_module ); + module_unload( handle ); + return -1; } - /* Everything worked fine, we can safely unload the module. */ - module_unload( p_module->handle ); - p_module->i_usage = -1; + DupModule( p_module ); + p_module->psz_filename = strdup( p_module->psz_filename ); + p_module->psz_longname = strdup( p_module->psz_longname ); + + /* Everything worked fine ! The module is ready to be added to the list. */ + p_module->b_builtin = VLC_FALSE; + + /* msg_Dbg( p_this, "plugin \"%s\", %s", + p_module->psz_object_name, p_module->psz_longname ); */ + + vlc_object_attach( p_module, p_this->p_libvlc->p_module_bank ); - return( 0 ); + return 0; } /***************************************************************************** - * FreeModule: delete a module and its structure. + * DupModule: make a plugin module standalone. ***************************************************************************** - * This function can only be called if i_usage <= 0. + * This function duplicates all strings in the module, so that the dynamic + * object can be unloaded. It acts recursively on submodules. *****************************************************************************/ -static int FreeModule( module_bank_t * p_bank, module_t * p_module ) +static void DupModule( module_t *p_module ) { - /* If the module is not in use but is still in memory, we first have - * to hide it and remove it from memory before we can free the - * data structure. */ - if( p_module->b_builtin ) - { - if( p_module->i_usage != 0 ) - { - intf_ErrMsg( "module error: trying to free builtin module `%s' with" - " usage %i", p_module->psz_name, p_module->i_usage ); - return( -1 ); - } - } - else - { - if( p_module->i_usage >= 1 ) - { - intf_ErrMsg( "module error: trying to free module `%s' which is" - " still in use", p_module->psz_name ); - return( -1 ); - } - - /* Two possibilities here: i_usage == -1 and the module is already - * unloaded, we can continue, or i_usage == 0, and we have to hide - * the module before going on. */ - if( p_module->i_usage == 0 ) - { - if( HideModule( p_module ) != 0 ) - { - return( -1 ); - } - } - } + char **pp_shortcut; + int i_submodule; - /* Unlink the module from the linked list. */ - if( p_module == p_bank->first ) + for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { - p_bank->first = p_module->next; + *pp_shortcut = strdup( *pp_shortcut ); } - if( p_module->prev != NULL ) + /* 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 ); + + if( p_module->psz_program != NULL ) { - p_module->prev->next = p_module->next; + p_module->psz_program = strdup( p_module->psz_program ); } - if( p_module->next != NULL ) + for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) { - p_module->next->prev = p_module->prev; + DupModule( (module_t*)p_module->pp_children[ i_submodule ] ); } - - /* We free the structures that we strdup()ed in Allocate*Module(). */ - free( p_module->psz_filename ); - free( p_module->psz_name ); - free( p_module->psz_longname ); - free( p_module->psz_version ); - - free( p_module ); - - return( 0 ); } /***************************************************************************** - * LockModule: increase the usage count of a module and load it if needed. + * UndupModule: free a duplicated module. ***************************************************************************** - * This function has to be called before a thread starts using a module. If - * the module is already loaded, we just increase its usage count. If it isn't - * loaded, we have to dynamically open it and initialize it. - * If you successfully call LockModule() at any moment, be careful to call - * UnlockModule() when you don't need it anymore. + * This function frees the allocations done in DupModule(). *****************************************************************************/ -static int LockModule( module_t * p_module ) +static void UndupModule( module_t *p_module ) { - if( p_module->i_usage >= 0 ) + char **pp_shortcut; + int i_submodule; + + for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) { - /* This module is already loaded and activated, we can return */ - p_module->i_usage++; - return( 0 ); + UndupModule( (module_t*)p_module->pp_children[ i_submodule ] ); } - if( p_module->b_builtin ) + for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { - /* A built-in module should always have a refcount >= 0 ! */ - intf_ErrMsg( "module error: built-in module `%s' has refcount %i", - p_module->psz_name, p_module->i_usage ); - return( -1 ); + free( *pp_shortcut ); } - if( p_module->i_usage != -1 ) + free( p_module->psz_object_name ); + free( p_module->psz_capability ); + + if( p_module->psz_program != NULL ) { - /* This shouldn't happen. Ever. We have serious problems here. */ - intf_ErrMsg( "module error: dynamic module `%s' has refcount %i", - p_module->psz_name, p_module->i_usage ); - return( -1 ); + free( p_module->psz_program ); } +} + +#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; - /* i_usage == -1, which means that the module isn't in memory */ - if( module_load( p_module->psz_filename, &p_module->handle ) ) + /* Now that we have successfully loaded the module, we can + * allocate a structure for it */ + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); + if( p_module == NULL ) { - /* The dynamic module couldn't be opened */ - intf_ErrMsg( "module error: cannot open %s (%s)", - p_module->psz_filename, module_error() ); - return( -1 ); + msg_Err( p_this, "out of memory" ); + return -1; } - /* FIXME: what to do if the guy modified the plugin while it was - * unloaded ? It makes XMMS crash nastily, perhaps we should try - * to be a bit more clever here. */ - - /* Activate the module : fill the capability structure, etc. */ - if( CallSymbol( p_module, "ActivateModule" ) != 0 ) + /* Initialize the module : fill p_module->psz_object_name, etc. */ + if( pf_entry( p_module ) != 0 ) { - /* We couldn't call ActivateModule() -- looks nasty, but - * we can't do much about it. Just try to unload module. */ - module_unload( p_module->handle ); - p_module->i_usage = -1; - return( -1 ); + /* 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 ); + return -1; } - /* Everything worked fine ! The module is ready to be used */ - p_module->i_usage = 1; + /* Everything worked fine ! The module is ready to be added to the list. */ + p_module->b_builtin = VLC_TRUE; + + /* msg_Dbg( p_this, "builtin \"%s\", %s", + p_module->psz_object_name, p_module->psz_longname ); */ + + vlc_object_attach( p_module, p_this->p_libvlc->p_module_bank ); - return( 0 ); + return 0; } /***************************************************************************** - * UnlockModule: decrease the usage count of a module. + * DeleteModule: delete a module and its structure. ***************************************************************************** - * We decrease the usage count of a module so that we know when a module - * becomes unused and can be hidden. + * This function can only be called if the module isn't being used. *****************************************************************************/ -static int UnlockModule( module_t * p_module ) +static int DeleteModule( module_t * p_module ) { - if( p_module->i_usage <= 0 ) + vlc_object_detach( p_module ); + + /* We free the structures that we strdup()ed in Allocate*Module(). */ +#ifdef HAVE_DYNAMIC_PLUGINS + if( !p_module->b_builtin ) + { + if( p_module->b_unloadable ) + { + module_unload( p_module->handle ); + } + UndupModule( p_module ); + free( p_module->psz_filename ); + free( p_module->psz_longname ); + } +#endif + + /* Free and detach the object's children */ + while( p_module->i_children ) { - /* This shouldn't happen. Ever. We have serious problems here. */ - intf_ErrMsg( "module error: trying to call module_Unneed() on `%s'" - " which isn't even in use", p_module->psz_name ); - return( -1 ); + vlc_object_t *p_this = p_module->pp_children[0]; + vlc_object_detach( p_this ); + vlc_object_destroy( p_this ); } - /* This module is still in use, we can return */ - p_module->i_usage--; - p_module->i_unused_delay = 0; + config_Free( p_module ); + vlc_object_destroy( p_module ); - return( 0 ); + return 0; } +#ifdef HAVE_DYNAMIC_PLUGINS /***************************************************************************** - * CallSymbol: calls a module symbol. + * CallEntry: call an entry point. ***************************************************************************** * This function calls a symbol given its name and a module structure. The * symbol MUST refer to a function returning int and taking a module_t* as * an argument. *****************************************************************************/ -static int CallSymbol( module_t * p_module, char * psz_name ) +static int CallEntry( module_t * p_module ) { - typedef int ( symbol_t ) ( module_t * p_module ); - symbol_t * p_symbol; + static char *psz_name = "vlc_entry" MODULE_SUFFIX; + int (* pf_symbol) ( module_t * p_module ); /* Try to resolve the symbol */ - p_symbol = module_getsymbol( p_module->handle, psz_name ); + pf_symbol = (int (*)(module_t *)) module_getsymbol( p_module->handle, + psz_name ); - if( !p_symbol ) + if( pf_symbol == NULL ) { + char psz_buffer[256]; + /* We couldn't load the symbol */ - intf_WarnMsg( 1, "module warning: " - "cannot find symbol %s in module %s (%s)", - psz_name, p_module->psz_filename, module_error() ); - return( -1 ); + msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)", + psz_name, p_module->psz_filename, + module_error( psz_buffer ) ); + return -1; } /* We can now try to call the symbol */ - if( p_symbol( p_module ) != 0 ) + if( pf_symbol( p_module ) != 0 ) { /* With a well-written module we shouldn't have to print an * additional error message here, but just make sure. */ - intf_ErrMsg( "module error: failed calling symbol %s in module %s", - psz_name, p_module->psz_filename ); - return( -1 ); + msg_Err( p_module, "failed calling symbol \"%s\" in file `%s'", + psz_name, p_module->psz_filename ); + return -1; } /* Everything worked fine, we can return */ - return( 0 ); + return 0; } - +#endif /* HAVE_DYNAMIC_PLUGINS */