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