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