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