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