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