X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;ds=sidebyside;f=src%2Fmisc%2Fvariables.c;h=f8bf3d8e951760f77f82c2bac06fa683677cc079;hb=9c24e1931faef97958eeb3287d0de778d4d07c89;hp=c6b4c24fe22f9e805da91ddaae8da655d22270f1;hpb=b25c2e85e26c75330d22ffdf2672eb71341928e1;p=vlc diff --git a/src/misc/variables.c b/src/misc/variables.c index c6b4c24fe2..f8bf3d8e95 100644 --- a/src/misc/variables.c +++ b/src/misc/variables.c @@ -24,12 +24,18 @@ /***************************************************************************** * Preamble *****************************************************************************/ -#include - -#ifdef HAVE_STDLIB_H -# include /* realloc() */ +#ifdef HAVE_CONFIG_H +# include "config.h" #endif +#include +#include "variables.h" + +#include "libvlc.h" + +#include "vlc_interface.h" +#include + /***************************************************************************** * Private types *****************************************************************************/ @@ -48,7 +54,13 @@ static int CmpTime( vlc_value_t v, vlc_value_t w ) { return v.i_time == w.i_time ? 0 : v.i_time > w.i_time ? 1 : -1; } -static int CmpString( vlc_value_t v, vlc_value_t w ) { return strcmp( v.psz_string, w.psz_string ); } +static int CmpString( vlc_value_t v, vlc_value_t w ) +{ + if( !v.psz_string ) + return !w.psz_string ? 0 : -1; + else + return !w.psz_string ? 1 : strcmp( v.psz_string, w.psz_string ); +} static int CmpFloat( vlc_value_t v, vlc_value_t w ) { return v.f_float == w.f_float ? 0 : v.f_float > w.f_float ? 1 : -1; } static int CmpAddress( vlc_value_t v, vlc_value_t w ) { return v.p_address == w.p_address ? 0 : v.p_address > w.p_address ? 1 : -1; } @@ -56,7 +68,10 @@ static int CmpAddress( vlc_value_t v, vlc_value_t w ) { return v.p_address == w. * Local duplication functions, and local deallocation functions *****************************************************************************/ static void DupDummy( vlc_value_t *p_val ) { (void)p_val; /* unused */ } -static void DupString( vlc_value_t *p_val ) { p_val->psz_string = strdup( p_val->psz_string ); } +static void DupString( vlc_value_t *p_val ) +{ + p_val->psz_string = strdup( p_val->psz_string ? p_val->psz_string : "" ); +} static void DupList( vlc_value_t *p_val ) { @@ -79,7 +94,7 @@ static void DupList( vlc_value_t *p_val ) { p_list->p_values[i] = p_val->p_list->p_values[i]; p_list->pi_types[i] = p_val->p_list->pi_types[i]; - switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE ) + switch( p_val->p_list->pi_types[i] & VLC_VAR_CLASS ) { case VLC_VAR_STRING: @@ -102,7 +117,7 @@ static void FreeList( vlc_value_t *p_val ) int i; for( i = 0; i < p_val->p_list->i_count; i++ ) { - switch( p_val->p_list->pi_types[i] & VLC_VAR_TYPE ) + switch( p_val->p_list->pi_types[i] & VLC_VAR_CLASS ) { case VLC_VAR_STRING: FreeString( &p_val->p_list->p_values[i] ); @@ -123,6 +138,17 @@ static void FreeList( vlc_value_t *p_val ) free( p_val->p_list ); } +static const struct variable_ops_t +void_ops = { NULL, DupDummy, FreeDummy, }, +addr_ops = { CmpAddress, DupDummy, FreeDummy, }, +bool_ops = { CmpBool, DupDummy, FreeDummy, }, +float_ops = { CmpFloat, DupDummy, FreeDummy, }, +int_ops = { CmpInt, DupDummy, FreeDummy, }, +list_ops = { CmpAddress, DupList, FreeList, }, +mutex_ops = { CmpAddress, DupDummy, FreeMutex, }, +string_ops = { CmpString, DupString, FreeString, }, +time_ops = { CmpTime, DupDummy, FreeDummy, }; + /***************************************************************************** * Local prototypes *****************************************************************************/ @@ -130,8 +156,7 @@ static int GetUnused ( vlc_object_t *, const char * ); static uint32_t HashString ( const char * ); static int Insert ( variable_t *, int, const char * ); static int InsertInner ( variable_t *, int, uint32_t ); -static int Lookup ( variable_t *, int, const char * ); -static int LookupInner ( variable_t *, int, uint32_t ); +static int Lookup ( variable_t *, size_t, const char * ); static void CheckValue ( variable_t *, vlc_value_t * ); @@ -155,44 +180,47 @@ 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 = vlc_internals( p_this ); - 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 ); @@ -202,9 +230,6 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) p_var->i_type = i_type & ~VLC_VAR_DOINHERIT; memset( &p_var->val, 0, sizeof(vlc_value_t) ); - p_var->pf_dup = DupDummy; - p_var->pf_free = FreeDummy; - p_var->i_usage = 1; p_var->i_default = -1; @@ -213,72 +238,65 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) p_var->choices_text.i_count = 0; p_var->choices_text.p_values = NULL; - p_var->b_incallback = VLC_FALSE; + p_var->b_incallback = false; p_var->i_entries = 0; p_var->p_entries = NULL; /* Always initialize the variable, even if it is a list variable; this * will lead to errors if the variable is not initialized, but it will * not cause crashes in the variable handling. */ - switch( i_type & VLC_VAR_TYPE ) + switch( i_type & VLC_VAR_CLASS ) { case VLC_VAR_BOOL: - p_var->pf_cmp = CmpBool; - p_var->val.b_bool = VLC_FALSE; + p_var->ops = &bool_ops; + p_var->val.b_bool = false; break; case VLC_VAR_INTEGER: - case VLC_VAR_HOTKEY: - p_var->pf_cmp = CmpInt; + p_var->ops = &int_ops; p_var->val.i_int = 0; break; case VLC_VAR_STRING: - case VLC_VAR_MODULE: - case VLC_VAR_FILE: - case VLC_VAR_DIRECTORY: - case VLC_VAR_VARIABLE: - p_var->pf_cmp = CmpString; - p_var->pf_dup = DupString; - p_var->pf_free = FreeString; - p_var->val.psz_string = ""; + p_var->ops = &string_ops; + p_var->val.psz_string = NULL; break; case VLC_VAR_FLOAT: - p_var->pf_cmp = CmpFloat; + p_var->ops = &float_ops; p_var->val.f_float = 0.0; break; case VLC_VAR_TIME: - p_var->pf_cmp = CmpTime; + p_var->ops = &time_ops; p_var->val.i_time = 0; break; case VLC_VAR_ADDRESS: - p_var->pf_cmp = CmpAddress; + p_var->ops = &addr_ops; p_var->val.p_address = NULL; break; case VLC_VAR_MUTEX: - p_var->pf_cmp = CmpAddress; - p_var->pf_free = FreeMutex; + p_var->ops = &mutex_ops; p_var->val.p_address = malloc( sizeof(vlc_mutex_t) ); - vlc_mutex_init( p_this, (vlc_mutex_t*)p_var->val.p_address ); + vlc_mutex_init( (vlc_mutex_t*)p_var->val.p_address ); break; case VLC_VAR_LIST: - p_var->pf_cmp = CmpAddress; - p_var->pf_dup = DupList; - p_var->pf_free = FreeList; + p_var->ops = &list_ops; p_var->val.p_list = &dummy_null_list; break; + default: + p_var->ops = &void_ops; + break; } /* Duplicate the default data we stored. */ - p_var->pf_dup( &p_var->val ); + p_var->ops->pf_dup( &p_var->val ); if( i_type & VLC_VAR_DOINHERIT ) { 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 ); + p_var->ops->pf_free( &p_var->val ); /* Set the variable */ p_var->val = val; @@ -291,13 +309,13 @@ int __var_Create( vlc_object_t *p_this, const char *psz_name, int i_type ) 0, val ); INSERT_ELEM( p_var->choices_text.p_values, p_var->choices_text.i_count, 0, val ); - p_var->pf_dup( &p_var->choices.p_values[0] ); + p_var->ops->pf_dup( &p_var->choices.p_values[0] ); p_var->choices_text.p_values[0].psz_string = NULL; } } } - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -315,36 +333,36 @@ 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 = vlc_internals( p_this ); - 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; } /* Free value if needed */ - p_var->pf_free( &p_var->val ); + p_var->ops->pf_free( &p_var->val ); /* Free choice list if needed */ if( p_var->choices.i_count ) { 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 ); + p_var->ops->pf_free( &p_var->choices.p_values[i] ); + free( p_var->choices_text.p_values[i].psz_string ); } free( p_var->choices.p_values ); free( p_var->choices_text.p_values ); @@ -357,21 +375,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; } @@ -391,74 +409,78 @@ 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 = vlc_internals( p_this ); - 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 ) { case VLC_VAR_SETMIN: if( p_var->i_type & VLC_VAR_HASMIN ) { - p_var->pf_free( &p_var->min ); + p_var->ops->pf_free( &p_var->min ); } p_var->i_type |= VLC_VAR_HASMIN; p_var->min = *p_val; - p_var->pf_dup( &p_var->min ); + p_var->ops->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 ) { - p_var->pf_free( &p_var->max ); + p_var->ops->pf_free( &p_var->max ); } p_var->i_type |= VLC_VAR_HASMAX; p_var->max = *p_val; - p_var->pf_dup( &p_var->max ); + p_var->ops->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 ) { - p_var->pf_free( &p_var->step ); + p_var->ops->pf_free( &p_var->step ); } p_var->i_type |= VLC_VAR_HASSTEP; p_var->step = *p_val; - p_var->pf_dup( &p_var->step ); + p_var->ops->pf_dup( &p_var->step ); CheckValue( p_var, &p_var->val ); break; - case VLC_VAR_ADDCHOICE: - /* FIXME: the list is sorted, dude. Use something cleverer. */ - for( i = p_var->choices.i_count ; i-- ; ) - { - if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) < 0 ) - { - break; - } - } - - /* The new place is i+1 */ - i++; - - if( p_var->i_default >= i ) + case VLC_VAR_GETSTEP: + if( p_var->i_type & VLC_VAR_HASSTEP ) { - p_var->i_default++; + *p_val = p_var->step; } + break; + case VLC_VAR_ADDCHOICE: + i = p_var->choices.i_count; INSERT_ELEM( p_var->choices.p_values, p_var->choices.i_count, i, *p_val ); INSERT_ELEM( p_var->choices_text.p_values, p_var->choices_text.i_count, i, *p_val ); - p_var->pf_dup( &p_var->choices.p_values[i] ); + p_var->ops->pf_dup( &p_var->choices.p_values[i] ); p_var->choices_text.p_values[i].psz_string = ( p_val2 && p_val2->psz_string ) ? strdup( p_val2->psz_string ) : NULL; @@ -466,10 +488,9 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, CheckValue( p_var, &p_var->val ); break; case VLC_VAR_DELCHOICE: - /* FIXME: the list is sorted, dude. Use something cleverer. */ for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) + if( p_var->ops->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) { break; } @@ -478,7 +499,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,9 +512,8 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, p_var->i_default = -1; } - 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 ); + p_var->ops->pf_free( &p_var->choices.p_values[i] ); + 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 ); @@ -506,13 +526,11 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, case VLC_VAR_CLEARCHOICES: for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - p_var->pf_free( &p_var->choices.p_values[i] ); + p_var->ops->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 ); @@ -526,7 +544,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, /* FIXME: the list is sorted, dude. Use something cleverer. */ for( i = 0 ; i < p_var->choices.i_count ; i++ ) { - if( p_var->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) + if( p_var->ops->pf_cmp( p_var->choices.p_values[i], *p_val ) == 0 ) { break; } @@ -543,7 +561,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, break; case VLC_VAR_SETVALUE: /* Duplicate data if needed */ - p_var->pf_dup( p_val ); + p_var->ops->pf_dup( p_val ); /* Backup needed stuff */ oldval = p_var->val; /* Check boundaries and list */ @@ -551,7 +569,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, /* Set the variable */ p_var->val = *p_val; /* Free data if needed */ - p_var->pf_free( &oldval ); + p_var->ops->pf_free( &oldval ); break; case VLC_VAR_GETCHOICES: case VLC_VAR_GETLIST: @@ -577,7 +595,7 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, { p_val->p_list->p_values[i] = p_var->choices.p_values[i]; p_val->p_list->pi_types[i] = p_var->i_type; - p_var->pf_dup( &p_val->p_list->p_values[i] ); + p_var->ops->pf_dup( &p_val->p_list->p_values[i] ); if( p_val2 ) { p_val2->p_list->p_values[i].psz_string = @@ -592,8 +610,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 ); @@ -603,9 +620,11 @@ 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 ); + else + p_val->psz_text = NULL; break; case VLC_VAR_GETTEXT: p_val->psz_string = NULL; @@ -618,8 +637,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 */ @@ -630,57 +651,26 @@ int __var_Change( vlc_object_t *p_this, const char *psz_name, /* Set the variable */ p_var->val = val; /* Free data if needed */ - p_var->pf_free( &oldval ); + p_var->ops->pf_free( &oldval ); } if( p_val ) { *p_val = p_var->val; - p_var->pf_dup( p_val ); + p_var->ops->pf_dup( p_val ); } } break; - case VLC_VAR_TRIGGER_CALLBACKS: - { - /* 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_this->var_lock ); - - /* The real calls */ - for( ; i_entries-- ; ) - { - p_entries[i_entries].pf_callback( p_this, psz_name, p_var->val, p_var->val, - p_entries[i_entries].p_data ); - } - - vlc_mutex_lock( &p_this->var_lock ); - - i_var = Lookup( p_this->p_vars, p_this->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 ); - return VLC_ENOVAR; - } - - p_var = &p_this->p_vars[i_var]; - p_var->b_incallback = VLC_FALSE; - } - } + + case VLC_VAR_SETISCOMMAND: + p_var->i_type |= VLC_VAR_ISCOMMAND; break; default: break; } - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -695,50 +685,48 @@ 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 = vlc_internals( p_this ); - 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; } -/** - * Set a variable's value - * - * \param p_this The object that hold the variable - * \param psz_name The name of the variable - * \param val the value to set - */ -int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) +int var_SetChecked( vlc_object_t *p_this, const char *psz_name, + int expected_type, vlc_value_t val ) { int i_var; variable_t *p_var; vlc_value_t oldval; + vlc_object_internals_t *p_priv = vlc_internals( p_this ); - 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]; + assert( (p_var->i_type & VLC_VAR_CLASS) == 0 || expected_type == 0 || + (p_var->i_type & VLC_VAR_CLASS) == expected_type ); /* Duplicate data if needed */ - p_var->pf_dup( &val ); + p_var->ops->pf_dup( &val ); /* Backup needed stuff */ oldval = p_var->val; @@ -757,8 +745,8 @@ int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) 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_this->var_lock ); + p_var->b_incallback = true; + vlc_mutex_unlock( &p_priv->var_lock ); /* The real calls */ for( ; i_entries-- ; ) @@ -767,62 +755,82 @@ 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->b_incallback = VLC_FALSE; + p_var = &p_priv->p_vars[i_var]; + p_var->b_incallback = false; + vlc_cond_broadcast( &p_priv->var_wait ); } /* Free data if needed */ - p_var->pf_free( &oldval ); + p_var->ops->pf_free( &oldval ); - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } + /** - * Get a variable's value + * Set a variable's value * - * \param p_this The object that holds the variable + * \param p_this The object that hold the variable * \param psz_name The name of the variable - * \param p_val Pointer to a vlc_value_t that will hold the variable's value - * after the function is finished + * \param val the value to set */ -int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) +int __var_Set( vlc_object_t *p_this, const char *psz_name, vlc_value_t val ) { - int i_var; - variable_t *p_var; + return var_SetChecked( p_this, psz_name, 0, val ); +} - vlc_mutex_lock( &p_this->var_lock ); +int var_GetChecked( vlc_object_t *p_this, const char *psz_name, + int expected_type, vlc_value_t *p_val ) +{ + vlc_object_internals_t *p_priv = vlc_internals( p_this ); + int i_var, err = VLC_SUCCESS; - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + vlc_mutex_lock( &p_priv->var_lock ); - if( i_var < 0 ) + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + if( i_var >= 0 ) { - vlc_mutex_unlock( &p_this->var_lock ); - return VLC_ENOVAR; - } + variable_t *p_var = &p_priv->p_vars[i_var]; - p_var = &p_this->p_vars[i_var]; + assert( (p_var->i_type & VLC_VAR_CLASS) == 0 || expected_type == 0 || + (p_var->i_type & VLC_VAR_CLASS) == expected_type ); - /* Really get the variable */ - *p_val = p_var->val; + /* Really get the variable */ + *p_val = p_var->val; - /* Duplicate value if needed */ - p_var->pf_dup( p_val ); + /* Duplicate value if needed */ + p_var->ops->pf_dup( p_val ); + } + else + err = VLC_ENOVAR; - vlc_mutex_unlock( &p_this->var_lock ); + vlc_mutex_unlock( &p_priv->var_lock ); + return err; +} - return VLC_SUCCESS; +/** + * Get a variable's value + * + * \param p_this The object that holds the variable + * \param psz_name The name of the variable + * \param p_val Pointer to a vlc_value_t that will hold the variable's value + * after the function is finished + */ +int __var_Get( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val ) +{ + return var_GetChecked( p_this, psz_name, 0, p_val ); } /** @@ -847,27 +855,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 = vlc_internals( p_this ); 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; } @@ -883,17 +892,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 = vlc_internals( p_this ); - 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-- ; ) { @@ -906,14 +916,78 @@ 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 = vlc_internals( p_this ); + + 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 = 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 = false; + vlc_cond_broadcast( &p_priv->var_wait ); + } + + vlc_mutex_unlock( &p_priv->var_lock ); return VLC_SUCCESS; } @@ -924,30 +998,34 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name, * 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 ) +void var_OptionParse( vlc_object_t *p_obj, const char *psz_option, + bool trusted ) { - char *psz_name, *psz_value = strchr( psz_option, '=' ); - int i_name_len, i_type; - vlc_bool_t b_isno = VLC_FALSE; + char *psz_name, *psz_value; + int i_type; + bool b_isno = false; vlc_value_t val; - if( psz_value ) i_name_len = psz_value - psz_option; - else i_name_len = strlen( psz_option ); + val.psz_string = NULL; - /* It's too much of an hassle to remove the ':' when we parse + /* It's too much of a hassle to remove the ':' when we parse * the cmd line :) */ - if( i_name_len && *psz_option == ':' ) - { + if( psz_option[0] == ':' ) psz_option++; - i_name_len--; - } - if( i_name_len == 0 ) return; + if( !psz_option[0] ) + return; - psz_name = strndup( psz_option, i_name_len ); - if( psz_value ) psz_value++; + 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" ) ) @@ -968,16 +1046,27 @@ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option ) } else goto cleanup; /* Option doesn't exist */ - b_isno = VLC_TRUE; + b_isno = true; i_type = config_GetType( p_obj, psz_name ); - - if( !i_type ) goto cleanup; /* Option doesn't exist */ } - else if( !i_type ) goto cleanup; /* Option doesn't exist */ + 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 || !p_config->b_safe ) + { + msg_Err( p_obj, "unsafe option \"%s\" has been ignored for " + "security reasons", psz_name ); + free( 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. */ @@ -1030,57 +1119,55 @@ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option ) INSERT_ELEM( p_list->pi_types, p_list->i_count, p_list->i_count, VLC_VAR_INTEGER ); } - if( psz_orig ) free( psz_orig ); + free( psz_orig ); break; } default: goto cleanup; - break; } var_Set( p_obj, psz_name, val ); - cleanup: - if( psz_name ) free( psz_name ); - return; + // If that's a list, remove all elements allocated + if( i_type == VLC_VAR_LIST ) + FreeList( &val ); + +cleanup: + free( psz_name ); } /* Following functions are local */ /***************************************************************************** - * GetUnused: find an unused variable from its name + * GetUnused: find an unused (not in callback) variable from its name ***************************************************************************** * We do i_tries tries before giving up, just in case the variable is being * modified and called from a callback. *****************************************************************************/ static int GetUnused( vlc_object_t *p_this, const char *psz_name ) { - int i_var, i_tries = 0; + vlc_object_internals_t *p_priv = vlc_internals( p_this ); - while( VLC_TRUE ) + while( true ) { - i_var = Lookup( p_this->p_vars, p_this->i_vars, psz_name ); + int i_var; + + 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; } - if( i_tries++ > 100 ) - { - msg_Err( p_this, "caught in a callback deadlock?" ); - return VLC_ETIMEOUT; - } - - vlc_mutex_unlock( &p_this->var_lock ); - msleep( THREAD_SLEEP ); - vlc_mutex_lock( &p_this->var_lock ); + mutex_cleanup_push( &p_priv->var_lock ); + vlc_cond_wait( &p_priv->var_wait, &p_priv->var_lock ); + vlc_cleanup_pop( ); } } @@ -1156,95 +1243,59 @@ static int InsertInner( variable_t *p_vars, int i_count, uint32_t i_hash ) return i_middle + 1; } +static int u32cmp( const void *key, const void *data ) +{ + const variable_t *p_var = data; + uint32_t hash = *(const uint32_t *)key ; + + if( hash > p_var->i_hash ) + return 1; + if( hash < p_var->i_hash ) + return -1; + return 0; +} + /***************************************************************************** * Lookup: find an existing variable given its name ***************************************************************************** * We use a recursive inner function indexed on the hash. Care is taken of * possible hash collisions. - * XXX: does this really need to be written recursively? *****************************************************************************/ -static int Lookup( variable_t *p_vars, int i_count, const char *psz_name ) +static int Lookup( variable_t *p_vars, size_t i_count, const char *psz_name ) { + variable_t *p_var; uint32_t i_hash; - int i, i_pos; - - if( i_count == 0 ) - { - return -1; - } i_hash = HashString( psz_name ); - - i_pos = LookupInner( p_vars, i_count, i_hash ); + p_var = bsearch( &i_hash, p_vars, i_count, sizeof( *p_var ), u32cmp ); /* Hash not found */ - if( i_hash != p_vars[i_pos].i_hash ) - { + if( p_var == NULL ) return -1; - } - /* Hash found, entry found */ - if( !strcmp( psz_name, p_vars[i_pos].psz_name ) ) - { - return i_pos; - } + assert( i_count > 0 ); - /* Hash collision! This should be very rare, but we cannot guarantee - * it will never happen. Just do an exhaustive search amongst all - * entries with the same hash. */ - for( i = i_pos - 1 ; i > 0 && i_hash == p_vars[i].i_hash ; i-- ) - { - if( !strcmp( psz_name, p_vars[i].psz_name ) ) - { - return i; - } - } + /* Find the first entry with the right hash */ + while( (p_var > p_vars) && (i_hash == p_var[-1].i_hash) ) + p_var--; + + assert( p_var->i_hash == i_hash ); - for( i = i_pos + 1 ; i < i_count && i_hash == p_vars[i].i_hash ; i++ ) + /* Hash collision should be very unlikely, but we cannot guarantee + * it will never happen. So we do an exhaustive search amongst all + * entries with the same hash. Typically, there is only one anyway. */ + for( variable_t *p_end = p_vars + i_count; + (p_var < p_end) && (i_hash == p_var->i_hash); + p_var++ ) { - if( !strcmp( psz_name, p_vars[i].psz_name ) ) - { - return i; - } + if( !strcmp( psz_name, p_var->psz_name ) ) + return p_var - p_vars; } /* Hash found, but entry not found */ return -1; } -static int LookupInner( variable_t *p_vars, int i_count, uint32_t i_hash ) -{ - int i_middle; - - if( i_hash <= p_vars[0].i_hash ) - { - return 0; - } - - if( i_hash >= p_vars[i_count-1].i_hash ) - { - return i_count - 1; - } - - i_middle = i_count / 2; - - /* We know that 0 < i_middle */ - if( i_hash < p_vars[i_middle].i_hash ) - { - return LookupInner( p_vars, i_middle, i_hash ); - } - - /* We know that i_middle + 1 < i_count */ - if( i_hash > p_vars[i_middle].i_hash ) - { - return i_middle + LookupInner( p_vars + i_middle, - i_count - i_middle, - i_hash ); - } - - return i_middle; -} - /***************************************************************************** * CheckValue: check that a value is valid wrt. a variable ***************************************************************************** @@ -1262,7 +1313,7 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) /* FIXME: the list is sorted, dude. Use something cleverer. */ for( i = p_var->choices.i_count ; i-- ; ) { - if( p_var->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 ) + if( p_var->ops->pf_cmp( *p_val, p_var->choices.p_values[i] ) == 0 ) { break; } @@ -1272,10 +1323,10 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) if( i < 0 ) { /* Free the old variable, get the new one, dup it */ - p_var->pf_free( p_val ); + p_var->ops->pf_free( p_val ); *p_val = p_var->choices.p_values[p_var->i_default >= 0 ? p_var->i_default : 0 ]; - p_var->pf_dup( p_val ); + p_var->ops->pf_dup( p_val ); } } @@ -1329,7 +1380,8 @@ static void CheckValue ( variable_t *p_var, vlc_value_t *p_val ) /***************************************************************************** * InheritValue: try to inherit the value of this variable from the same one - * in our closest parent. + * in our closest parent, libvlc or ultimately from the configuration. + * The function should always be entered with the object var_lock locked. *****************************************************************************/ static int InheritValue( vlc_object_t *p_this, const char *psz_name, vlc_value_t *p_val, int i_type ) @@ -1337,17 +1389,44 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, int i_var; variable_t *p_var; - /* No need to take the structure lock, - * we are only looking for our parents */ - - if( !p_this->p_parent ) + if( p_this->p_parent || ( p_this->p_libvlc && p_this != (vlc_object_t*) p_this->p_libvlc ) ) { - switch( i_type & VLC_VAR_TYPE ) + vlc_object_internals_t *p_priv; + + if( p_this->p_parent ) + p_priv = vlc_internals( p_this->p_parent ); + else + p_priv = vlc_internals( p_this->p_libvlc ); + + i_var = Lookup( p_priv->p_vars, p_priv->i_vars, psz_name ); + + if( i_var >= 0 ) { - case VLC_VAR_FILE: - case VLC_VAR_DIRECTORY: + /* We found it! */ + p_var = &p_priv->p_vars[i_var]; + + /* Really get the variable */ + *p_val = p_var->val; + + /* Duplicate value if needed */ + p_var->ops->pf_dup( p_val ); + + /*msg_Dbg( p_this, "Inherited value for var %s from object %s", + psz_name ? psz_name : "(null)", + p_this->psz_object_name + ? p_this->psz_object_name : "(Unknown)" );*/ + return VLC_SUCCESS; + } + else if ( p_this->p_parent ) /* We are still not there */ + return InheritValue( p_this->p_parent, psz_name, p_val, i_type ); + + /* else take value from config */ + } + + + switch( i_type & VLC_VAR_CLASS ) + { case VLC_VAR_STRING: - case VLC_VAR_MODULE: p_val->psz_string = config_GetPsz( p_this, psz_name ); if( !p_val->psz_string ) p_val->psz_string = strdup(""); break; @@ -1355,7 +1434,6 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, p_val->f_float = config_GetFloat( p_this, psz_name ); break; case VLC_VAR_INTEGER: - case VLC_VAR_HOTKEY: p_val->i_int = config_GetInt( p_this, psz_name ); break; case VLC_VAR_BOOL: @@ -1387,41 +1465,73 @@ static int InheritValue( vlc_object_t *p_this, const char *psz_name, INSERT_ELEM( p_list->pi_types, p_list->i_count, p_list->i_count, VLC_VAR_INTEGER ); } - if( psz_orig ) free( psz_orig ); + free( psz_orig ); break; } default: + msg_Warn( p_this, "Could not inherit value for var %s " + "from config. Invalid Type", psz_name ); return VLC_ENOOBJ; break; - } - - return VLC_SUCCESS; } + /*msg_Dbg( p_this, "Inherited value for var %s from config", psz_name );*/ + return VLC_SUCCESS; +} - /* Look for the variable */ - vlc_mutex_lock( &p_this->p_parent->var_lock ); - - i_var = Lookup( p_this->p_parent->p_vars, p_this->p_parent->i_vars, - psz_name ); +/********************************************************************** + * 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( i_var >= 0 ) + if( !p_obj ) { - /* We found it! */ - p_var = &p_this->p_parent->p_vars[i_var]; - - /* Really get the variable */ - *p_val = p_var->val; + if( psz_msg ) + *psz_msg = strdup( "Unknown destination object." ); + return VLC_ENOOBJ; + } - /* Duplicate value if needed */ - p_var->pf_dup( p_val ); + 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; + } - vlc_mutex_unlock( &p_this->p_parent->var_lock ); - return VLC_SUCCESS; + i_type &= VLC_VAR_CLASS; + 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_mutex_unlock( &p_this->p_parent->var_lock ); + vlc_object_release( p_obj ); - /* We're still not there */ + if( psz_msg ) + { + if( asprintf( psz_msg, "%s on object %s returned %i (%s)", + psz_cmd, psz_name, i_ret, vlc_error( i_ret ) ) == -1) + *psz_msg = NULL; + } - return InheritValue( p_this->p_parent, psz_name, p_val, i_type ); + return i_ret; }