X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=904ae746aebe116d8f4ab6a2e276f0b750971815;hb=77f7cdd4cb65332ed8343e3ed973b92f77fbaa03;hp=f210d0e8c963b7ef93c78caaee844e2acf7f1061;hpb=bef75ae8f094f21a72e78cfb48631587f06d38a4;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index f210d0e8c9..904ae746ae 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -1,7 +1,7 @@ /***************************************************************************** * variables.c: routines for object variables handling ***************************************************************************** - * Copyright (C) 2002-2004 VideoLAN + * Copyright (C) 2002-2006 the VideoLAN team * $Id$ * * Authors: Samuel Hocevar @@ -18,17 +18,22 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + #include +#include "variables.h" -#ifdef HAVE_STDLIB_H -# include /* realloc() */ -#endif +#include "libvlc.h" + +#include "vlc_interface.h" /***************************************************************************** * Private types @@ -155,44 +160,48 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) int i_new; variable_t *p_var; static vlc_list_t dummy_null_list = {0, NULL, NULL}; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); /* FIXME: if the variable already exists, we don't duplicate it. But we * duplicate the lookups. It's not that serious, but if anyone finds some * time to rework Insert() so that only one lookup has to be done, feel * free to do so. */ - i_new = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_new = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_new >= 0 ) { /* If the types differ, variable creation failed. */ - if( (i_type & ~VLC_VAR_DOINHERIT) != p_this->p_vars[i_new].i_type ) + if( (i_type & ~(VLC_VAR_DOINHERIT|VLC_VAR_ISCOMMAND)) != p_priv->p_vars[i_new].i_type ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_EBADVAR; } - p_this->p_vars[i_new].i_usage++; - vlc_mutex_unlock( &p_this->var_lock ); + p_priv->p_vars[i_new].i_usage++; + if( i_type & VLC_VAR_ISCOMMAND ) + p_priv->p_vars[i_new].i_type |= VLC_VAR_ISCOMMAND; + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } - i_new = Insert( p_this->p_vars, p_this->i_vars, psz_name ); + i_new = Insert( p_priv->p_vars, p_priv->i_vars, psz_name ); - if( (p_this->i_vars & 15) == 15 ) + if( (p_priv->i_vars & 15) == 15 ) { - p_this->p_vars = realloc( p_this->p_vars, - (p_this->i_vars+17) * sizeof(variable_t) ); + p_priv->p_vars = realloc( p_priv->p_vars, + (p_priv->i_vars+17) * sizeof(variable_t) ); } - memmove( p_this->p_vars + i_new + 1, - p_this->p_vars + i_new, - (p_this->i_vars - i_new) * sizeof(variable_t) ); + memmove( p_priv->p_vars + i_new + 1, + p_priv->p_vars + i_new, + (p_priv->i_vars - i_new) * sizeof(variable_t) ); - p_this->i_vars++; + p_priv->i_vars++; - p_var = &p_this->p_vars[i_new]; + p_var = &p_priv->p_vars[i_new]; + memset( p_var, 0, sizeof(*p_var) ); p_var->i_hash = HashString( psz_name ); p_var->psz_name = strdup( psz_name ); @@ -238,7 +247,7 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) p_var->pf_cmp = CmpString; p_var->pf_dup = DupString; p_var->pf_free = FreeString; - p_var->val.psz_string = ""; + p_var->val.psz_string = strdup( "" ); break; case VLC_VAR_FLOAT: p_var->pf_cmp = CmpFloat; @@ -274,7 +283,7 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) vlc_value_t val; if( InheritValue( p_this, psz_name, &val, p_var->i_type ) - == VLC_SUCCESS ); + == VLC_SUCCESS ) { /* Free data if needed */ p_var->pf_free( &p_var->val ); @@ -296,7 +305,7 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) } } - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -314,22 +323,23 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) { int i_var, i; variable_t *p_var; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); i_var = GetUnused( p_this, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return i_var; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; if( p_var->i_usage > 1 ) { p_var->i_usage--; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -342,8 +352,7 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) for( i = 0 ; i < p_var->choices.i_count ; i++ ) { p_var->pf_free( &p_var->choices.p_values[i] ); - if( p_var->choices_text.p_values[i].psz_string ) - free( p_var->choices_text.p_values[i].psz_string ); + free( p_var->choices_text.p_values[i].psz_string ); } free( p_var->choices.p_values ); free( p_var->choices_text.p_values ); @@ -356,21 +365,21 @@ int __var_Destroy( vlc_object_t *p_this, const char *psz_name ) } free( p_var->psz_name ); - if( p_var->psz_text ) free( p_var->psz_text ); + free( p_var->psz_text ); - memmove( p_this->p_vars + i_var, - p_this->p_vars + i_var + 1, - (p_this->i_vars - i_var - 1) * sizeof(variable_t) ); + memmove( p_priv->p_vars + i_var, + p_priv->p_vars + i_var + 1, + (p_priv->i_vars - i_var - 1) * sizeof(variable_t) ); - if( (p_this->i_vars & 15) == 0 ) + if( (p_priv->i_vars & 15) == 0 ) { - p_this->p_vars = realloc( p_this->p_vars, - (p_this->i_vars) * sizeof( variable_t ) ); + p_priv->p_vars = realloc( p_priv->p_vars, + (p_priv->i_vars) * sizeof( variable_t ) ); } - p_this->i_vars--; + p_priv->i_vars--; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -390,18 +399,19 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, int i_var, i; variable_t *p_var; vlc_value_t oldval; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_ENOVAR; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; switch( i_action ) { @@ -415,6 +425,12 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->pf_dup( &p_var->min ); CheckValue( p_var, &p_var->val ); break; + case VLC_VAR_GETMIN: + if( p_var->i_type & VLC_VAR_HASMIN ) + { + *p_val = p_var->min; + } + break; case VLC_VAR_SETMAX: if( p_var->i_type & VLC_VAR_HASMAX ) { @@ -425,6 +441,12 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->pf_dup( &p_var->max ); CheckValue( p_var, &p_var->val ); break; + case VLC_VAR_GETMAX: + if( p_var->i_type & VLC_VAR_HASMAX ) + { + *p_val = p_var->max; + } + break; case VLC_VAR_SETSTEP: if( p_var->i_type & VLC_VAR_HASSTEP ) { @@ -435,6 +457,12 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->pf_dup( &p_var->step ); CheckValue( p_var, &p_var->val ); break; + case VLC_VAR_GETSTEP: + if( p_var->i_type & VLC_VAR_HASSTEP ) + { + *p_val = p_var->step; + } + break; case VLC_VAR_ADDCHOICE: /* FIXME: the list is sorted, dude. Use something cleverer. */ for( i = p_var->choices.i_count ; i-- ; ) @@ -477,7 +505,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, if( i == p_var->choices.i_count ) { /* Not found */ - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_EGENERIC; } @@ -491,8 +519,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, } p_var->pf_free( &p_var->choices.p_values[i] ); - if( p_var->choices_text.p_values[i].psz_string ) - free( p_var->choices_text.p_values[i].psz_string ); + free( p_var->choices_text.p_values[i].psz_string ); REMOVE_ELEM( p_var->choices.p_values, p_var->choices.i_count, i ); REMOVE_ELEM( p_var->choices_text.p_values, p_var->choices_text.i_count, i ); @@ -508,10 +535,8 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->pf_free( &p_var->choices.p_values[i] ); } for( i = 0 ; i < p_var->choices_text.i_count ; i++ ) - { - if( p_var->choices_text.p_values[i].psz_string ) - free( p_var->choices_text.p_values[i].psz_string ); - } + free( p_var->choices_text.p_values[i].psz_string ); + if( p_var->choices.i_count ) free( p_var->choices.p_values ); if( p_var->choices_text.i_count ) free( p_var->choices_text.p_values ); @@ -591,8 +616,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, if( p_val2 && p_val2->p_list ) { for( i = 0; i < p_val2->p_list->i_count; i++ ) - if( p_val2->p_list->p_values[i].psz_string ) - free( p_val2->p_list->p_values[i].psz_string ); + free( p_val2->p_list->p_values[i].psz_string ); if( p_val2->p_list->i_count ) { free( p_val2->p_list->p_values ); @@ -602,7 +626,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, } break; case VLC_VAR_SETTEXT: - if( p_var->psz_text ) free( p_var->psz_text ); + free( p_var->psz_text ); if( p_val && p_val->psz_string ) p_var->psz_text = strdup( p_val->psz_string ); break; @@ -617,8 +641,10 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, { vlc_value_t val; - if( InheritValue( p_this, psz_name, &val, p_var->i_type ) - == VLC_SUCCESS ); + if( InheritValue( p_this, + p_val2 ? p_val2->psz_string : psz_name, + &val, p_var->i_type ) + == VLC_SUCCESS ) { /* Duplicate already done */ @@ -650,7 +676,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, callback_entry_t *p_entries = p_var->p_entries; p_var->b_incallback = VLC_TRUE; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); /* The real calls */ for( ; i_entries-- ; ) @@ -659,17 +685,17 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_entries[i_entries].p_data ); } - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { msg_Err( p_this, "variable %s has disappeared", psz_name ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_ENOVAR; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; p_var->b_incallback = VLC_FALSE; } } @@ -679,7 +705,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, break; } - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -694,20 +720,21 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, int __var_Type( vlc_object_t *p_this, const char *psz_name ) { int i_var, i_type; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return 0; } - i_type = p_this->p_vars[i_var].i_type; + i_type = p_priv->p_vars[i_var].i_type; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return i_type; } @@ -724,17 +751,18 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) int i_var; variable_t *p_var; vlc_value_t oldval; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); i_var = GetUnused( p_this, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return i_var; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; /* Duplicate data if needed */ p_var->pf_dup( &val ); @@ -757,7 +785,7 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) callback_entry_t *p_entries = p_var->p_entries; p_var->b_incallback = VLC_TRUE; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); /* The real calls */ for( ; i_entries-- ; ) @@ -766,24 +794,24 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) p_entries[i_entries].p_data ); } - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { msg_Err( p_this, "variable %s has disappeared", psz_name ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_ENOVAR; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; p_var->b_incallback = VLC_FALSE; } /* Free data if needed */ p_var->pf_free( &oldval ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -800,18 +828,19 @@ int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) { int i_var; variable_t *p_var; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_ENOVAR; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; /* Really get the variable */ *p_val = p_var->val; @@ -819,11 +848,30 @@ int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) /* Duplicate value if needed */ p_var->pf_dup( p_val ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } + +/** + * Finds a process-wide mutex, creates it if needed, and locks it. + * Unlock with vlc_mutex_unlock(). + */ +vlc_mutex_t *var_AcquireMutex( const char *name ) +{ + libvlc_global_data_t *p_global = vlc_global(); + vlc_value_t val; + + if( var_Create( p_global, name, VLC_VAR_MUTEX ) ) + return NULL; + + var_Get( p_global, name, &val ); + vlc_mutex_lock( val.p_address ); + return val.p_address; +} + + /** * Register a callback in a variable * @@ -846,27 +894,28 @@ int __var_AddCallback( vlc_object_t *p_this, const char *psz_name, int i_var; variable_t *p_var; callback_entry_t entry; + vlc_object_internals_t *p_priv = p_this->p_internals; entry.pf_callback = pf_callback; entry.p_data = p_data; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); i_var = GetUnused( p_this, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return i_var; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; INSERT_ELEM( p_var->p_entries, p_var->i_entries, p_var->i_entries, entry ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -882,17 +931,18 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, { int i_entry, i_var; variable_t *p_var; + vlc_object_internals_t *p_priv = p_this->p_internals; - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); i_var = GetUnused( p_this, psz_name ); if( i_var < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return i_var; } - p_var = &p_this->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; for( i_entry = p_var->i_entries ; i_entry-- ; ) { @@ -905,17 +955,222 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, if( i_entry < 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_EGENERIC; } REMOVE_ELEM( p_var->p_entries, p_var->i_entries, i_entry ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } +/** + * Trigger callback on a variable + * + * \param p_this The object that hold the variable + * \param psz_name The name of the variable + */ +int __var_TriggerCallback( vlc_object_t *p_this, const char *psz_name ) +{ + int i_var; + variable_t *p_var; + vlc_value_t oldval; + vlc_object_internals_t *p_priv = p_this->p_internals; + + vlc_mutex_lock( &p_priv->var_lock ); + + i_var = GetUnused( p_this, psz_name ); + if( i_var < 0 ) + { + vlc_mutex_unlock( &p_priv->var_lock ); + return i_var; + } + + p_var = &p_priv->p_vars[i_var]; + + /* Backup needed stuff */ + oldval = p_var->val; + + /* Deal with callbacks. Tell we're in a callback, release the lock, + * call stored functions, retake the lock. */ + if( p_var->i_entries ) + { + int i_var; + int i_entries = p_var->i_entries; + callback_entry_t *p_entries = p_var->p_entries; + + p_var->b_incallback = VLC_TRUE; + vlc_mutex_unlock( &p_priv->var_lock ); + + /* The real calls */ + for( ; i_entries-- ; ) + { + p_entries[i_entries].pf_callback( p_this, psz_name, oldval, oldval, + p_entries[i_entries].p_data ); + } + + vlc_mutex_lock( &p_priv->var_lock ); + + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + if( i_var < 0 ) + { + msg_Err( p_this, "variable %s has disappeared", psz_name ); + vlc_mutex_unlock( &p_priv->var_lock ); + return VLC_ENOVAR; + } + + p_var = &p_priv->p_vars[i_var]; + p_var->b_incallback = VLC_FALSE; + } + + vlc_mutex_unlock( &p_priv->var_lock ); + return VLC_SUCCESS; +} + +/** Parse a stringified option + * This function parse a string option and create the associated object + * variable + * The option must be of the form "[no[-]]foo[=bar]" where foo is the + * option name and bar is the value of the option. + * \param p_obj the object in which the variable must be created + * \param psz_option the option to parse + * \param trusted whether the option is set by a trusted input or not + * \return nothing + */ +void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, + bool trusted ) +{ + char *psz_name, *psz_value; + int i_type; + vlc_bool_t b_isno = VLC_FALSE; + vlc_value_t val; + + val.psz_string = NULL; + + /* It's too much of a hassle to remove the ':' when we parse + * the cmd line :) */ + if( psz_option[0] == ':' ) + psz_option++; + + if( !psz_option[0] ) + return; + + psz_name = strdup( psz_option ); + if( psz_name == NULL ) + return; + + psz_value = strchr( psz_name, '=' ); + if( psz_value != NULL ) + *psz_value++ = '\0'; + + /* FIXME: :programs should be handled generically */ + if( !strcmp( psz_name, "programs" ) ) + i_type = VLC_VAR_LIST; + else + i_type = config_GetType( p_obj, psz_name ); + + if( !i_type && !psz_value ) + { + /* check for "no-foo" or "nofoo" */ + if( !strncmp( psz_name, "no-", 3 ) ) + { + memmove( psz_name, psz_name + 3, strlen(psz_name) + 1 - 3 ); + } + else if( !strncmp( psz_name, "no", 2 ) ) + { + memmove( psz_name, psz_name + 2, strlen(psz_name) + 1 - 2 ); + } + else goto cleanup; /* Option doesn't exist */ + + b_isno = VLC_TRUE; + i_type = config_GetType( p_obj, psz_name ); + } + if( !i_type ) goto cleanup; /* Option doesn't exist */ + + if( ( i_type != VLC_VAR_BOOL ) && + ( !psz_value || !*psz_value ) ) goto cleanup; /* Invalid value */ + + /* check if option is unsafe */ + if( !trusted ) + { + module_config_t *p_config = config_FindConfig( p_obj, psz_name ); + if( !p_config->b_safe ) + { + msg_Err( p_obj, "unsafe option \"%s\" has been ignored for " + "security reasons", psz_name ); + return; + } + } + + /* Create the variable in the input object. + * Children of the input object will be able to retreive this value + * thanks to the inheritance property of the object variables. */ + var_Create( p_obj, psz_name, i_type ); + + switch( i_type ) + { + case VLC_VAR_BOOL: + val.b_bool = !b_isno; + break; + + case VLC_VAR_INTEGER: + val.i_int = strtol( psz_value, NULL, 0 ); + break; + + case VLC_VAR_FLOAT: + val.f_float = atof( psz_value ); + break; + + case VLC_VAR_STRING: + case VLC_VAR_MODULE: + case VLC_VAR_FILE: + case VLC_VAR_DIRECTORY: + val.psz_string = psz_value; + break; + + case VLC_VAR_LIST: + { + char *psz_orig, *psz_var; + vlc_list_t *p_list = malloc(sizeof(vlc_list_t)); + val.p_list = p_list; + p_list->i_count = 0; + + psz_var = psz_orig = strdup(psz_value); + while( psz_var && *psz_var ) + { + char *psz_item = psz_var; + vlc_value_t val2; + while( *psz_var && *psz_var != ',' ) psz_var++; + if( *psz_var == ',' ) + { + *psz_var = '\0'; + psz_var++; + } + val2.i_int = strtol( psz_item, NULL, 0 ); + INSERT_ELEM( p_list->p_values, p_list->i_count, + p_list->i_count, val2 ); + /* p_list->i_count is incremented twice by INSERT_ELEM */ + p_list->i_count--; + INSERT_ELEM( p_list->pi_types, p_list->i_count, + p_list->i_count, VLC_VAR_INTEGER ); + } + free( psz_orig ); + break; + } + + default: + goto cleanup; + } + + var_Set( p_obj, psz_name, val ); + +cleanup: + free( psz_name ); +} + + /* Following functions are local */ /***************************************************************************** @@ -927,16 +1182,17 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, static int GetUnused( vlc_object_t *p_this, const char *psz_name ) { int i_var, i_tries = 0; + vlc_object_internals_t *p_priv = p_this->p_internals; while( VLC_TRUE ) { - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var < 0 ) { return VLC_ENOVAR; } - if( ! p_this->p_vars[i_var].b_incallback ) + if( ! p_priv->p_vars[i_var].b_incallback ) { return i_var; } @@ -947,9 +1203,9 @@ static int GetUnused( vlc_object_t *p_this, const char *psz_name ) return VLC_ETIMEOUT; } - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); msleep( THREAD_SLEEP ); - vlc_mutex_lock( &p_this->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); } } @@ -1120,7 +1376,7 @@ static int LookupInner( variable_t *p_vars, int i_count, uint32_t i_hash ) * This function checks p_val's value against p_var's limitations such as * minimal and maximal value, step, in-list position, and modifies p_val if * necessary. - *****************************************************************************/ + ****************************************************************************/ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) { /* Check that our variable is in the list */ @@ -1232,29 +1488,31 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, break; case VLC_VAR_LIST: { - char * psz_var = config_GetPsz( p_this, psz_name ); + char *psz_orig, *psz_var; vlc_list_t *p_list = malloc(sizeof(vlc_list_t)); p_val->p_list = p_list; p_list->i_count = 0; - while ( *psz_var ) + + psz_var = psz_orig = config_GetPsz( p_this, psz_name ); + while( psz_var && *psz_var ) { - char * psz_item = psz_var; + char *psz_item = psz_var; vlc_value_t val; - while ( *psz_var && *psz_var != ',' ) - psz_var++; - if ( *psz_var == ',' ) + while( *psz_var && *psz_var != ',' ) psz_var++; + if( *psz_var == ',' ) { *psz_var = '\0'; psz_var++; } val.i_int = strtol( psz_item, NULL, 0 ); - INSERT_ELEM( p_list->p_values, p_list->i_count, p_list->i_count, - val ); + INSERT_ELEM( p_list->p_values, p_list->i_count, + p_list->i_count, val ); /* p_list->i_count is incremented twice by INSERT_ELEM */ p_list->i_count--; - INSERT_ELEM( p_list->pi_types, p_list->i_count, p_list->i_count, - VLC_VAR_INTEGER ); + INSERT_ELEM( p_list->pi_types, p_list->i_count, + p_list->i_count, VLC_VAR_INTEGER ); } + free( psz_orig ); break; } default: @@ -1265,16 +1523,17 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, return VLC_SUCCESS; } + vlc_object_internals_t *p_priv = p_this->p_parent->p_internals; + /* Look for the variable */ - vlc_mutex_lock( &p_this->p_parent->var_lock ); + vlc_mutex_lock( &p_priv->var_lock ); - i_var = Lookup( p_this->p_parent->p_vars, p_this->p_parent->i_vars, - psz_name ); + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); if( i_var >= 0 ) { /* We found it! */ - p_var = &p_this->p_parent->p_vars[i_var]; + p_var = &p_priv->p_vars[i_var]; /* Really get the variable */ *p_val = p_var->val; @@ -1282,13 +1541,71 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, /* Duplicate value if needed */ p_var->pf_dup( p_val ); - vlc_mutex_unlock( &p_this->p_parent->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } - vlc_mutex_unlock( &p_this->p_parent->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); /* We're still not there */ return InheritValue( p_this->p_parent, psz_name, p_val, i_type ); } + +/********************************************************************** + * Execute a var command on an object identified by its name + **********************************************************************/ +int __var_Command( vlc_object_t *p_this, const char *psz_name, + const char *psz_cmd, const char *psz_arg, char **psz_msg ) +{ + vlc_object_t *p_obj = vlc_object_find_name( p_this->p_libvlc, + psz_name, FIND_CHILD ); + int i_type, i_ret; + + if( !p_obj ) + { + if( psz_msg ) + *psz_msg = strdup( "Unknown destination object." ); + return VLC_ENOOBJ; + } + + i_type = var_Type( p_obj, psz_cmd ); + if( !( i_type&VLC_VAR_ISCOMMAND ) ) + { + vlc_object_release( p_obj ); + if( psz_msg ) + *psz_msg = strdup( "Variable doesn't exist or isn't a command." ); + return VLC_EGENERIC; + } + + i_type &= 0xf0; + switch( i_type ) + { + case VLC_VAR_INTEGER: + i_ret = var_SetInteger( p_obj, psz_cmd, atoi( psz_arg ) ); + break; + case VLC_VAR_FLOAT: + i_ret = var_SetFloat( p_obj, psz_cmd, atof( psz_arg ) ); + break; + case VLC_VAR_STRING: + i_ret = var_SetString( p_obj, psz_cmd, psz_arg ); + break; + case VLC_VAR_BOOL: + i_ret = var_SetBool( p_obj, psz_cmd, atoi( psz_arg ) ); + break; + default: + i_ret = VLC_EGENERIC; + break; + } + + vlc_object_release( p_obj ); + + if( psz_msg ) + { + *psz_msg = (char*)malloc( 80 ); + sprintf( *psz_msg, "%s on object %s returned %i (%s)", + psz_cmd, psz_name, i_ret, vlc_error( i_ret ) ); + } + + return i_ret; +}