X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmisc%2Fvariables.c;h=15d29c186cc3381b9f245537df38e376b92ee62d;hb=983312cb0a0e331629b9f0e67a982d433465ec71;hp=b7910d396b5345225f457c208153db81aadc6df8;hpb=6aa543713d3f9759aac245e4289376ef187770bb;p=vlc

diff --git a/src/misc/variables.c b/src/misc/variables.c
index b7910d396b..15d29c186c 100644
--- a/src/misc/variables.c
+++ b/src/misc/variables.c
@@ -24,12 +24,16 @@
 /*****************************************************************************
  * Preamble
  *****************************************************************************/
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
 #include <vlc/vlc.h>
 #include "variables.h"
 
-#ifdef HAVE_STDLIB_H
-#   include <stdlib.h>                                          /* realloc() */
-#endif
+#include "libvlc.h"
+
+#include "vlc_interface.h"
 
 /*****************************************************************************
  * Private types
@@ -156,46 +160,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 = 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|VLC_VAR_ISCOMMAND)) != 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++;
+        p_priv->p_vars[i_new].i_usage++;
         if( i_type & VLC_VAR_ISCOMMAND )
-            p_this->p_vars[i_new].i_type |= VLC_VAR_ISCOMMAND;
-        vlc_mutex_unlock( &p_this->var_lock );
+            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 );
@@ -242,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;
@@ -300,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;
 }
@@ -318,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;
     }
 
@@ -362,19 +368,19 @@ 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 );
 
-    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;
 }
@@ -394,18 +400,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 )
     {
@@ -419,6 +426,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 )
             {
@@ -429,6 +442,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 )
             {
@@ -439,6 +458,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-- ; )
@@ -481,7 +506,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;
             }
 
@@ -621,7 +646,9 @@ 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 )
+                if( InheritValue( p_this,
+                                  p_val2 ? p_val2->psz_string :  psz_name,
+                                  &val, p_var->i_type )
                     == VLC_SUCCESS )
                 {
                     /* Duplicate already done */
@@ -654,7 +681,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-- ; )
@@ -663,17 +690,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;
                 }
             }
@@ -683,7 +710,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;
 }
@@ -698,20 +725,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;
 }
@@ -728,17 +756,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 );
@@ -761,7 +790,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-- ; )
@@ -770,24 +799,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;
 }
@@ -804,18 +833,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;
@@ -823,11 +853,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
  *
@@ -850,27 +899,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;
 }
@@ -886,17 +936,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-- ; )
     {
@@ -909,14 +960,77 @@ 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;
 }
 
@@ -929,28 +1043,30 @@ int __var_DelCallback( vlc_object_t *p_this, const char *psz_name,
  * \param psz_option the option to parse
  * \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 )
 {
-    char *psz_name, *psz_value = strchr( psz_option, '=' );
-    int  i_name_len, i_type;
+    char *psz_name, *psz_value;
+    int  i_type;
     vlc_bool_t b_isno = VLC_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 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 = strdup( psz_option );
+    if( psz_name == NULL )
+        return;
 
-    psz_name = strndup( psz_option, i_name_len );
-    if( psz_value ) psz_value++;
+    psz_value = strchr( psz_name, '=' );
+    if( psz_value != NULL )
+        *psz_value++ = '\0';
 
     /* FIXME: :programs should be handled generically */
     if( !strcmp( psz_name, "programs" ) )
@@ -973,14 +1089,41 @@ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option )
 
         b_isno = VLC_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 */
+    {
+        module_config_t *p_config = config_FindConfig( p_obj, psz_name );
+        if( !p_config->b_safe )
+        {
+            int policy = config_GetInt( p_obj, "security-policy" );
+            switch( policy )
+            {
+                case 0: /* block */
+                    msg_Err( p_obj, "option %s is unsafe and is blocked by security policy", psz_name );
+                    return;
+                case 1: /* allow */
+                    break;
+                case 2: /* prompt */
+                {
+                    char description[256];
+                    snprintf(description, sizeof(description), _("playlist item is making use of the following unsafe option '%s', which may be harmful if used in a malicious way, authorize it ?"), psz_name);
+                    if( DIALOG_OK_YES != intf_UserYesNo( p_obj, _("WARNING: Unsafe Playlist"), description, _("Yes"), _("No"), NULL) )
+                    {
+                        msg_Err( p_obj, "option %s is unsafe and is blocked by security policy", psz_name );
+                        goto cleanup;
+                    }
+                }
+                default:
+                    ;
+            }
+        }
+    }
+
     /* 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. */
@@ -1039,14 +1182,12 @@ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option )
 
     default:
         goto cleanup;
-        break;
     }
 
     var_Set( p_obj, psz_name, val );
 
-  cleanup:
-    if( psz_name ) free( psz_name );
-    return;
+cleanup:
+    free( psz_name );
 }
 
 
@@ -1061,16 +1202,17 @@ void __var_OptionParse( vlc_object_t *p_obj, const char *psz_option )
 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;
         }
@@ -1081,9 +1223,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 );
     }
 }
 
@@ -1401,16 +1543,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;
@@ -1418,11 +1561,11 @@ 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 */