HTTP interface: get rid of vlc_object_find
[vlc.git] / modules / control / http / rpn.c
1 /*****************************************************************************
2  * rpn.c : RPN evaluator for the HTTP Interface
3  *****************************************************************************
4  * Copyright (C) 2001-2006 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 "vlc_url.h"
31 #include "vlc_meta.h"
32 #include "vlc_strings.h"
33
34 static vlc_object_t *GetVLCObject( intf_thread_t *p_intf,
35                                    const char *psz_object,
36                                    bool *pb_need_release )
37 {
38     intf_sys_t    *p_sys = p_intf->p_sys;
39     vlc_object_t *p_object = NULL;
40     *pb_need_release = false;
41
42     if( !strcmp( psz_object, "VLC_OBJECT_LIBVLC" ) )
43         p_object = VLC_OBJECT(p_intf->p_libvlc);
44     else if( !strcmp( psz_object, "VLC_OBJECT_INTF" ) )
45         p_object = VLC_OBJECT(p_intf);
46     else if( !strcmp( psz_object, "VLC_OBJECT_PLAYLIST" ) )
47         p_object = VLC_OBJECT(p_sys->p_playlist);
48     else if( !strcmp( psz_object, "VLC_OBJECT_INPUT" ) )
49         p_object = VLC_OBJECT(p_sys->p_input);
50     else if( p_sys->p_input )
51     {
52         if( !strcmp( psz_object, "VLC_OBJECT_VOUT" ) )
53             p_object = VLC_OBJECT( input_GetVout( p_sys->p_input ) );
54         else if( !strcmp( psz_object, "VLC_OBJECT_AOUT" ) )
55             p_object = VLC_OBJECT( input_GetAout( p_sys->p_input ) );
56         if( p_object )
57             *pb_need_release = true;
58     }
59     else
60         msg_Warn( p_intf, "unknown object type (%s)", psz_object );
61
62     return p_object;
63 }
64
65 void SSInit( rpn_stack_t *st )
66 {
67     st->i_stack = 0;
68 }
69
70 void SSClean( rpn_stack_t *st )
71 {
72     while( st->i_stack > 0 )
73     {
74         free( st->stack[--st->i_stack] );
75     }
76 }
77
78 void SSPush( rpn_stack_t *st, const char *s )
79 {
80     if( st->i_stack < STACK_MAX )
81     {
82         st->stack[st->i_stack++] = strdup( s );
83     }
84 }
85
86 char *SSPop( rpn_stack_t *st )
87 {
88     if( st->i_stack <= 0 )
89     {
90         return strdup( "" );
91     }
92     else
93     {
94         return st->stack[--st->i_stack];
95     }
96 }
97
98 int SSPopN( rpn_stack_t *st, mvar_t  *vars )
99 {
100     char *name;
101
102     char *end;
103     int  i;
104
105     name = SSPop( st );
106     i = strtol( name, &end, 0 );
107     if( end == name )
108     {
109         const char *value = mvar_GetValue( vars, name );
110         i = atoi( value );
111     }
112     free( name );
113
114     return( i );
115 }
116
117 void SSPushN( rpn_stack_t *st, int i )
118 {
119     char v[12];
120
121     snprintf( v, sizeof (v), "%d", i );
122     SSPush( st, v );
123 }
124
125 void EvaluateRPN( intf_thread_t *p_intf, mvar_t  *vars,
126                       rpn_stack_t *st, char *exp )
127 {
128     intf_sys_t    *p_sys = p_intf->p_sys;
129
130     while( exp != NULL && *exp != '\0' )
131     {
132         char *p, *s;
133
134         /* skip space */
135         while( *exp == ' ' )
136         {
137             exp++;
138         }
139
140         if( *exp == '\'' )
141         {
142             /* extract string */
143             p = FirstWord( exp, exp );
144             SSPush( st, exp );
145             exp = p;
146             continue;
147         }
148
149         /* extract token */
150         p = FirstWord( exp, exp );
151         s = exp;
152         if( p == NULL )
153         {
154             exp += strlen( exp );
155         }
156         else
157         {
158             exp = p;
159         }
160
161         if( *s == '\0' )
162         {
163             break;
164         }
165
166         /* 1. Integer function */
167         if( !strcmp( s, "!" ) )
168         {
169             SSPushN( st, ~SSPopN( st, vars ) );
170         }
171         else if( !strcmp( s, "^" ) )
172         {
173             SSPushN( st, SSPopN( st, vars ) ^ SSPopN( st, vars ) );
174         }
175         else if( !strcmp( s, "&" ) )
176         {
177             SSPushN( st, SSPopN( st, vars ) & SSPopN( st, vars ) );
178         }
179         else if( !strcmp( s, "|" ) )
180         {
181             SSPushN( st, SSPopN( st, vars ) | SSPopN( st, vars ) );
182         }
183         else if( !strcmp( s, "+" ) )
184         {
185             SSPushN( st, SSPopN( st, vars ) + SSPopN( st, vars ) );
186         }
187         else if( !strcmp( s, "-" ) )
188         {
189             int j = SSPopN( st, vars );
190             int i = SSPopN( st, vars );
191             SSPushN( st, i - j );
192         }
193         else if( !strcmp( s, "*" ) )
194         {
195             SSPushN( st, SSPopN( st, vars ) * SSPopN( st, vars ) );
196         }
197         else if( !strcmp( s, "/" ) )
198         {
199             int i, j;
200
201             j = SSPopN( st, vars );
202             i = SSPopN( st, vars );
203
204             SSPushN( st, j != 0 ? i / j : 0 );
205         }
206         else if( !strcmp( s, "%" ) )
207         {
208             int i, j;
209
210             j = SSPopN( st, vars );
211             i = SSPopN( st, vars );
212
213             SSPushN( st, j != 0 ? i % j : 0 );
214         }
215         /* 2. integer tests */
216         else if( !strcmp( s, "=" ) )
217         {
218             SSPushN( st, SSPopN( st, vars ) == SSPopN( st, vars ) ? -1 : 0 );
219         }
220         else if( !strcmp( s, "!=" ) )
221         {
222             SSPushN( st, SSPopN( st, vars ) != SSPopN( st, vars ) ? -1 : 0 );
223         }
224         else if( !strcmp( s, "<" ) )
225         {
226             int j = SSPopN( st, vars );
227             int i = SSPopN( st, vars );
228
229             SSPushN( st, i < j ? -1 : 0 );
230         }
231         else if( !strcmp( s, ">" ) )
232         {
233             int j = SSPopN( st, vars );
234             int i = SSPopN( st, vars );
235
236             SSPushN( st, i > j ? -1 : 0 );
237         }
238         else if( !strcmp( s, "<=" ) )
239         {
240             int j = SSPopN( st, vars );
241             int i = SSPopN( st, vars );
242
243             SSPushN( st, i <= j ? -1 : 0 );
244         }
245         else if( !strcmp( s, ">=" ) )
246         {
247             int j = SSPopN( st, vars );
248             int i = SSPopN( st, vars );
249
250             SSPushN( st, i >= j ? -1 : 0 );
251         }
252         /* 3. string functions */
253         else if( !strcmp( s, "strcat" ) )
254         {
255             char *s2 = SSPop( st );
256             char *s1 = SSPop( st );
257             char *str = malloc( strlen( s1 ) + strlen( s2 ) + 1 );
258
259             strcpy( str, s1 );
260             strcat( str, s2 );
261
262             SSPush( st, str );
263             free( s1 );
264             free( s2 );
265             free( str );
266         }
267         else if( !strcmp( s, "strcmp" ) )
268         {
269             char *s2 = SSPop( st );
270             char *s1 = SSPop( st );
271
272             SSPushN( st, strcmp( s1, s2 ) );
273             free( s1 );
274             free( s2 );
275         }
276         else if( !strcmp( s, "strncmp" ) )
277         {
278             int n = SSPopN( st, vars );
279             char *s2 = SSPop( st );
280             char *s1 = SSPop( st );
281
282             SSPushN( st, strncmp( s1, s2 , n ) );
283             free( s1 );
284             free( s2 );
285         }
286         else if( !strcmp( s, "strsub" ) )
287         {
288             int n = SSPopN( st, vars );
289             int m = SSPopN( st, vars );
290             int i_len;
291             char *s = SSPop( st );
292             char *str;
293
294             if( n >= m )
295             {
296                 i_len = n - m + 1;
297             }
298             else
299             {
300                 i_len = 0;
301             }
302
303             str = malloc( i_len + 1 );
304
305             memcpy( str, s + m - 1, i_len );
306             str[ i_len ] = '\0';
307
308             SSPush( st, str );
309             free( s );
310             free( str );
311         }
312         else if( !strcmp( s, "strlen" ) )
313         {
314             char *str = SSPop( st );
315
316             SSPushN( st, strlen( str ) );
317             free( str );
318         }
319         else if( !strcmp( s, "str_replace" ) )
320         {
321             char *psz_to = SSPop( st );
322             char *psz_from = SSPop( st );
323             char *psz_in = SSPop( st );
324             char *psz_in_current = psz_in;
325             char *psz_out = malloc( strlen(psz_in) * strlen(psz_to) + 1 );
326             char *psz_out_current = psz_out;
327
328             while( (p = strstr( psz_in_current, psz_from )) != NULL )
329             {
330                 memcpy( psz_out_current, psz_in_current, p - psz_in_current );
331                 psz_out_current += p - psz_in_current;
332                 strcpy( psz_out_current, psz_to );
333                 psz_out_current += strlen(psz_to);
334                 psz_in_current = p + strlen(psz_from);
335             }
336             strcpy( psz_out_current, psz_in_current );
337             psz_out_current += strlen(psz_in_current);
338             *psz_out_current = '\0';
339
340             SSPush( st, psz_out );
341             free( psz_to );
342             free( psz_from );
343             free( psz_in );
344             free( psz_out );
345         }
346         else if( !strcmp( s, "url_extract" ) )
347         {
348             const char *url = mvar_GetValue( vars, "url_value" );
349             char *name = SSPop( st );
350             char *value = ExtractURIString( url, name );
351             if( value != NULL )
352             {
353                 decode_URI( value );
354                 SSPush( st, value );
355                 free( value );
356             }
357             else
358                 SSPush( st, "" );
359
360             free( name );
361         }
362         else if( !strcmp( s, "url_encode" ) )
363         {
364             char *url = SSPop( st );
365             char *value = vlc_UrlEncode( url );
366             free( url );
367             SSPush( st, value );
368             free( value );
369         }
370         else if( !strcmp( s, "xml_encode" ) )
371         {
372             char *url = SSPop( st );
373             char *value = convert_xml_special_chars( url );
374             free( url );
375             SSPush( st, value );
376             free( value );
377         }
378         else if( !strcmp( s, "addslashes" ) )
379         {
380             char *psz_src = SSPop( st );
381             char *psz_dest;
382             char *str = psz_src;
383
384             p = psz_dest = malloc( strlen( str ) * 2 + 1 );
385
386             while( *str != '\0' )
387             {
388                 if( *str == '"' || *str == '\'' || *str == '\\' )
389                 {
390                     *p++ = '\\';
391                 }
392                 *p++ = *str;
393                 str++;
394             }
395             *p = '\0';
396
397             SSPush( st, psz_dest );
398             free( psz_src );
399             free( psz_dest );
400         }
401         else if( !strcmp( s, "stripslashes" ) )
402         {
403             char *psz_src = SSPop( st );
404             char *psz_dest;
405             char *str = psz_src;
406
407             p = psz_dest = strdup( psz_src );
408
409             while( *str )
410             {
411                 if( *str == '\\' && *(str + 1) )
412                 {
413                     str++;
414                 }
415                 *p++ = *str++;
416             }
417             *p = '\0';
418
419             SSPush( st, psz_dest );
420             free( psz_src );
421             free( psz_dest );
422         }
423         else if( !strcmp( s, "htmlspecialchars" ) )
424         {
425             char *psz_src = SSPop( st );
426             char *psz_dest;
427
428             psz_dest = convert_xml_special_chars( psz_src );
429
430             SSPush( st, psz_dest );
431             free( psz_src );
432             free( psz_dest );
433         }
434         else if( !strcmp( s, "realpath" ) )
435         {
436             char *psz_src = SSPop( st );
437             char *psz_dir = RealPath( psz_src );
438
439             SSPush( st, psz_dir );
440             free( psz_src );
441             free( psz_dir );
442         }
443         /* 4. stack functions */
444         else if( !strcmp( s, "dup" ) )
445         {
446             char *str = SSPop( st );
447             SSPush( st, str );
448             SSPush( st, str );
449             free( str );
450         }
451         else if( !strcmp( s, "drop" ) )
452         {
453             char *str = SSPop( st );
454             free( str );
455         }
456         else if( !strcmp( s, "swap" ) )
457         {
458             char *s1 = SSPop( st );
459             char *s2 = SSPop( st );
460
461             SSPush( st, s1 );
462             SSPush( st, s2 );
463             free( s1 );
464             free( s2 );
465         }
466         else if( !strcmp( s, "flush" ) )
467         {
468             SSClean( st );
469             SSInit( st );
470         }
471         else if( !strcmp( s, "store" ) )
472         {
473             char *value = SSPop( st );
474             char *name  = SSPop( st );
475
476             mvar_PushNewVar( vars, name, value );
477             free( name );
478             free( value );
479         }
480         else if( !strcmp( s, "value" ) )
481         {
482             char *name  = SSPop( st );
483             const char *value = mvar_GetValue( vars, name );
484
485             SSPush( st, value );
486
487             free( name );
488         }
489         /* 5. player control */
490         else if( !strcmp( s, "vlc_play" ) )
491         {
492             int i_id = SSPopN( st, vars );
493             int i_ret;
494
495             playlist_Lock( p_sys->p_playlist );
496             i_ret = playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
497                                       pl_Locked, NULL,
498                                       playlist_ItemGetById( p_sys->p_playlist,
499                                       i_id, pl_Locked ) );
500             playlist_Unlock( p_sys->p_playlist );
501             msg_Dbg( p_intf, "requested playlist item: %i", i_id );
502             SSPushN( st, i_ret );
503         }
504         else if( !strcmp( s, "vlc_stop" ) )
505         {
506             playlist_Control( p_sys->p_playlist, PLAYLIST_STOP, pl_Unlocked );
507             msg_Dbg( p_intf, "requested playlist stop" );
508         }
509         else if( !strcmp( s, "vlc_pause" ) )
510         {
511             playlist_Control( p_sys->p_playlist, PLAYLIST_PAUSE, pl_Unlocked );
512             msg_Dbg( p_intf, "requested playlist pause" );
513         }
514         else if( !strcmp( s, "vlc_next" ) )
515         {
516             playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, 1 );
517             msg_Dbg( p_intf, "requested playlist next" );
518         }
519         else if( !strcmp( s, "vlc_previous" ) )
520         {
521             playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP, pl_Unlocked, -1 );
522             msg_Dbg( p_intf, "requested playlist previous" );
523         }
524         else if( !strcmp( s, "vlc_seek" ) )
525         {
526             char *psz_value = SSPop( st );
527             HandleSeek( p_intf, psz_value );
528             msg_Dbg( p_intf, "requested playlist seek: %s", psz_value );
529             free( psz_value );
530         }
531         else if( !strcmp( s, "vlc_var_type" )
532                   || !strcmp( s, "vlc_config_type" ) )
533         {
534             vlc_object_t *p_object;
535             const char *psz_type = NULL;
536             int i_type = 0;
537
538             if( !strcmp( s, "vlc_var_type" ) )
539             {
540                 char *psz_object = SSPop( st );
541                 char *psz_variable = SSPop( st );
542                 bool b_need_release;
543
544                 p_object = GetVLCObject( p_intf, psz_object, &b_need_release );
545
546                 if( p_object != NULL )
547                     i_type = var_Type( p_object, psz_variable );
548                 free( psz_variable );
549                 free( psz_object );
550                 if( b_need_release && p_object != NULL )
551                     vlc_object_release( p_object );
552             }
553             else
554             {
555                 char *psz_variable = SSPop( st );
556                 p_object = VLC_OBJECT(p_intf);
557                 i_type = config_GetType( p_object, psz_variable );
558                 free( psz_variable );
559             }
560
561             if( p_object != NULL )
562             {
563                 switch( i_type & VLC_VAR_TYPE )
564                 {
565                 case VLC_VAR_BOOL:
566                     psz_type = "VLC_VAR_BOOL";
567                     break;
568                 case VLC_VAR_INTEGER:
569                     psz_type = "VLC_VAR_INTEGER";
570                     break;
571                 case VLC_VAR_HOTKEY:
572                     psz_type = "VLC_VAR_HOTKEY";
573                     break;
574                 case VLC_VAR_STRING:
575                     psz_type = "VLC_VAR_STRING";
576                     break;
577                 case VLC_VAR_MODULE:
578                     psz_type = "VLC_VAR_MODULE";
579                     break;
580                 case VLC_VAR_FILE:
581                     psz_type = "VLC_VAR_FILE";
582                     break;
583                 case VLC_VAR_DIRECTORY:
584                     psz_type = "VLC_VAR_DIRECTORY";
585                     break;
586                 case VLC_VAR_VARIABLE:
587                     psz_type = "VLC_VAR_VARIABLE";
588                     break;
589                 case VLC_VAR_FLOAT:
590                     psz_type = "VLC_VAR_FLOAT";
591                     break;
592                 default:
593                     psz_type = "UNDEFINED";
594                 }
595             }
596             else
597                 psz_type = "INVALID";
598
599             SSPush( st, psz_type );
600         }
601         else if( !strcmp( s, "vlc_var_set" ) )
602         {
603             char *psz_object = SSPop( st );
604             char *psz_variable = SSPop( st );
605             bool b_need_release;
606
607             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
608                                                    &b_need_release );
609
610             if( p_object != NULL )
611             {
612                 bool b_error = false;
613                 char *psz_value = NULL;
614                 vlc_value_t val;
615                 int i_type;
616
617                 i_type = var_Type( p_object, psz_variable );
618
619                 switch( i_type & VLC_VAR_TYPE )
620                 {
621                 case VLC_VAR_BOOL:
622                     val.b_bool = SSPopN( st, vars );
623                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
624                              psz_object, psz_variable, val.b_bool );
625                     break;
626                 case VLC_VAR_INTEGER:
627                 case VLC_VAR_HOTKEY:
628                     val.i_int = SSPopN( st, vars );
629                     msg_Dbg( p_intf, "requested %s var change: %s->%d",
630                              psz_object, psz_variable, val.i_int );
631                     break;
632                 case VLC_VAR_STRING:
633                 case VLC_VAR_MODULE:
634                 case VLC_VAR_FILE:
635                 case VLC_VAR_DIRECTORY:
636                 case VLC_VAR_VARIABLE:
637                     val.psz_string = psz_value = SSPop( st );
638                     msg_Dbg( p_intf, "requested %s var change: %s->%s",
639                              psz_object, psz_variable, psz_value );
640                     break;
641                 case VLC_VAR_FLOAT:
642                     psz_value = SSPop( st );
643                     val.f_float = atof( psz_value );
644                     msg_Dbg( p_intf, "requested %s var change: %s->%f",
645                              psz_object, psz_variable, val.f_float );
646                     break;
647                 default:
648                     SSPopN( st, vars );
649                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
650                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
651                     b_error = true;
652                 }
653
654                 if( !b_error )
655                     var_Set( p_object, psz_variable, val );
656                 if( psz_value != NULL )
657                     free( psz_value );
658             }
659             else
660                 msg_Warn( p_intf, "vlc_var_set called without an object" );
661             free( psz_variable );
662             free( psz_object );
663
664             if( b_need_release && p_object != NULL )
665                 vlc_object_release( p_object );
666         }
667         else if( !strcmp( s, "vlc_var_get" ) )
668         {
669             char *psz_object = SSPop( st );
670             char *psz_variable = SSPop( st );
671             bool b_need_release;
672
673             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
674                                                    &b_need_release );
675
676             if( p_object != NULL )
677             {
678                 vlc_value_t val;
679                 int i_type;
680
681                 i_type = var_Type( p_object, psz_variable );
682                 var_Get( p_object, psz_variable, &val );
683
684                 switch( i_type & VLC_VAR_TYPE )
685                 {
686                 case VLC_VAR_BOOL:
687                     SSPushN( st, val.b_bool );
688                     break;
689                 case VLC_VAR_INTEGER:
690                 case VLC_VAR_HOTKEY:
691                     SSPushN( st, val.i_int );
692                     break;
693                 case VLC_VAR_STRING:
694                 case VLC_VAR_MODULE:
695                 case VLC_VAR_FILE:
696                 case VLC_VAR_DIRECTORY:
697                 case VLC_VAR_VARIABLE:
698                     SSPush( st, val.psz_string );
699                     free( val.psz_string );
700                     break;
701                 case VLC_VAR_FLOAT:
702                 {
703                     char psz_value[20];
704                     lldiv_t value = lldiv( val.f_float * 1000000, 1000000 );
705                     snprintf( psz_value, sizeof(psz_value), "%lld.%06u",
706                                     value.quot, (unsigned int)value.rem );
707                     SSPush( st, psz_value );
708                     break;
709                 }
710                 default:
711                     msg_Warn( p_intf, "invalid %s variable type %d (%s)",
712                               psz_object, i_type & VLC_VAR_TYPE, psz_variable );
713                     SSPush( st, "" );
714                 }
715             }
716             else
717             {
718                 msg_Warn( p_intf, "vlc_var_get called without an object" );
719                 SSPush( st, "" );
720             }
721             free( psz_variable );
722             free( psz_object );
723
724             if( b_need_release && p_object != NULL )
725                 vlc_object_release( p_object );
726         }
727         else if( !strcmp( s, "vlc_object_exists" ) )
728         {
729             char *psz_object = SSPop( st );
730             bool b_need_release;
731
732             vlc_object_t *p_object = GetVLCObject( p_intf, psz_object,
733                                                    &b_need_release );
734             if( b_need_release && p_object != NULL )
735                 vlc_object_release( p_object );
736
737             if( p_object != NULL )
738                 SSPush( st, "1" );
739             else
740                 SSPush( st, "0" );
741         }
742         else if( !strcmp( s, "vlc_config_set" ) )
743         {
744             char *psz_variable = SSPop( st );
745             int i_type = config_GetType( p_intf, psz_variable );
746
747             switch( i_type & VLC_VAR_TYPE )
748             {
749             case VLC_VAR_BOOL:
750             case VLC_VAR_INTEGER:
751                 config_PutInt( p_intf, psz_variable, SSPopN( st, vars ) );
752                 break;
753             case VLC_VAR_STRING:
754             case VLC_VAR_MODULE:
755             case VLC_VAR_FILE:
756             case VLC_VAR_DIRECTORY:
757             {
758                 char *psz_string = SSPop( st );
759                 config_PutPsz( p_intf, psz_variable, psz_string );
760                 free( psz_string );
761                 break;
762             }
763             case VLC_VAR_FLOAT:
764             {
765                 char *psz_string = SSPop( st );
766                 config_PutFloat( p_intf, psz_variable, atof(psz_string) );
767                 free( psz_string );
768                 break;
769             }
770             default:
771                 msg_Warn( p_intf, "vlc_config_set called on unknown var (%s)",
772                           psz_variable );
773             }
774             free( psz_variable );
775         }
776         else if( !strcmp( s, "vlc_config_get" ) )
777         {
778             char *psz_variable = SSPop( st );
779             int i_type = config_GetType( p_intf, psz_variable );
780
781             switch( i_type & VLC_VAR_TYPE )
782             {
783             case VLC_VAR_BOOL:
784             case VLC_VAR_INTEGER:
785                 SSPushN( st, config_GetInt( p_intf, psz_variable ) );
786                 break;
787             case VLC_VAR_STRING:
788             case VLC_VAR_MODULE:
789             case VLC_VAR_FILE:
790             case VLC_VAR_DIRECTORY:
791             {
792                 char *psz_string = config_GetPsz( p_intf, psz_variable );
793                 SSPush( st, psz_string );
794                 free( psz_string );
795                 break;
796             }
797             case VLC_VAR_FLOAT:
798             {
799                 char psz_string[20];
800                 lldiv_t value = lldiv( config_GetFloat( p_intf, psz_variable )
801                                        * 1000000, 1000000 );
802                 snprintf( psz_string, sizeof(psz_string), "%lld.%06u",
803                           value.quot, (unsigned int)value.rem );
804                 SSPush( st, psz_string );
805                 break;
806             }
807             default:
808                 msg_Warn( p_intf, "vlc_config_get called on unknown var (%s)",
809                           psz_variable );
810                 SSPush( st, "" );
811             }
812             free( psz_variable );
813         }
814         else if( !strcmp( s, "vlc_config_save" ) )
815         {
816             char *psz_module = SSPop( st );
817             int i_result;
818
819             if( !*psz_module )
820             {
821                 free( psz_module );
822                 psz_module = NULL;
823             }
824             i_result = config_SaveConfigFile( p_intf, psz_module );
825
826             if( psz_module != NULL )
827                 free( psz_module );
828             SSPushN( st, i_result );
829         }
830         else if( !strcmp( s, "vlc_config_reset" ) )
831         {
832             config_ResetAll( p_intf );
833         }
834         /* 6. playlist functions */
835         else if( !strcmp( s, "playlist_add" ) )
836         {
837             char *psz_name = SSPop( st );
838             char *mrl = SSPop( st );
839             input_item_t *p_input;
840             int i_ret;
841
842             p_input = MRLParse( p_intf, mrl, psz_name );
843
844             char *psz_uri = input_item_GetURI( p_input );
845             if( !p_input || !psz_uri || !*psz_uri )
846             {
847                 i_ret = VLC_EGENERIC;
848                 msg_Dbg( p_intf, "invalid requested mrl: %s", mrl );
849             }
850             else
851             {
852                 i_ret = playlist_AddInput( p_sys->p_playlist, p_input,
853                                    PLAYLIST_APPEND, PLAYLIST_END, true,
854                                    pl_Unlocked );
855                 if( i_ret == VLC_SUCCESS )
856                 {
857                     playlist_item_t *p_item;
858                     msg_Dbg( p_intf, "requested mrl add: %s", mrl );
859                     p_item = playlist_ItemGetByInput( p_sys->p_playlist,
860                                                       p_input,
861                                                       pl_Unlocked );
862                     if( p_item )
863                         i_ret = p_item->i_id;
864                 }
865                 else
866                     msg_Warn( p_intf, "adding mrl %s failed", mrl );
867                 vlc_gc_decref( p_input );
868             }
869             free( psz_uri );
870             SSPushN( st, i_ret );
871
872             free( mrl );
873             free( psz_name );
874         }
875         else if( !strcmp( s, "playlist_empty" ) )
876         {
877             playlist_Clear( p_sys->p_playlist, pl_Unlocked );
878             msg_Dbg( p_intf, "requested playlist empty" );
879         }
880         else if( !strcmp( s, "playlist_delete" ) )
881         {
882             int i_id = SSPopN( st, vars );
883             playlist_item_t *p_item = playlist_ItemGetById( p_sys->p_playlist,
884                                                             i_id, pl_Unlocked );
885             if( p_item )
886             {
887                 playlist_DeleteFromInput( p_sys->p_playlist,
888                                           p_item->p_input->i_id, pl_Unlocked );
889                 msg_Dbg( p_intf, "requested playlist delete: %d", i_id );
890             }
891             else
892             {
893                 msg_Dbg( p_intf, "couldn't find playlist item to delete (%d)",
894                          i_id );
895             }
896         }
897         else if( !strcmp( s, "playlist_move" ) )
898         {
899             /*int i_newpos =*/ SSPopN( st, vars );
900             /*int i_pos =*/ SSPopN( st, vars );
901             /* FIXME FIXME TODO TODO XXX XXX
902             do not release before fixing this
903             if ( i_pos < i_newpos )
904             {
905                 playlist_Move( p_sys->p_playlist, i_pos, i_newpos + 1 );
906             }
907             else
908             {
909                 playlist_Move( p_sys->p_playlist, i_pos, i_newpos );
910             }
911             msg_Dbg( p_intf, "requested to move playlist item %d to %d",
912                      i_pos, i_newpos);
913                FIXME FIXME TODO TODO XXX XXX */
914             msg_Err( p_intf, "moving using indexes is obsolete. We need to update this function" );
915         }
916         else if( !strcmp( s, "playlist_sort" ) )
917         {
918             int i_order = SSPopN( st, vars );
919             int i_sort = SSPopN( st, vars );
920             i_order = i_order % 2;
921             i_sort = i_sort % 9;
922             /* FIXME FIXME TODO TODO XXX XXX
923             do not release before fixing this
924             playlist_RecursiveNodeSort(  p_sys->p_playlist,
925                                          p_sys->p_playlist->p_general,
926                                          i_sort, i_order );
927             msg_Dbg( p_intf, "requested sort playlist by : %d in order : %d",
928                      i_sort, i_order );
929                FIXME FIXME TODO TODO XXX XXX */
930             msg_Err( p_intf, "this needs to be fixed to use the new playlist framework" );
931         }
932         else if( !strcmp( s, "services_discovery_add" ) )
933         {
934             char *psz_sd = SSPop( st );
935             playlist_ServicesDiscoveryAdd( p_sys->p_playlist, psz_sd );
936             free( psz_sd );
937         }
938         else if( !strcmp( s, "services_discovery_remove" ) )
939         {
940             char *psz_sd = SSPop( st );
941             playlist_ServicesDiscoveryRemove( p_sys->p_playlist, psz_sd );
942             free( psz_sd );
943         }
944         else if( !strcmp( s, "services_discovery_is_loaded" ) )
945         {
946             char *psz_sd = SSPop( st );
947             SSPushN( st,
948             playlist_IsServicesDiscoveryLoaded( p_sys->p_playlist, psz_sd ) );
949             free( psz_sd );
950         }
951         else if( !strcmp( s, "vlc_volume_set" ) )
952         {
953             char *psz_vol = SSPop( st );
954             int i_value;
955             audio_volume_t i_volume;
956             aout_VolumeGet( p_intf, &i_volume );
957             if( psz_vol[0] == '+' )
958             {
959                 i_value = atoi( psz_vol );
960                 if( (i_volume + i_value) > AOUT_VOLUME_MAX )
961                     aout_VolumeSet( p_intf, AOUT_VOLUME_MAX );
962                 else
963                     aout_VolumeSet( p_intf, i_volume + i_value );
964             }
965             else if( psz_vol[0] == '-' )
966             {
967                 i_value = atoi( psz_vol );
968                 if( (i_volume + i_value) < AOUT_VOLUME_MIN )
969                     aout_VolumeSet( p_intf, AOUT_VOLUME_MIN );
970                 else
971                     aout_VolumeSet( p_intf, i_volume + i_value );
972             }
973             else if( strstr( psz_vol, "%") != NULL )
974             {
975                 i_value = atoi( psz_vol );
976                 if( i_value < 0 ) i_value = 0;
977                 if( i_value > 400 ) i_value = 400;
978                 aout_VolumeSet( p_intf, (i_value * (AOUT_VOLUME_MAX - AOUT_VOLUME_MIN))/400+AOUT_VOLUME_MIN);
979             }
980             else
981             {
982                 i_value = atoi( psz_vol );
983                 if( i_value > AOUT_VOLUME_MAX ) i_value = AOUT_VOLUME_MAX;
984                 if( i_value < AOUT_VOLUME_MIN ) i_value = AOUT_VOLUME_MIN;
985                 aout_VolumeSet( p_intf, i_value );
986             }
987             aout_VolumeGet( p_intf, &i_volume );
988             free( psz_vol );
989         }
990         else if( !strcmp( s, "vlc_get_meta" ) )
991         {
992             char *psz_meta = SSPop( st );
993             char *psz_val = NULL;
994             if( p_sys->p_input && input_GetItem(p_sys->p_input) )
995             {
996 #define p_item input_GetItem( p_sys->p_input )
997                 if( !strcmp( psz_meta, "ARTIST" ) )
998                 {
999                     psz_val = input_item_GetArtist( p_item );
1000                 }
1001                 else if( !strcmp( psz_meta, "TITLE" ) )
1002                 {
1003                     psz_val = input_item_GetTitle( p_item );
1004                     if( !psz_val )
1005                         psz_val = input_item_GetName( p_item );
1006                 }
1007                 else if( !strcmp( psz_meta, "ALBUM" ) )
1008                 {
1009                     psz_val = input_item_GetAlbum( p_item );
1010                 }
1011                 else if( !strcmp( psz_meta, "GENRE" ) )
1012                 {
1013                     psz_val = input_item_GetGenre( p_item );
1014                 }
1015                 else if( !strcmp( psz_meta, "COPYRIGHT" ) )
1016                 {
1017                      psz_val = input_item_GetCopyright( p_item );
1018                 }
1019                 else if( !strcmp( psz_meta, "TRACK_NUMBER" ) )
1020                 {
1021                     psz_val = input_item_GetTrackNum( p_item );
1022                 }
1023                 else if( !strcmp( psz_meta, "DESCRIPTION" ) )
1024                 {
1025                     psz_val = input_item_GetDescription( p_item );
1026                 }
1027                 else if( !strcmp( psz_meta, "RATING" ) )
1028                 {
1029                     psz_val = input_item_GetRating( p_item );
1030                 }
1031                 else if( !strcmp( psz_meta, "DATE" ) )
1032                 {
1033                     psz_val = input_item_GetDate( p_item );
1034                 }
1035                 else if( !strcmp( psz_meta, "URL" ) )
1036                 {
1037                     psz_val = input_item_GetURL( p_item );
1038                 }
1039                 else if( !strcmp( psz_meta, "LANGUAGE" ) )
1040                 {
1041                     psz_val = input_item_GetLanguage( p_item );
1042                 }
1043                 else if( !strcmp( psz_meta, "NOW_PLAYING" ) )
1044                 {
1045                     psz_val = input_item_GetNowPlaying( p_item );
1046                 }
1047                 else if( !strcmp( psz_meta, "PUBLISHER" ) )
1048                 {
1049                     psz_val = input_item_GetPublisher( p_item );
1050                 }
1051                 else if( !strcmp( psz_meta, "ENCODED_BY" ) )
1052                 {
1053                     psz_val = input_item_GetEncodedBy( p_item );
1054                 }
1055                 else if( !strcmp( psz_meta, "ART_URL" ) )
1056                 {
1057                     psz_val = input_item_GetEncodedBy( p_item );
1058                 }
1059                 else if( !strcmp( psz_meta, "TRACK_ID" ) )
1060                 {
1061                     psz_val = input_item_GetTrackID( p_item );
1062                 }
1063 #undef p_item
1064             }
1065             if( psz_val == NULL ) psz_val = strdup( "" );
1066             SSPush( st, psz_val );
1067             free( psz_meta );
1068             free( psz_val );
1069         }
1070 #ifdef ENABLE_VLM
1071         else if( !strcmp( s, "vlm_command" ) || !strcmp( s, "vlm_cmd" ) )
1072         {
1073             char *psz_elt;
1074             char *psz_cmd = strdup( "" );
1075             char *psz_error;
1076             vlm_message_t *vlm_answer;
1077
1078             /* make sure that we have a vlm object */
1079             if( p_intf->p_sys->p_vlm == NULL )
1080                 p_intf->p_sys->p_vlm = vlm_New( p_intf );
1081
1082
1083             /* vlm command uses the ';' delimiter
1084              * (else we can't know when to stop) */
1085             while( strcmp( psz_elt = SSPop( st ), "" )
1086                    && strcmp( psz_elt, ";" ) )
1087             {
1088                 char* psz_buf;
1089                 if( asprintf( &psz_buf, "%s %s", psz_cmd, psz_elt ) == -1 )
1090                     psz_buf = NULL;
1091                 free( psz_cmd );
1092                 free( psz_elt );
1093                 psz_cmd = psz_buf;
1094             }
1095
1096             msg_Dbg( p_intf, "executing vlm command: %s", psz_cmd );
1097             vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz_cmd, &vlm_answer );
1098
1099             if( vlm_answer->psz_value == NULL )
1100             {
1101                 psz_error = strdup( "" );
1102             }
1103             else
1104             {
1105                 if( asprintf( &psz_error , "%s : %s" , vlm_answer->psz_name,
1106                               vlm_answer->psz_value ) == -1 )
1107                     psz_error = NULL;
1108             }
1109
1110             mvar_AppendNewVar( vars, "vlm_error", psz_error );
1111             /* this is kind of a duplicate but we need to have the message
1112              * without the command name for the "export" command */
1113             mvar_AppendNewVar( vars, "vlm_value", vlm_answer->psz_value );
1114             vlm_MessageDelete( vlm_answer );
1115
1116             free( psz_cmd );
1117             free( psz_error );
1118         }
1119 #endif /* ENABLE_VLM */
1120         else if( !strcmp( s, "snapshot" ) )
1121         {
1122             if( p_sys->p_input )
1123             {
1124                 vout_thread_t *p_vout = input_GetVout( p_sys->p_input );
1125                 if( p_vout )
1126                 {
1127                     vout_Control( p_vout, VOUT_SNAPSHOT );
1128                     vlc_object_release( p_vout );
1129                     msg_Dbg( p_intf, "requested snapshot" );
1130                 }
1131             }
1132             break;
1133
1134         }
1135         else
1136         {
1137             SSPush( st, s );
1138         }
1139     }
1140 }