rc: header inclusion fix
[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 #include <assert.h>
33
34 /* Utility function for scandir */
35 static int Filter( const char *foo )
36 {
37     return strcmp( foo, "." );
38 };
39
40 static int InsensitiveAlphasort( const char **foo1,
41                                  const char **foo2 )
42 {
43     return strcasecmp( *foo1, *foo2 );
44 };
45
46
47
48 mvar_t *mvar_New( const char *name, const char *value )
49 {
50     mvar_t *v = malloc( sizeof( mvar_t ) );
51
52     if( !v ) return NULL;
53     v->name = strdup( name );
54     v->value = strdup( value ? value : "" );
55
56     v->i_field = 0;
57     v->field = malloc( sizeof( mvar_t * ) );
58     v->field[0] = NULL;
59
60     return v;
61 }
62
63 void mvar_Delete( mvar_t *v )
64 {
65     int i;
66
67     free( v->name );
68     free( v->value );
69
70     for( i = 0; i < v->i_field; i++ )
71     {
72         mvar_Delete( v->field[i] );
73     }
74     free( v->field );
75     free( v );
76 }
77
78 void mvar_AppendVar( mvar_t *v, mvar_t *f )
79 {
80     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
81     v->field[v->i_field] = f;
82     v->i_field++;
83 }
84
85 mvar_t *mvar_Duplicate( const mvar_t *v )
86 {
87     int i;
88     mvar_t *n;
89
90     n = mvar_New( v->name, v->value );
91     for( i = 0; i < v->i_field; i++ )
92     {
93         mvar_AppendVar( n, mvar_Duplicate( v->field[i] ) );
94     }
95
96     return n;
97 }
98
99 void mvar_PushVar( mvar_t *v, mvar_t *f )
100 {
101     v->field = realloc( v->field, sizeof( mvar_t * ) * ( v->i_field + 2 ) );
102     if( v->i_field > 0 )
103     {
104         memmove( &v->field[1], &v->field[0], sizeof( mvar_t * ) * v->i_field );
105     }
106     v->field[0] = f;
107     v->i_field++;
108 }
109
110 void mvar_RemoveVar( mvar_t *v, mvar_t *f )
111 {
112     int i;
113     for( i = 0; i < v->i_field; i++ )
114     {
115         if( v->field[i] == f )
116         {
117             break;
118         }
119     }
120     if( i >= v->i_field )
121     {
122         return;
123     }
124
125     if( i + 1 < v->i_field )
126     {
127         memmove( &v->field[i], &v->field[i+1], sizeof( mvar_t * ) * ( v->i_field - i - 1 ) );
128     }
129     v->i_field--;
130     /* FIXME should do a realloc */
131 }
132
133 mvar_t *mvar_GetVar( mvar_t *s, const char *name )
134 {
135     /* format: name[index].field */
136     const char *field = strchr( name, '.' );
137     char base[1 + (field ? (size_t)(field - name) : strlen( name ))];
138     char *p;
139     int i_index, i;
140
141     strlcpy( base, name, sizeof (base) );
142     if( field != NULL )
143         field++;
144
145     if( ( p = strchr( base, '[' ) ) != NULL )
146     {
147         char *end;
148         unsigned long l = strtoul( p, &end, 0 );
149
150         if( ( l > INT_MAX ) || strcmp( "]", end ) )
151             return NULL;
152
153         *p++ = '\0';
154         i_index = (int)l;
155     }
156     else
157     {
158         i_index = 0;
159     }
160
161     for( i = 0; i < s->i_field; i++ )
162     {
163         if( !strcmp( s->field[i]->name, base ) )
164         {
165             if( i_index > 0 )
166             {
167                 i_index--;
168             }
169             else
170             {
171                 if( field )
172                 {
173                     return mvar_GetVar( s->field[i], field );
174                 }
175                 else
176                 {
177                     return s->field[i];
178                 }
179             }
180         }
181     }
182     return NULL;
183 }
184
185 const char *mvar_GetValue( mvar_t *v, const char *field )
186 {
187     if( *field == '\0' )
188     {
189         return v->value;
190     }
191     else
192     {
193         mvar_t *f = mvar_GetVar( v, field );
194         if( f )
195         {
196             return f->value;
197         }
198         else
199         {
200             return field;
201         }
202     }
203 }
204
205 void mvar_PushNewVar( mvar_t *vars, const char *name,
206                           const char *value )
207 {
208     mvar_t *f = mvar_New( name, value );
209     mvar_PushVar( vars, f );
210 }
211
212 void mvar_AppendNewVar( mvar_t *vars, const char *name,
213                             const char *value )
214 {
215     mvar_t *f = mvar_New( name, value );
216     mvar_AppendVar( vars, f );
217 }
218
219
220 /* arg= start[:stop[:step]],.. */
221 mvar_t *mvar_IntegerSetNew( const char *name, const char *arg )
222 {
223     char *dup = strdup( arg );
224     char *str = dup;
225     mvar_t *s = mvar_New( name, "set" );
226
227     while( str )
228     {
229         char *p;
230         int  i_start,i_stop,i_step;
231         int  i_match;
232
233         p = strchr( str, ',' );
234         if( p )
235         {
236             *p++ = '\0';
237         }
238
239         i_step = 0;
240         i_match = sscanf( str, "%d:%d:%d", &i_start, &i_stop, &i_step );
241
242         if( i_match == 1 )
243         {
244             i_stop = i_start;
245             i_step = 1;
246         }
247         else if( i_match == 2 )
248         {
249             i_step = i_start < i_stop ? 1 : -1;
250         }
251
252         if( i_match >= 1 )
253         {
254             int i;
255
256             if( ( i_start <= i_stop && i_step > 0 ) ||
257                 ( i_start >= i_stop && i_step < 0 ) )
258             {
259                 for( i = i_start; ; i += i_step )
260                 {
261                     char   value[79];
262
263                     if( ( i_step > 0 && i > i_stop ) ||
264                         ( i_step < 0 && i < i_stop ) )
265                     {
266                         break;
267                     }
268
269                     sprintf( value, "%d", i );
270
271                     mvar_PushNewVar( s, name, value );
272                 }
273             }
274         }
275         str = p;
276     }
277
278     free( dup );
279     return s;
280 }
281
282 /********************************************************************
283  * Special sets handling
284  ********************************************************************/
285
286 mvar_t *mvar_PlaylistSetNew( intf_thread_t *p_intf, char *name,
287                                  playlist_t *p_pl )
288 {
289     mvar_t *s = mvar_New( name, "set" );
290     playlist_Lock( p_pl );
291     PlaylistListNode( p_intf, p_pl, p_pl->p_root_category , name, s, 0 );
292     playlist_Unlock( p_pl );
293     return s;
294 }
295
296 mvar_t *mvar_InfoSetNew( char *name, input_thread_t *p_input )
297 {
298     mvar_t *s = mvar_New( name, "set" );
299     int i, j;
300
301     if( p_input == NULL || p_input->p == NULL /* workarround assert in input_GetItem */ )
302     {
303         return s;
304     }
305
306     vlc_mutex_lock( &input_GetItem(p_input)->lock );
307     for ( i = 0; i < input_GetItem(p_input)->i_categories; i++ )
308     {
309         info_category_t *p_category = input_GetItem(p_input)->pp_categories[i];
310
311         mvar_t *cat  = mvar_New( name, "set" );
312         mvar_t *iset = mvar_New( "info", "set" );
313
314         mvar_AppendNewVar( cat, "name", p_category->psz_name );
315         mvar_AppendVar( cat, iset );
316
317         for ( j = 0; j < p_category->i_infos; j++ )
318         {
319             info_t *p_info = p_category->pp_infos[j];
320             mvar_t *info = mvar_New( "info", "" );
321
322             /* msg_Dbg( p_input, "adding info name=%s value=%s",
323                      psz_name, psz_value ); */
324             mvar_AppendNewVar( info, "name",  p_info->psz_name );
325             mvar_AppendNewVar( info, "value", p_info->psz_value );
326             mvar_AppendVar( iset, info );
327         }
328         mvar_AppendVar( s, cat );
329     }
330     vlc_mutex_unlock( &input_GetItem(p_input)->lock );
331
332     return s;
333 }
334
335 mvar_t *mvar_ObjectSetNew( intf_thread_t *p_intf, char *psz_name,
336                                const char *psz_capability )
337 {
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 }