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