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