git.sesse.net Git - vlc/blob - modules/control/http/mvar.c

   1 /*****************************************************************************
   2  * mvar.c : Variables handling for the HTTP Interface
   3  *****************************************************************************
   4  * Copyright (C) 2001-2007 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *          Laurent Aimar <fenrir@via.ecp.fr>
   9  *          Christophe Massiot <massiot@via.ecp.fr>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 #include "http.h"
  27 #include <limits.h>
  28
  29 /* Utility function for scandir */
  30 static int Filter( const char *foo )
  31 {
  32     return strcmp( foo, "." );
  33 };
  34
  35 static int InsensitiveAlphasort( const char **foo1,
  36                                  const char **foo2 )
  37 {
  38     return strcasecmp( *foo1, *foo2 );
  39 };
  40
  41
  42
  43 mvar_t *E_(mvar_New)( const char *name, const char *value )
  44 {
  45     mvar_t *v = malloc( sizeof( mvar_t ) );
  46
  47     if( !v ) return NULL;
  48     v->name = strdup( name );
  49     v->value = strdup( value ? value : "" );
  50
  51     v->i_field = 0;
  52     v->field = malloc( sizeof( mvar_t * ) );
  53     v->field[0] = NULL;
  54
  55     return v;
  56 }
  57
  58 void E_(mvar_Delete)( mvar_t *v )
  59 {
  60     int i;
  61
  62     free( v->name );
  63     free( v->value );
  64
  65     for( i = 0; i < v->i_field; i++ )
  66     {
  67         E_(mvar_Delete)( v->field[i] );
  68     }
  69     free( v->field );
  70     free( v );
  71 }
  72
  73 void E_(mvar_AppendVar)( mvar_t *v, mvar_t *f )
  74 {
  75     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
  76     v->field[v->i_field] = f;
  77     v->i_field++;
  78 }
  79
  80 mvar_t *E_(mvar_Duplicate)( const mvar_t *v )
  81 {
  82     int i;
  83     mvar_t *n;
  84
  85     n = E_(mvar_New)( v->name, v->value );
  86     for( i = 0; i < v->i_field; i++ )
  87     {
  88         E_(mvar_AppendVar)( n, E_(mvar_Duplicate)( v->field[i] ) );
  89     }
  90
  91     return n;
  92 }
  93
  94 void E_(mvar_PushVar)( mvar_t *v, mvar_t *f )
  95 {
  96     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
  97     if( v->i_field > 0 )
  98     {
  99         memmove( &v->field[1], &v->field[0], sizeof( mvar_t * ) * v->i_field );
 100     }
 101     v->field[0] = f;
 102     v->i_field++;
 103 }
 104
 105 void E_(mvar_RemoveVar)( mvar_t *v, mvar_t *f )
 106 {
 107     int i;
 108     for( i = 0; i < v->i_field; i++ )
 109     {
 110         if( v->field[i] == f )
 111         {
 112             break;
 113         }
 114     }
 115     if( i >= v->i_field )
 116     {
 117         return;
 118     }
 119
 120     if( i + 1 < v->i_field )
 121     {
 122         memmove( &v->field[i], &v->field[i+1], sizeof( mvar_t * ) * ( v->i_field - i - 1 ) );
 123     }
 124     v->i_field--;
 125     /* FIXME should do a realloc */
 126 }
 127
 128 mvar_t *E_(mvar_GetVar)( mvar_t *s, const char *name )
 129 {
 130     /* format: name[index].field */
 131     const char *field = strchr( name, '.' );
 132     char base[1 + (field ? (size_t)(field - name) : strlen( name ))];
 133     char *p;
 134     int i_index, i;
 135
 136     strlcpy( base, name, sizeof (base) );
 137     if( field != NULL )
 138         field++;
 139
 140     if( ( p = strchr( base, '[' ) ) != NULL )
 141     {
 142         char *end;
 143         unsigned long l = strtoul( p, &end, 0 );
 144
 145         if( ( l > INT_MAX ) || strcmp( "]", end ) )
 146             return NULL;
 147
 148         *p++ = '\0';
 149         i_index = (int)l;
 150     }
 151     else
 152     {
 153         i_index = 0;
 154     }
 155
 156     for( i = 0; i < s->i_field; i++ )
 157     {
 158         if( !strcmp( s->field[i]->name, base ) )
 159         {
 160             if( i_index > 0 )
 161             {
 162                 i_index--;
 163             }
 164             else
 165             {
 166                 if( field )
 167                 {
 168                     return E_(mvar_GetVar)( s->field[i], field );
 169                 }
 170                 else
 171                 {
 172                     return s->field[i];
 173                 }
 174             }
 175         }
 176     }
 177     return NULL;
 178 }
 179
 180 char *E_(mvar_GetValue)( mvar_t *v, char *field )
 181 {
 182     if( *field == '\0' )
 183     {
 184         return v->value;
 185     }
 186     else
 187     {
 188         mvar_t *f = E_(mvar_GetVar)( v, field );
 189         if( f )
 190         {
 191             return f->value;
 192         }
 193         else
 194         {
 195             return field;
 196         }
 197     }
 198 }
 199
 200 void E_(mvar_PushNewVar)( mvar_t *vars, const char *name,
 201                           const char *value )
 202 {
 203     mvar_t *f = E_(mvar_New)( name, value );
 204     E_(mvar_PushVar)( vars, f );
 205 }
 206
 207 void E_(mvar_AppendNewVar)( mvar_t *vars, const char *name,
 208                             const char *value )
 209 {
 210     mvar_t *f = E_(mvar_New)( name, value );
 211     E_(mvar_AppendVar)( vars, f );
 212 }
 213
 214
 215 /* arg= start[:stop[:step]],.. */
 216 mvar_t *E_(mvar_IntegerSetNew)( const char *name, const char *arg )
 217 {
 218     char *dup = strdup( arg );
 219     char *str = dup;
 220     mvar_t *s = E_(mvar_New)( name, "set" );
 221
 222     while( str )
 223     {
 224         char *p;
 225         int  i_start,i_stop,i_step;
 226         int  i_match;
 227
 228         p = strchr( str, ',' );
 229         if( p )
 230         {
 231             *p++ = '\0';
 232         }
 233
 234         i_step = 0;
 235         i_match = sscanf( str, "%d:%d:%d", &i_start, &i_stop, &i_step );
 236
 237         if( i_match == 1 )
 238         {
 239             i_stop = i_start;
 240             i_step = 1;
 241         }
 242         else if( i_match == 2 )
 243         {
 244             i_step = i_start < i_stop ? 1 : -1;
 245         }
 246
 247         if( i_match >= 1 )
 248         {
 249             int i;
 250
 251             if( ( i_start <= i_stop && i_step > 0 ) ||
 252                 ( i_start >= i_stop && i_step < 0 ) )
 253             {
 254                 for( i = i_start; ; i += i_step )
 255                 {
 256                     char   value[79];
 257
 258                     if( ( i_step > 0 && i > i_stop ) ||
 259                         ( i_step < 0 && i < i_stop ) )
 260                     {
 261                         break;
 262                     }
 263
 264                     sprintf( value, "%d", i );
 265
 266                     E_(mvar_PushNewVar)( s, name, value );
 267                 }
 268             }
 269         }
 270         str = p;
 271     }
 272
 273     free( dup );
 274     return s;
 275 }
 276
 277 /********************************************************************
 278  * Special sets handling
 279  ********************************************************************/
 280
 281 mvar_t *E_(mvar_PlaylistSetNew)( intf_thread_t *p_intf, char *name,
 282                                  playlist_t *p_pl )
 283 {
 284     mvar_t *s = E_(mvar_New)( name, "set" );
 285     vlc_mutex_lock( &p_pl->object_lock );
 286     E_(PlaylistListNode)( p_intf, p_pl, p_pl->p_root_category , name, s, 0 );
 287     vlc_mutex_unlock( &p_pl->object_lock );
 288     return s;
 289 }
 290
 291 mvar_t *E_(mvar_InfoSetNew)( intf_thread_t *p_intf, char *name,
 292                              input_thread_t *p_input )
 293 {
 294     mvar_t *s = E_(mvar_New)( name, "set" );
 295     int i, j;
 296
 297     if( p_input == NULL || p_input->p == NULL /* workarround assert in input_GetItem */ )
 298     {
 299         return s;
 300     }
 301
 302     vlc_mutex_lock( &input_GetItem(p_input)->lock );
 303     for ( i = 0; i < input_GetItem(p_input)->i_categories; i++ )
 304     {
 305         info_category_t *p_category = input_GetItem(p_input)->pp_categories[i];
 306
 307         mvar_t *cat  = E_(mvar_New)( name, "set" );
 308         mvar_t *iset = E_(mvar_New)( "info", "set" );
 309
 310         E_(mvar_AppendNewVar)( cat, "name", p_category->psz_name );
 311         E_(mvar_AppendVar)( cat, iset );
 312
 313         for ( j = 0; j < p_category->i_infos; j++ )
 314         {
 315             info_t *p_info = p_category->pp_infos[j];
 316             mvar_t *info = E_(mvar_New)( "info", "" );
 317
 318             /* msg_Dbg( p_input, "adding info name=%s value=%s",
 319                      psz_name, psz_value ); */
 320             E_(mvar_AppendNewVar)( info, "name",  p_info->psz_name );
 321             E_(mvar_AppendNewVar)( info, "value", p_info->psz_value );
 322             E_(mvar_AppendVar)( iset, info );
 323         }
 324         E_(mvar_AppendVar)( s, cat );
 325     }
 326     vlc_mutex_unlock( &input_GetItem(p_input)->lock );
 327
 328     return s;
 329 }
 330
 331 mvar_t *E_(mvar_ObjectSetNew)( intf_thread_t *p_intf, char *psz_name,
 332                                const char *psz_capability )
 333 {
 334     mvar_t *s = E_(mvar_New)( psz_name, "set" );
 335     int i;
 336
 337     vlc_list_t *p_list = vlc_list_find( p_intf, VLC_OBJECT_MODULE,
 338                                         FIND_ANYWHERE );
 339
 340     for( i = 0; i < p_list->i_count; i++ )
 341     {
 342         module_t *p_parser = (module_t *)p_list->p_values[i].p_object;
 343         if( module_IsCapable( p_parser, psz_capability ) )
 344         {
 345             mvar_t *sd = E_(mvar_New)( "sd", module_GetObjName( p_parser ) );
 346             E_(mvar_AppendNewVar)( sd, "name",
 347                                    module_GetName( p_parser, VLC_TRUE ) );
 348             E_(mvar_AppendVar)( s, sd );
 349         }
 350     }
 351
 352     vlc_list_release( p_list );
 353
 354     return s;
 355 }
 356
 357 mvar_t *E_(mvar_InputVarSetNew)( intf_thread_t *p_intf, char *name,
 358                                  input_thread_t *p_input,
 359                                  const char *psz_variable )
 360 {
 361     intf_sys_t     *p_sys = p_intf->p_sys;
 362     mvar_t *s = E_(mvar_New)( name, "set" );
 363     vlc_value_t val, val_list, text_list;
 364     int i_type, i;
 365
 366     if( p_input == NULL )
 367     {
 368         return s;
 369     }
 370
 371     /* Check the type of the object variable */
 372     i_type = var_Type( p_sys->p_input, psz_variable );
 373
 374     /* Make sure we want to display the variable */
 375     if( i_type & VLC_VAR_HASCHOICE )
 376     {
 377         var_Change( p_sys->p_input, psz_variable, VLC_VAR_CHOICESCOUNT, &val, NULL );
 378         if( val.i_int == 0 ) return s;
 379         if( (i_type & VLC_VAR_TYPE) != VLC_VAR_VARIABLE && val.i_int == 1 )
 380             return s;
 381     }
 382     else
 383     {
 384         return s;
 385     }
 386
 387     switch( i_type & VLC_VAR_TYPE )
 388     {
 389     case VLC_VAR_VOID:
 390     case VLC_VAR_BOOL:
 391     case VLC_VAR_VARIABLE:
 392     case VLC_VAR_STRING:
 393     case VLC_VAR_INTEGER:
 394         break;
 395     default:
 396         /* Variable doesn't exist or isn't handled */
 397         return s;
 398     }
 399
 400     if( var_Get( p_sys->p_input, psz_variable, &val ) < 0 )
 401     {
 402         return s;
 403     }
 404
 405     if( var_Change( p_sys->p_input, psz_variable, VLC_VAR_GETLIST,
 406                     &val_list, &text_list ) < 0 )
 407     {
 408         if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
 409         return s;
 410     }
 411
 412     for( i = 0; i < val_list.p_list->i_count; i++ )
 413     {
 414         char *psz, psz_int[16];
 415         mvar_t *itm;
 416
 417         switch( i_type & VLC_VAR_TYPE )
 418         {
 419         case VLC_VAR_STRING:
 420             itm = E_(mvar_New)( name, "set" );
 421             /* FIXME: Memory leak here?? (remove strdup?) */
 422             psz = strdup( text_list.p_list->p_values[i].psz_string );
 423             E_(mvar_AppendNewVar)( itm, "name", psz );
 424             E_(mvar_AppendNewVar)( itm, "id", val_list.p_list->p_values[i].psz_string );
 425             snprintf( psz_int, sizeof(psz_int), "%d",
 426                       ( !strcmp( val.psz_string,
 427                                    val_list.p_list->p_values[i].psz_string )
 428                            && !( i_type & VLC_VAR_ISCOMMAND ) ) );
 429             E_(mvar_AppendNewVar)( itm, "selected", psz_int );
 430             E_(mvar_AppendVar)( s, itm );
 431             break;
 432
 433         case VLC_VAR_INTEGER:
 434             itm = E_(mvar_New)( name, "set" );
 435             psz = strdup( text_list.p_list->p_values[i].psz_string );
 436             E_(mvar_AppendNewVar)( itm, "name", psz );
 437             snprintf( psz_int, sizeof(psz_int), "%d",
 438                       val_list.p_list->p_values[i].i_int );
 439             E_(mvar_AppendNewVar)( itm, "id", psz_int );
 440             snprintf( psz_int, sizeof(psz_int), "%d",
 441                       ( val.i_int == val_list.p_list->p_values[i].i_int )
 442                          && !( i_type & VLC_VAR_ISCOMMAND ) );
 443             E_(mvar_AppendNewVar)( itm, "selected", psz_int );
 444             E_(mvar_AppendVar)( s, itm );
 445             break;
 446
 447         default:
 448             break;
 449         }
 450     }
 451     /* clean up everything */
 452     if( (i_type & VLC_VAR_TYPE) == VLC_VAR_STRING ) free( val.psz_string );
 453     var_Change( p_sys->p_input, psz_variable, VLC_VAR_FREELIST, &val_list,
 454                 &text_list );
 455     return s;
 456 }
 457
 458 #if 0
 459 mvar_t *E_(mvar_HttpdInfoSetNew)( char *name, httpd_t *p_httpd, int i_type )
 460 {
 461     mvar_t       *s = E_(mvar_New)( name, "set" );
 462     httpd_info_t info;
 463     int          i;
 464
 465     if( !p_httpd->pf_control( p_httpd, i_type, &info, NULL ) )
 466     {
 467         for( i= 0; i < info.i_count; )
 468         {
 469             mvar_t *inf;
 470
 471             inf = E_(mvar_New)( name, "set" );
 472             do
 473             {
 474                 /* fprintf( stderr," mvar_HttpdInfoSetNew: append name=`%s' value=`%s'\n",
 475                             info.info[i].psz_name, info.info[i].psz_value ); */
 476                 E_(mvar_AppendNewVar)( inf,
 477                                    info.info[i].psz_name,
 478                                    info.info[i].psz_value );
 479                 i++;
 480             } while( i < info.i_count && strcmp( info.info[i].psz_name, "id" ) );
 481             E_(mvar_AppendVar)( s, inf );
 482         }
 483     }
 484
 485     /* free mem */
 486     for( i = 0; i < info.i_count; i++ )
 487     {
 488         free( info.info[i].psz_name );
 489         free( info.info[i].psz_value );
 490     }
 491     if( info.i_count > 0 )
 492     {
 493         free( info.info );
 494     }
 495
 496     return s;
 497 }
 498 #endif
 499
 500 mvar_t *E_(mvar_FileSetNew)( intf_thread_t *p_intf, char *name,
 501                              char *psz_dir )
 502 {
 503     mvar_t *s = E_(mvar_New)( name, "set" );
 504 #ifdef HAVE_SYS_STAT_H
 505     struct stat   stat_info;
 506 #endif
 507     char        **ppsz_dir_content;
 508     int           i_dir_content, i;
 509     psz_dir = E_(RealPath)( p_intf, psz_dir );
 510
 511 #ifdef HAVE_SYS_STAT_H
 512     if( (utf8_stat( psz_dir, &stat_info ) == -1 )
 513      || !S_ISDIR( stat_info.st_mode )
 514 #   if defined( WIN32 )
 515           && psz_dir[0] != '\0' && (psz_dir[0] != '\\' || psz_dir[1] != '\0')
 516 #   endif
 517       )
 518     {
 519         free( psz_dir );
 520         return s;
 521     }
 522 #endif
 523
 524     /* parse psz_src dir */
 525     if( ( i_dir_content = utf8_scandir( psz_dir, &ppsz_dir_content, Filter,
 526                                         InsensitiveAlphasort ) ) == -1 )
 527     {
 528         msg_Warn( p_intf, "error while scanning dir %s (%m)", psz_dir );
 529         free( psz_dir );
 530         return s;
 531     }
 532
 533     for( i = 0; i < i_dir_content; i++ )
 534     {
 535         char *psz_name = ppsz_dir_content[i], *psz_ext, *psz_dummy;
 536         char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];
 537         mvar_t *f;
 538
 539 #if defined( WIN32 )
 540         if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
 541         {
 542             strcpy( psz_tmp, psz_name );
 543         }
 544         else
 545 #endif
 546         {
 547             sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
 548
 549 #ifdef HAVE_SYS_STAT_H
 550             if( utf8_stat( psz_tmp, &stat_info ) == -1 )
 551             {
 552                 free( psz_name );
 553                 continue;
 554             }
 555 #endif
 556         }
 557         f = E_(mvar_New)( name, "set" );
 558
 559         /* put lower-case file extension in 'ext' */
 560         psz_ext = strrchr( psz_name, '.' );
 561         psz_ext = strdup( psz_ext != NULL ? psz_ext + 1 : "" );
 562         for( psz_dummy = psz_ext; *psz_dummy != '\0'; psz_dummy++ )
 563             *psz_dummy = tolower( *psz_dummy );
 564
 565         E_(mvar_AppendNewVar)( f, "ext", psz_ext );
 566         free( psz_ext );
 567
 568 #if defined( WIN32 )
 569         if( psz_dir[0] == '\0' || (psz_dir[0] == '\\' && psz_dir[1] == '\0') )
 570         {
 571             char psz_tmp[3];
 572             sprintf( psz_tmp, "%c:", psz_name[0] );
 573             E_(mvar_AppendNewVar)( f, "name", psz_name );
 574             E_(mvar_AppendNewVar)( f, "basename", psz_tmp );
 575             E_(mvar_AppendNewVar)( f, "type", "directory" );
 576             E_(mvar_AppendNewVar)( f, "size", "unknown" );
 577             E_(mvar_AppendNewVar)( f, "date", "unknown" );
 578         }
 579         else
 580 #endif
 581         {
 582             char psz_ctime[26];
 583             char psz_tmp[strlen( psz_dir ) + 1 + strlen( psz_name ) + 1];
 584
 585             sprintf( psz_tmp, "%s"DIR_SEP"%s", psz_dir, psz_name );
 586             E_(mvar_AppendNewVar)( f, "name", psz_tmp );
 587             E_(mvar_AppendNewVar)( f, "basename", psz_name );
 588
 589 #ifdef HAVE_SYS_STAT_H
 590             if( S_ISDIR( stat_info.st_mode ) )
 591             {
 592                 E_(mvar_AppendNewVar)( f, "type", "directory" );
 593             }
 594             else if( S_ISREG( stat_info.st_mode ) )
 595             {
 596                 E_(mvar_AppendNewVar)( f, "type", "file" );
 597             }
 598             else
 599             {
 600                 E_(mvar_AppendNewVar)( f, "type", "unknown" );
 601             }
 602
 603             sprintf( psz_ctime, I64Fd, (int64_t)stat_info.st_size );
 604             E_(mvar_AppendNewVar)( f, "size", psz_ctime );
 605
 606             /* FIXME memory leak FIXME */
 607 #   ifdef HAVE_CTIME_R
 608             ctime_r( &stat_info.st_mtime, psz_ctime );
 609             E_(mvar_AppendNewVar)( f, "date", psz_ctime );
 610 #   else
 611             E_(mvar_AppendNewVar)( f, "date", ctime( &stat_info.st_mtime ) );
 612 #   endif
 613
 614 #else
 615             E_(mvar_AppendNewVar)( f, "type", "unknown" );
 616             E_(mvar_AppendNewVar)( f, "size", "unknown" );
 617             E_(mvar_AppendNewVar)( f, "date", "unknown" );
 618 #endif
 619         }
 620
 621         E_(mvar_AppendVar)( s, f );
 622
 623         free( psz_name );
 624     }
 625
 626     free( psz_dir );
 627     if( ppsz_dir_content != NULL )
 628         free( ppsz_dir_content );
 629     return s;
 630 }
 631
 632 void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, vlc_bool_t b_name );
 633 void E_(mvar_VlmSetNewLoop)( char *name, vlm_t *vlm, mvar_t *s, vlm_message_t *el, vlc_bool_t b_name )
 634 {
 635     /* Over name */
 636     mvar_t        *set;
 637     int k;
 638
 639     /* Add a node with name and info */
 640     set = E_(mvar_New)( name, "set" );
 641     if( b_name == VLC_TRUE )
 642     {
 643         E_(mvar_AppendNewVar)( set, "name", el->psz_name );
 644     }
 645
 646     for( k = 0; k < el->i_child; k++ )
 647     {
 648         vlm_message_t *ch = el->child[k];
 649         if( ch->i_child > 0 )
 650         {
 651             E_(mvar_VlmSetNewLoop)( ch->psz_name, vlm, set, ch, VLC_FALSE );
 652         }
 653         else
 654         {
 655             if( ch->psz_value )
 656             {
 657                 E_(mvar_AppendNewVar)( set, ch->psz_name, ch->psz_value );
 658             }
 659             else
 660             {
 661                 E_(mvar_AppendNewVar)( set, el->psz_name, ch->psz_name );
 662             }
 663         }
 664     }
 665
 666     E_(mvar_AppendVar)( s, set );
 667 }
 668
 669 mvar_t *E_(mvar_VlmSetNew)( char *name, vlm_t *vlm )
 670 {
 671     mvar_t        *s = E_(mvar_New)( name, "set" );
 672     vlm_message_t *msg;
 673     int    i;
 674
 675     if( vlm == NULL ) return s;
 676
 677     if( vlm_ExecuteCommand( vlm, "show", &msg ) )
 678     {
 679         return s;
 680     }
 681
 682     for( i = 0; i < msg->i_child; i++ )
 683     {
 684         /* Over media, schedule */
 685         vlm_message_t *ch = msg->child[i];
 686         int j;
 687
 688         for( j = 0; j < ch->i_child; j++ )
 689         {
 690             /* Over name */
 691             vlm_message_t *el = ch->child[j];
 692             vlm_message_t *inf, *desc;
 693             char          psz[6 + strlen(el->psz_name)];
 694
 695             sprintf( psz, "show %s", el->psz_name );
 696             if( vlm_ExecuteCommand( vlm, psz, &inf ) )
 697                 continue;
 698             desc = inf->child[0];
 699
 700             E_(mvar_VlmSetNewLoop)( el->psz_name, vlm, s, desc, VLC_TRUE );
 701
 702             vlm_MessageDelete( inf );
 703         }
 704     }
 705     vlm_MessageDelete( msg );
 706
 707     return s;
 708 }