X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fmodules.c;h=0dd888af8811da63defcec1668e9272331cb89f0;hb=005be1388992f71eb6c15b01d99110528dfd825e;hp=8e5347486554f710b5b155efd12ab0f85b76db3b;hpb=0cd5d9133656183f9d25ba3b1019a6272487fcd9;p=vlc diff --git a/src/misc/modules.c b/src/misc/modules.c index 8e53474865..0dd888af88 100644 --- a/src/misc/modules.c +++ b/src/misc/modules.c @@ -1,8 +1,8 @@ /***************************************************************************** - * modules.c : Built-in and plugin modules management functions + * modules.c : Builtin and plugin modules management functions ***************************************************************************** * Copyright (C) 2001 VideoLAN - * $Id: modules.c,v 1.62 2002/05/22 19:31:33 gbazin Exp $ + * $Id: modules.c,v 1.86 2002/08/14 17:06:53 sam Exp $ * * Authors: Samuel Hocevar * Ethan C. Baldridge @@ -33,9 +33,14 @@ #include /* sprintf() */ #include /* strdup() */ -#include +#include #include +#include +#include +#ifdef HAVE_UNISTD_H +# include +#endif #if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */ # include /* dlopen(), dlsym(), dlclose() */ @@ -53,7 +58,7 @@ #include "netutils.h" #include "interface.h" -#include "intf_playlist.h" +#include "vlc_playlist.h" #include "intf_eject.h" #include "stream_control.h" @@ -65,6 +70,9 @@ #include "video_output.h" #include "audio_output.h" +#include "aout_internal.h" + +#include "stream_output.h" #include "iso_lang.h" @@ -82,22 +90,19 @@ * Local prototypes *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins ( void ); -static int AllocatePluginModule ( char * ); +static void AllocateAllPlugins ( vlc_object_t * ); +static void AllocatePluginDir ( vlc_object_t *, const char *, int ); +static int AllocatePluginFile ( vlc_object_t *, char * ); #endif -static int AllocateBuiltinModule( int ( * ) ( module_t * ), - int ( * ) ( module_t * ), - int ( * ) ( module_t * ) ); +static int AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) ); static int DeleteModule ( module_t * ); static int LockModule ( module_t * ); static int UnlockModule ( module_t * ); #ifdef HAVE_DYNAMIC_PLUGINS static int HideModule ( module_t * ); -static int CallSymbol ( module_t *, char * ); -#endif - -#ifdef HAVE_DYNAMIC_PLUGINS -static module_symbols_t symbols; +static void DupModule ( module_t * ); +static void UndupModule ( module_t * ); +static int CallEntry ( module_t * ); #endif /***************************************************************************** @@ -106,59 +111,41 @@ static module_symbols_t symbols; * This function creates a module bank structure which will be filled later * on with all the modules found. *****************************************************************************/ -void module_InitBank( void ) +void __module_InitBank( vlc_object_t *p_this ) { - p_module_bank->first = NULL; - p_module_bank->i_count = 0; - vlc_mutex_init( &p_module_bank->lock ); + module_bank_t *p_bank; + + p_bank = vlc_object_create( p_this, sizeof(module_bank_t) ); + p_bank->psz_object_name = "module bank"; + + p_bank->first = NULL; + p_bank->i_count = 0; + vlc_mutex_init( p_this, &p_bank->lock ); /* * Store the symbols to be exported */ #ifdef HAVE_DYNAMIC_PLUGINS - STORE_SYMBOLS( &symbols ); + STORE_SYMBOLS( &p_bank->symbols ); #endif - return; -} - -/***************************************************************************** - * 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. - *****************************************************************************/ -void module_LoadMain( void ) -{ - AllocateBuiltinModule( InitModule__MODULE_main, - ActivateModule__MODULE_main, - DeactivateModule__MODULE_main ); -} + /* Everything worked, attach the object */ + p_this->p_vlc->p_module_bank = p_bank; + vlc_object_attach( p_bank, p_this->p_vlc ); -/***************************************************************************** - * module_LoadBuiltins: load all modules which we built with. - ***************************************************************************** - * This function fills the module bank structure with the built-in modules. - *****************************************************************************/ -void module_LoadBuiltins( void ) -{ - intf_WarnMsg( 2, "module: checking built-in modules" ); - ALLOCATE_ALL_BUILTINS(); + return; } /***************************************************************************** - * module_LoadPlugins: load all plugin modules we can find. + * module_ResetBank: reset the module bank. ***************************************************************************** - * This function fills the module bank structure with the plugin modules. + * This function resets the module bank by unloading all unused plugin + * modules. *****************************************************************************/ -void module_LoadPlugins( void ) +void __module_ResetBank( vlc_object_t *p_this ) { -#ifdef HAVE_DYNAMIC_PLUGINS - intf_WarnMsg( 2, "module: checking plugin modules" ); - AllocateAllPlugins(); -#endif + msg_Err( p_this, "FIXME: module_ResetBank unimplemented" ); + return; } /***************************************************************************** @@ -167,41 +154,71 @@ void module_LoadPlugins( void ) * This function unloads all unused plugin modules and empties the module * bank in case of success. *****************************************************************************/ -void module_EndBank( void ) +void __module_EndBank( vlc_object_t *p_this ) { module_t * p_next; - while( p_module_bank->first != NULL ) + vlc_object_detach( p_this->p_vlc->p_module_bank ); + + while( p_this->p_vlc->p_module_bank->first != NULL ) { - if( DeleteModule( p_module_bank->first ) ) + if( DeleteModule( p_this->p_vlc->p_module_bank->first ) ) { /* Module deletion failed */ - intf_ErrMsg( "module error: `%s' can't be removed, trying harder", - p_module_bank->first->psz_name ); + msg_Err( p_this, "module \"%s\" can't be removed, trying harder", + p_this->p_vlc->p_module_bank->first->psz_object_name ); /* We just free the module by hand. Niahahahahaha. */ - p_next = p_module_bank->first->next; - free(p_module_bank->first); - p_module_bank->first = p_next; + p_next = p_this->p_vlc->p_module_bank->first->next; + vlc_object_detach( p_this->p_vlc->p_module_bank->first ); + vlc_object_destroy( p_this->p_vlc->p_module_bank->first ); + p_this->p_vlc->p_module_bank->first = p_next; } } /* Destroy the lock */ - vlc_mutex_destroy( &p_module_bank->lock ); + vlc_mutex_destroy( &p_this->p_vlc->p_module_bank->lock ); + + vlc_object_destroy( p_this->p_vlc->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 plugin - * 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( void ) +void __module_LoadMain( vlc_object_t *p_this ) { - intf_ErrMsg( "FIXME: module_ResetBank unimplemented" ); - return; + 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. + *****************************************************************************/ +void __module_LoadBuiltins( vlc_object_t * p_this ) +{ + 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. + *****************************************************************************/ +void __module_LoadPlugins( vlc_object_t * p_this ) +{ +#ifdef HAVE_DYNAMIC_PLUGINS + msg_Dbg( p_this, "checking plugin modules" ); + AllocateAllPlugins( p_this ); +#endif } /***************************************************************************** @@ -210,16 +227,16 @@ void module_ResetBank( void ) * This function parses the module bank and hides modules that have been * unused for a while. *****************************************************************************/ -void module_ManageBank( void ) +void __module_ManageBank( vlc_object_t *p_this ) { #ifdef HAVE_DYNAMIC_PLUGINS module_t * p_module; /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + vlc_mutex_lock( &p_this->p_vlc->p_module_bank->lock ); /* Parse the module list to see if any modules need to be unloaded */ - for( p_module = p_module_bank->first ; + for( p_module = p_this->p_vlc->p_module_bank->first ; p_module != NULL ; p_module = p_module->next ) { @@ -232,8 +249,8 @@ void module_ManageBank( void ) } else { - intf_WarnMsg( 3, "module: hiding unused plugin module `%s'", - p_module->psz_name ); + msg_Dbg( p_this, "hiding unused plugin module \"%s\"", + p_module->psz_object_name ); HideModule( p_module ); /* Break here, so that we only hide one module at a time */ @@ -243,7 +260,7 @@ void module_ManageBank( void ) } /* We release the global lock */ - vlc_mutex_unlock( &p_module_bank->lock ); + vlc_mutex_unlock( &p_this->p_vlc->p_module_bank->lock ); #endif /* HAVE_DYNAMIC_PLUGINS */ return; @@ -254,73 +271,139 @@ void module_ManageBank( void ) ***************************************************************************** * This function returns the module that best fits the asked capabilities. *****************************************************************************/ -module_t * module_Need( int i_capability, char *psz_name, void *p_data ) +module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability, + const char *psz_name ) { - typedef struct module_list_s + typedef struct module_list_t module_list_t; + + struct module_list_t { - struct module_s *p_module; - struct module_list_s* p_next; - } module_list_t; - struct module_list_s *p_list, *p_first, *p_tolock; + module_t *p_module; + int i_score; + module_list_t *p_next; + }; - int i_ret, i_index = 0; - boolean_t b_intf = 0; + module_list_t *p_list, *p_first, *p_tmp; + + int i_index = 0; + vlc_bool_t b_intf = VLC_FALSE; module_t *p_module; - char *psz_realname = NULL; - /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + int i_shortcuts = 0; + char *psz_shortcuts = NULL, *psz_var = NULL; - if( psz_name != NULL && *psz_name ) + msg_Dbg( p_this, "looking for %s module", psz_capability ); + + /* Deal with variables */ + if( psz_name && psz_name[0] == '$' ) { - /* A module name was requested. */ - psz_realname = strdup( psz_name ); - if( psz_realname ) + 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++ ) { - char *p; - p = strchr( psz_realname, ':' ); - if( p ) + if( *psz_parser == ',' ) { - *p = '\0'; + *psz_parser = '\0'; + i_shortcuts++; } - psz_name = psz_realname; } } + /* We take the global lock */ + vlc_mutex_lock( &p_this->p_vlc->p_module_bank->lock ); + /* Sort the modules and test them */ - p_list = malloc( p_module_bank->i_count * sizeof( module_list_t ) ); + p_list = malloc( p_this->p_vlc->p_module_bank->i_count + * sizeof( module_list_t ) ); p_first = NULL; /* Parse the module list for capabilities and probe each of them */ - for( p_module = p_module_bank->first ; + for( p_module = p_this->p_vlc->p_module_bank->first ; p_module != NULL ; p_module = p_module->next ) { - /* Test that this module can do everything we need */ - if( !(p_module->i_capabilities & ( 1 << i_capability )) ) + module_t * p_submodule = NULL; + int i_shortcut_bonus = 0, i_submodule; + + /* Test that this module can do what we need */ + if( strcmp( p_module->psz_capability, psz_capability ) ) { - continue; + 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 ]; + p_submodule->next = p_module->next; + break; + } + } + + if( p_submodule == NULL ) + { + continue; + } + + p_module = p_submodule; } /* Test if we have the required CPU */ - if( (p_module->i_cpu_capabilities & p_main->i_cpu_capabilities) - != p_module->i_cpu_capabilities ) + if( (p_module->i_cpu & p_this->p_vlc->i_cpu) != p_module->i_cpu ) { continue; } /* If we required a shortcut, check this plugin provides it. */ - if( psz_name != NULL && *psz_name ) + if( i_shortcuts ) { - boolean_t b_trash = 1; - int i_dummy; + vlc_bool_t b_trash = VLC_TRUE; + int i_dummy, i_short = i_shortcuts; + char *psz_name = psz_shortcuts; - for( i_dummy = 0; - b_trash && p_module->pp_shortcuts[i_dummy]; - i_dummy++ ) + while( i_short ) { - b_trash = strcmp( psz_name, p_module->pp_shortcuts[i_dummy] ); + for( i_dummy = 0; + b_trash && p_module->pp_shortcuts[i_dummy]; + i_dummy++ ) + { + b_trash = ( strcmp(psz_name, "any") || !p_module->i_score ) + && strcmp( psz_name, p_module->pp_shortcuts[i_dummy] ); + } + + if( !b_trash ) + { + i_shortcut_bonus = i_short * 10000; + break; + } + + /* Go to the next shortcut... This is so lame! */ + while( *psz_name ) + { + psz_name++; + } + psz_name++; + i_short--; } if( b_trash ) @@ -329,36 +412,32 @@ module_t * module_Need( int i_capability, char *psz_name, void *p_data ) } } /* If we didn't require a shortcut, trash zero-scored plugins */ - else if( !p_module->pi_score[i_capability] ) + else if( !p_module->i_score ) { continue; } /* Special case: test if we requested a particular intf plugin */ - if( i_capability == MODULE_CAPABILITY_INTF ) + if( p_module->psz_program + && !strcmp( p_module->psz_program, + p_this->p_vlc->psz_object_name ) ) { - if( p_module->psz_program != NULL - && !strcmp( p_module->psz_program, p_main->psz_arg0 ) ) + if( !b_intf ) { - if( !b_intf ) - { - /* Remove previous non-matching plugins */ - i_index = 0; - b_intf = 1; - } - } - else - { - if( b_intf ) - { - /* This one doesn't match */ - continue; - } + /* 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; /* Add it to the modules-to-probe list */ if( i_index == 0 ) @@ -371,19 +450,17 @@ module_t * module_Need( int i_capability, char *psz_name, void *p_data ) /* 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. */ - struct module_list_s *p_newlist = p_first; + module_list_t *p_newlist = p_first; - if( p_first->p_module->pi_score[i_capability] - < p_module->pi_score[i_capability] ) + 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 { - while( p_newlist->p_next != NULL - && p_newlist->p_next->p_module->pi_score[i_capability] - >= p_module->pi_score[i_capability] ) + while( p_newlist->p_next != NULL && + p_newlist->p_next->i_score >= p_list[ i_index ].i_score ) { p_newlist = p_newlist->p_next; } @@ -396,97 +473,39 @@ module_t * module_Need( int i_capability, char *psz_name, void *p_data ) i_index++; } + msg_Dbg( p_this, "probing %i candidate%s", + i_index, i_index == 1 ? "" : "s" ); + /* Lock all selected modules */ - p_tolock = p_first; - while( p_tolock != NULL ) + p_tmp = p_first; + while( p_tmp != NULL ) { - LockModule( p_tolock->p_module ); - p_tolock = p_tolock->p_next; + LockModule( p_tmp->p_module ); + p_tmp = p_tmp->p_next; } /* We can release the global lock, module refcounts were incremented */ - vlc_mutex_unlock( &p_module_bank->lock ); + vlc_mutex_unlock( &p_this->p_vlc->p_module_bank->lock ); /* Parse the linked list and use the first successful module */ - while( p_first != NULL ) + p_tmp = p_first; + while( p_tmp != NULL ) { - /* Test the requested capability */ - switch( i_capability ) - { - case MODULE_CAPABILITY_ACCESS: - i_ret = p_first->p_module->p_functions->access.functions. - access.pf_open( (struct input_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_DEMUX: - i_ret = p_first->p_module->p_functions->demux.functions. - demux.pf_init( (struct input_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_NETWORK: - i_ret = p_first->p_module->p_functions->network.functions. - network.pf_open( (struct network_socket_s *)p_data ); - break; - - case MODULE_CAPABILITY_DECODER: - i_ret = p_first->p_module->p_functions->dec.functions. - dec.pf_probe( (u8 *)p_data ); - break; - - case MODULE_CAPABILITY_INTF: - i_ret = p_first->p_module->p_functions->intf.functions. - intf.pf_open( (struct intf_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_AOUT: - i_ret = p_first->p_module->p_functions->aout.functions. - aout.pf_open( (struct aout_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_VOUT: - i_ret = p_first->p_module->p_functions->vout.functions. - vout.pf_create( (struct vout_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_CHROMA: - i_ret = p_first->p_module->p_functions->chroma.functions. - chroma.pf_init( (struct vout_thread_s *)p_data ); - break; - - case MODULE_CAPABILITY_IDCT: - case MODULE_CAPABILITY_IMDCT: - case MODULE_CAPABILITY_MOTION: - case MODULE_CAPABILITY_DOWNMIX: - case MODULE_CAPABILITY_MEMCPY: - /* This one always works */ - i_ret = 0; - break; - - default: - intf_ErrMsg( "module error: unknown module type %i", - i_capability ); - i_ret = -1; - break; - } - - /* If the high score was broken, we have a new champion */ - if( i_ret == 0 ) + if( p_tmp->p_module->pf_activate + && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS ) { break; } - else - { - UnlockModule( p_first->p_module ); - } - p_first = p_first->p_next; + UnlockModule( p_tmp->p_module ); + p_tmp = p_tmp->p_next; } /* Store the locked module value */ - if( p_first != NULL ) + if( p_tmp != NULL ) { - p_module = p_first->p_module; - p_first = p_first->p_next; + p_module = p_tmp->p_module; + p_tmp = p_tmp->p_next; } else { @@ -494,33 +513,42 @@ module_t * module_Need( int i_capability, char *psz_name, void *p_data ) } /* Unlock the remaining modules */ - while( p_first != NULL ) + while( p_tmp != NULL ) { - UnlockModule( p_first->p_module ); - p_first = p_first->p_next; + UnlockModule( p_tmp->p_module ); + p_tmp = p_tmp->p_next; } free( p_list ); if( p_module != NULL ) { - intf_WarnMsg( 1, "module: locking %s module `%s'", - GetCapabilityName( i_capability ), - p_module->psz_name ); + msg_Info( 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 ) { - intf_ErrMsg( "module error: requested %s module `%s' unavailable", - GetCapabilityName( i_capability ), psz_name ); + msg_Err( p_this, "no %s module matching \"%s\" could be loaded", + psz_capability, (psz_name && *psz_name) ? psz_name : "any" ); } - if( psz_realname ) + if( psz_shortcuts ) { - free( psz_realname ); + free( psz_shortcuts ); + } + + if( psz_var ) + { + free( psz_var ); } /* Don't forget that the module is still locked */ - return( p_module ); + return p_module; } /***************************************************************************** @@ -529,19 +557,25 @@ module_t * module_Need( int i_capability, char *psz_name, void *p_data ) * 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_t * p_module ) +void __module_Unneed( vlc_object_t * p_this, module_t * p_module ) { + /* Use the close method */ + if( p_module->pf_deactivate ) + { + p_module->pf_deactivate( p_this ); + } + /* We take the global lock */ - vlc_mutex_lock( &p_module_bank->lock ); + vlc_mutex_lock( &p_module->p_vlc->p_module_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 ); - intf_WarnMsg( 1, "module: unlocking module `%s'", p_module->psz_name ); + msg_Info( p_module, "unlocking module \"%s\"", p_module->psz_object_name ); /* We release the global lock */ - vlc_mutex_unlock( &p_module_bank->lock ); + vlc_mutex_unlock( &p_module->p_vlc->p_module_bank->lock ); return; } @@ -554,34 +588,36 @@ void module_Unneed( module_t * p_module ) * AllocateAllPlugins: load all plugin modules we can find. *****************************************************************************/ #ifdef HAVE_DYNAMIC_PLUGINS -static void AllocateAllPlugins( void ) +static void AllocateAllPlugins( vlc_object_t *p_this ) { - static char * path[] = { ".", "plugins", PLUGIN_PATH, NULL, NULL }; + /* Yes, there are two NULLs because we replace one with "plugin-path". */ + char * path[] = { "modules", PLUGIN_PATH, NULL, NULL }; char ** ppsz_path = path; char * psz_fullpath; - char * psz_file; #if defined( SYS_BEOS ) || defined( SYS_DARWIN ) char * psz_vlcpath = system_GetProgramPath(); int i_vlclen = strlen( psz_vlcpath ); - boolean_t b_notinroot; + vlc_bool_t b_notinroot; #endif - DIR * dir; - struct dirent * file; + + /* 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" ); for( ; *ppsz_path != NULL ; ppsz_path++ ) { +#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) /* Store strlen(*ppsz_path) for later use. */ int i_dirlen = strlen( *ppsz_path ); -#if defined( SYS_BEOS ) || defined( SYS_DARWIN ) - b_notinroot = 0; + b_notinroot = VLC_FALSE; /* 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; + b_notinroot = VLC_TRUE; psz_fullpath = malloc( i_dirlen ); if( psz_fullpath == NULL ) @@ -596,38 +632,10 @@ static void AllocateAllPlugins( void ) psz_fullpath = *ppsz_path; } - intf_WarnMsg( 1, "module: browsing `%s'", psz_fullpath ); - - 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 ); - - /* 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 ); - - /* We created a nice filename -- now we just try to load - * it as a plugin module. */ - AllocatePluginModule( psz_file ); - - /* We don't care if the allocation succeeded */ - free( psz_file ); - } - } + msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath ); - /* Close the directory if successfully opened */ - closedir( dir ); - } + /* Don't go deeper than 5 subdirectories */ + AllocatePluginDir( p_this, psz_fullpath, 5 ); #if defined( SYS_BEOS ) || defined( SYS_DARWIN ) if( b_notinroot ) @@ -639,77 +647,152 @@ static void AllocateAllPlugins( void ) } /***************************************************************************** - * AllocatePluginModule: load a module into memory and initialize it. + * AllocatePluginDir: recursively parse a directory to look for plugins + *****************************************************************************/ +static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir, + int i_maxdepth ) +{ +#define PLUGIN_EXT ".so" + int i_dirlen; + DIR * dir; + char * psz_file; + + struct dirent * file; + + if( i_maxdepth < 0 ) + { + return; + } + + dir = opendir( psz_dir ); + + if( !dir ) + { + return; + } + + i_dirlen = strlen( psz_dir ); + + /* Parse the directory and try to load all files it contains. */ + while( (file = readdir( dir )) ) + { + struct stat statbuf; + int i_len = strlen( file->d_name ); + + /* Skip ".", ".." and anything starting with "." */ + if( !*file->d_name || *file->d_name == '.' ) + { + continue; + } + + psz_file = malloc( i_dirlen + 1 /* / */ + i_len + 1 /* \0 */ ); + sprintf( psz_file, "%s/%s", psz_dir, file->d_name ); + + if( !stat( psz_file, &statbuf ) && statbuf.st_mode & S_IFDIR ) + { + AllocatePluginDir( p_this, psz_file, i_maxdepth - 1 ); + } + else if( i_len > strlen( PLUGIN_EXT ) + /* We only load files ending with ".so" */ + && !strncmp( file->d_name + i_len - strlen( PLUGIN_EXT ), + PLUGIN_EXT, strlen( PLUGIN_EXT ) ) ) + { + AllocatePluginFile( p_this, psz_file ); + } + + free( psz_file ); + } + + /* Close the directory */ + closedir( dir ); +} + +/***************************************************************************** + * 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, * module_Unneed and HideModule. It can be removed by DeleteModule. *****************************************************************************/ -static int AllocatePluginModule( char * psz_filename ) +static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file ) { - char **pp_shortcut; - module_t * p_module, * p_othermodule; + module_t * p_module; module_handle_t handle; /* Try to dynamically load the module. */ - if( module_load( psz_filename, &handle ) ) + if( module_load( psz_file, &handle ) ) { char psz_buffer[256]; /* The plugin module couldn't be opened */ - intf_WarnMsg( 1, "module warning: cannot open %s (%s)", - psz_filename, module_error( psz_buffer ) ); - return( -1 ); + msg_Warn( p_this, "cannot open `%s' (%s)", + psz_file, module_error( psz_buffer ) ); + return -1; } /* Now that we have successfully loaded the module, we can * allocate a structure for it */ - p_module = malloc( sizeof( module_t ) ); + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); if( p_module == NULL ) { - intf_ErrMsg( "module error: can't allocate p_module" ); + msg_Err( p_this, "out of memory" ); module_unload( handle ); - return( -1 ); + return -1; } - /* We need to fill these since they may be needed by CallSymbol() */ - p_module->is.plugin.psz_filename = psz_filename; - p_module->is.plugin.handle = handle; - p_module->p_symbols = &symbols; + /* We need to fill these since they may be needed by CallEntry() */ + p_module->psz_filename = psz_file; + p_module->handle = handle; + p_module->p_symbols = &p_this->p_vlc->p_module_bank->symbols; - /* Initialize the module : fill p_module->psz_name, default config, etc. */ - if( CallSymbol( p_module, "InitModule" MODULE_SUFFIX ) != 0 ) + /* Initialize the module: fill p_module->psz_object_name, default config */ + if( CallEntry( p_module ) != 0 ) { - /* We couldn't call InitModule() */ - free( p_module ); + /* We couldn't call module_init() */ + msg_Err( p_this, "failed calling entry point in `%s'", psz_file ); + vlc_object_destroy( p_module ); module_unload( handle ); - return( -1 ); + return -1; } - /* Check that we don't already have a module with this name */ - for( p_othermodule = p_module_bank->first ; - p_othermodule != NULL ; - p_othermodule = p_othermodule->next ) - { - if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) ) - { - intf_WarnMsg( 5, "module warning: cannot load %s, a module named " - "`%s' already exists", - psz_filename, p_module->psz_name ); - free( p_module ); - module_unload( handle ); - return( -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->i_usage = 0; + p_module->i_unused_delay = 0; + + p_module->b_builtin = VLC_FALSE; - /* Activate the module : fill the capability structure, etc. */ - if( CallSymbol( p_module, "ActivateModule" MODULE_SUFFIX ) != 0 ) + /* Link module into the linked list */ + if( p_this->p_vlc->p_module_bank->first != NULL ) { - /* We couldn't call ActivateModule() */ - free( p_module ); - module_unload( handle ); - return( -1 ); + p_this->p_vlc->p_module_bank->first->prev = p_module; } + p_module->next = p_this->p_vlc->p_module_bank->first; + p_module->prev = NULL; + p_this->p_vlc->p_module_bank->first = p_module; + p_this->p_vlc->p_module_bank->i_count++; + + /* msg_Dbg( p_this, "plugin \"%s\", %s", + p_module->psz_object_name, p_module->psz_longname ); */ + + vlc_object_attach( p_module, p_this->p_vlc->p_module_bank ); + + return 0; +} + +/***************************************************************************** + * 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; + int i_submodule; for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { @@ -718,135 +801,104 @@ static int AllocatePluginModule( char * psz_filename ) /* We strdup() these entries so that they are still valid when the * module is unloaded. */ - p_module->is.plugin.psz_filename = - strdup( p_module->is.plugin.psz_filename ); - p_module->psz_name = strdup( p_module->psz_name ); - p_module->psz_longname = strdup( p_module->psz_longname ); + p_module->psz_object_name = strdup( p_module->psz_object_name ); + p_module->psz_capability = strdup( p_module->psz_capability ); - if( p_module->is.plugin.psz_filename == NULL - || p_module->psz_name == NULL - || p_module->psz_longname == NULL ) + if( p_module->psz_program != NULL ) { - intf_ErrMsg( "module error: can't duplicate strings" ); - - free( p_module->is.plugin.psz_filename ); - free( p_module->psz_name ); - free( p_module->psz_longname ); - free( p_module->psz_program ); - - free( p_module ); - module_unload( handle ); - return( -1 ); + p_module->psz_program = strdup( p_module->psz_program ); } - if( p_module->psz_program != NULL ) + for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) { - p_module->psz_program = strdup( p_module->psz_program ); + DupModule( (module_t*)p_module->pp_children[ i_submodule ] ); } +} - /* Everything worked fine ! The module is ready to be added to the list. */ - p_module->i_usage = 0; - p_module->i_unused_delay = 0; +/***************************************************************************** + * UndupModule: free a duplicated module. + ***************************************************************************** + * This function frees the allocations done in DupModule(). + *****************************************************************************/ +static void UndupModule( module_t *p_module ) +{ + char **pp_shortcut; + int i_submodule; - p_module->b_builtin = 0; + for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ ) + { + UndupModule( (module_t*)p_module->pp_children[ i_submodule ] ); + } - /* Link module into the linked list */ - if( p_module_bank->first != NULL ) + for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ ) { - p_module_bank->first->prev = p_module; + free( *pp_shortcut ); } - p_module->next = p_module_bank->first; - p_module->prev = NULL; - p_module_bank->first = p_module; - p_module_bank->i_count++; - /* Immediate message so that a slow module doesn't make the user wait */ - intf_WarnMsg( 2, "module: new plugin module `%s', %s", - p_module->psz_name, p_module->psz_longname ); + free( p_module->psz_object_name ); + free( p_module->psz_capability ); - return( 0 ); + if( p_module->psz_program != NULL ) + { + free( p_module->psz_program ); + } } + #endif /* HAVE_DYNAMIC_PLUGINS */ /***************************************************************************** - * AllocateBuiltinModule: initialize a built-in module. + * AllocateBuiltinModule: initialize a builtin module. ***************************************************************************** - * This function registers a built-in module and allocates a structure + * This function registers a builtin 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 DeleteModule. *****************************************************************************/ -static int AllocateBuiltinModule( int ( *pf_init ) ( module_t * ), - int ( *pf_activate ) ( module_t * ), - int ( *pf_deactivate ) ( module_t * ) ) +static int AllocateBuiltinModule( vlc_object_t * p_this, + int ( *pf_entry ) ( module_t * ) ) { - module_t * p_module, * p_othermodule; + module_t * p_module; /* Now that we have successfully loaded the module, we can * allocate a structure for it */ - p_module = malloc( sizeof( module_t ) ); + p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE ); if( p_module == NULL ) { - intf_ErrMsg( "module error: can't allocate p_module" ); - return( -1 ); + msg_Err( p_this, "out of memory" ); + return -1; } - /* Initialize the module : fill p_module->psz_name, etc. */ - if( pf_init( p_module ) != 0 ) + /* 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. */ - intf_ErrMsg( "module error: failed calling init in builtin module" ); - free( p_module ); - return( -1 ); - } - - /* Check that we don't already have a module with this name */ - for( p_othermodule = p_module_bank->first ; - p_othermodule != NULL ; - p_othermodule = p_othermodule->next ) - { - if( !strcmp( p_othermodule->psz_name, p_module->psz_name ) ) - { - intf_WarnMsg( 5, "module warning: cannot load builtin `%s', a " - "module named `%s' already exists", - p_module->psz_name, p_module->psz_name ); - free( p_module ); - return( -1 ); - } - } - - if( pf_activate( 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 activate " - "in builtin module" ); - free( p_module ); - return( -1 ); + 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 added to the list. */ p_module->i_usage = 0; p_module->i_unused_delay = 0; - p_module->b_builtin = 1; - p_module->is.builtin.pf_deactivate = pf_deactivate; + p_module->b_builtin = VLC_TRUE; /* Link module into the linked list */ - if( p_module_bank->first != NULL ) + if( p_this->p_vlc->p_module_bank->first != NULL ) { - p_module_bank->first->prev = p_module; + p_this->p_vlc->p_module_bank->first->prev = p_module; } - p_module->next = p_module_bank->first; + p_module->next = p_this->p_vlc->p_module_bank->first; p_module->prev = NULL; - p_module_bank->first = p_module; - p_module_bank->i_count++; + p_this->p_vlc->p_module_bank->first = p_module; + p_this->p_vlc->p_module_bank->i_count++; + + /* msg_Dbg( p_this, "builtin \"%s\", %s", + p_module->psz_object_name, p_module->psz_longname ); */ - /* Immediate message so that a slow module doesn't make the user wait */ - intf_WarnMsg( 2, "module: new builtin module `%s', %s", - p_module->psz_name, p_module->psz_longname ); + vlc_object_attach( p_module, p_this->p_vlc->p_module_bank ); - return( 0 ); + return 0; } /***************************************************************************** @@ -863,14 +915,9 @@ static int DeleteModule( module_t * p_module ) { 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 - { - /* We deactivate the module now. */ - p_module->is.builtin.pf_deactivate( p_module ); + msg_Err( p_module, "trying to free builtin module \"%s\" with " + "usage %i", p_module->psz_object_name, p_module->i_usage ); + return -1; } } #ifdef HAVE_DYNAMIC_PLUGINS @@ -878,9 +925,9 @@ static int DeleteModule( module_t * p_module ) { 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 ); + msg_Err( p_module, "trying to free module \"%s\" which is " + "still in use", p_module->psz_object_name ); + return -1; } /* Two possibilities here: i_usage == -1 and the module is already @@ -890,12 +937,14 @@ static int DeleteModule( module_t * p_module ) { if( HideModule( p_module ) != 0 ) { - return( -1 ); + return -1; } } } #endif + vlc_object_detach( p_module ); + /* Unlink the module from the linked list. */ if( p_module->prev != NULL ) { @@ -903,7 +952,7 @@ static int DeleteModule( module_t * p_module ) } else { - p_module_bank->first = p_module->next; + p_module->p_vlc->p_module_bank->first = p_module->next; } if( p_module->next != NULL ) @@ -911,29 +960,30 @@ static int DeleteModule( module_t * p_module ) p_module->next->prev = p_module->prev; } - p_module_bank->i_count--; + p_module->p_vlc->p_module_bank->i_count--; /* We free the structures that we strdup()ed in Allocate*Module(). */ #ifdef HAVE_DYNAMIC_PLUGINS if( !p_module->b_builtin ) { - char **pp_shortcut = p_module->pp_shortcuts; - - for( ; *pp_shortcut ; pp_shortcut++ ) - { - free( *pp_shortcut ); - } - - free( p_module->is.plugin.psz_filename ); - free( p_module->psz_name ); + UndupModule( p_module ); + free( p_module->psz_filename ); free( p_module->psz_longname ); - free( p_module->psz_program ); } #endif - free( p_module ); + /* Free and detach the object's children */ + while( p_module->i_children ) + { + vlc_object_t *p_this = p_module->pp_children[0]; + vlc_object_detach( p_this ); + vlc_object_destroy( p_this ); + } + + config_Free( p_module ); + vlc_object_destroy( p_module ); - return( 0 ); + return 0; } /***************************************************************************** @@ -951,58 +1001,46 @@ static int LockModule( module_t * p_module ) { /* This module is already loaded and activated, we can return */ p_module->i_usage++; - return( 0 ); + return 0; } if( p_module->b_builtin ) { - /* 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 ); + /* A builtin module should always have a refcount >= 0 ! */ + msg_Err( p_module, "builtin module \"%s\" has refcount %i", + p_module->psz_object_name, p_module->i_usage ); + return -1; } #ifdef HAVE_DYNAMIC_PLUGINS if( p_module->i_usage != -1 ) { /* This shouldn't happen. Ever. We have serious problems here. */ - intf_ErrMsg( "module error: plugin module `%s' has refcount %i", - p_module->psz_name, p_module->i_usage ); - return( -1 ); + msg_Err( p_module, "plugin module \"%s\" has refcount %i", + p_module->psz_object_name, p_module->i_usage ); + return -1; } /* i_usage == -1, which means that the module isn't in memory */ - if( module_load( p_module->is.plugin.psz_filename, - &p_module->is.plugin.handle ) ) + if( module_load( p_module->psz_filename, &p_module->handle ) ) { char psz_buffer[256]; /* The plugin module couldn't be opened */ - intf_ErrMsg( "module error: cannot open %s (%s)", - p_module->is.plugin.psz_filename, - module_error( psz_buffer ) ); - return( -1 ); + msg_Err( p_module, "cannot open `%s' (%s)", + p_module->psz_filename, module_error(psz_buffer) ); + 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" MODULE_SUFFIX ) != 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->is.plugin.handle ); - p_module->i_usage = -1; - return( -1 ); - } - /* Everything worked fine ! The module is ready to be used */ p_module->i_usage = 1; #endif /* HAVE_DYNAMIC_PLUGINS */ - return( 0 ); + return 0; } /***************************************************************************** @@ -1016,16 +1054,16 @@ static int UnlockModule( module_t * p_module ) if( p_module->i_usage <= 0 ) { /* 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 ); + msg_Err( p_module, "trying to call module_Unneed() on \"%s\" " + "which is not in use", p_module->psz_object_name ); + return -1; } /* This module is still in use, we can return */ p_module->i_usage--; p_module->i_unused_delay = 0; - return( 0 ); + return 0; } #ifdef HAVE_DYNAMIC_PLUGINS @@ -1033,74 +1071,65 @@ static int UnlockModule( module_t * p_module ) * HideModule: remove a module from memory but keep its structure. ***************************************************************************** * 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 + * to the module's inner module_deactivate() symbol, and then unload it * from memory. A call to module_Need() will automagically load it again. *****************************************************************************/ static int HideModule( module_t * p_module ) { 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 ); + /* A builtin module should never be hidden. */ + msg_Err( p_module, "trying to hide builtin module \"%s\"", + p_module->psz_object_name ); + return -1; } if( p_module->i_usage >= 1 ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is still" - " in use", p_module->psz_name ); - return( -1 ); + msg_Err( p_module, "trying to hide module \"%s\" which is still " + "in use", p_module->psz_object_name ); + return -1; } if( p_module->i_usage <= -1 ) { - intf_ErrMsg( "module error: trying to hide module `%s' which is already" - " hidden", p_module->psz_name ); - return( -1 ); - } - - /* Deactivate the module : free the capability structure, etc. */ - if( CallSymbol( p_module, "DeactivateModule" MODULE_SUFFIX ) != 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->is.plugin.handle ); - p_module->i_usage = -1; - return( -1 ); + msg_Err( p_module, "trying to hide module \"%s\" which is already " + "hidden", p_module->psz_object_name ); + return -1; } /* Everything worked fine, we can safely unload the module. */ - module_unload( p_module->is.plugin.handle ); + module_unload( p_module->handle ); p_module->i_usage = -1; - return( 0 ); + return 0; } /***************************************************************************** - * 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 ) { + static char *psz_name = "vlc_entry" MODULE_SUFFIX; int (* pf_symbol) ( module_t * p_module ); /* Try to resolve the symbol */ - pf_symbol = module_getsymbol( p_module->is.plugin.handle, psz_name ); + pf_symbol = (int (*)(module_t *)) module_getsymbol( p_module->handle, + psz_name ); 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->is.plugin.psz_filename, - module_error( psz_buffer ) ); - 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 */ @@ -1108,13 +1137,13 @@ static int CallSymbol( module_t * p_module, char * psz_name ) { /* 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->is.plugin.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 */