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