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