开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
macro.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：40k
源码类别：

midi

开发平台：

Unix_Linux

macro.c：源码内容
  1. /*****************************************************************************
  2.  * macro.c : Custom <vlc> macro handling
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2005 the VideoLAN team
  5.  * $Id: 22e323177a4ac9e3ab9db8d0f4a946040e24f916 $
  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
  29. #include "http.h"
  30. #include "macros.h"
  31. #include "vlc_url.h"
  33. static int MacroParse( macro_t *m, char *psz_src )
  34. {
  35.     char *dup = strdup( (char *)psz_src );
  36.     char *src = dup;
  37.     char *p;
  38.     int     i_skip;
  40. #define EXTRACT( name, l ) 
  41.         src += l;    
  42.         p = strchr( src, '"' );             
  43.         if( p )                             
  44.         {                                   
  45.             *p++ = '';                    
  46.         }                                   
  47.         m->name = strdup( src );            
  48.         if( !p )                            
  49.         {                                   
  50.             break;                          
  51.         }                                   
  52.         src = p;
  54.     /* init m */
  55.     m->id = NULL;
  56.     m->param1 = NULL;
  57.     m->param2 = NULL;
  59.     /* parse */
  60.     src += 4;
  62.     while( *src )
  63.     {
  64.         while( *src == ' ')
  65.         {
  66.             src++;
  67.         }
  68.         if( !strncmp( src, "id="", 4 ) )
  69.         {
  70.             EXTRACT( id, 4 );
  71.         }
  72.         else if( !strncmp( src, "param1="", 8 ) )
  73.         {
  74.             EXTRACT( param1, 8 );
  75.         }
  76.         else if( !strncmp( src, "param2="", 8 ) )
  77.         {
  78.             EXTRACT( param2, 8 );
  79.         }
  80.         else
  81.         {
  82.             break;
  83.         }
  84.     }
  85.     if( strstr( src, "/>" ) )
  86.     {
  87.         src = strstr( src, "/>" ) + 2;
  88.     }
  89.     else
  90.     {
  91.         src += strlen( src );
  92.     }
  94.     if( m->id == NULL )
  95.     {
  96.         m->id = strdup( "" );
  97.     }
  98.     if( m->param1 == NULL )
  99.     {
  100.         m->param1 = strdup( "" );
  101.     }
  102.     if( m->param2 == NULL )
  103.     {
  104.         m->param2 = strdup( "" );
  105.     }
  106.     i_skip = src - dup;
  108.     free( dup );
  109.     return i_skip;
  110. #undef EXTRACT
  111. }
  113. static void MacroClean( macro_t *m )
  114. {
  115.     free( m->id );
  116.     free( m->param1 );
  117.     free( m->param2 );
  118. }
  120. static int StrToMacroType( const char *name )
  121. {
  122.     int i;
  124.     if( !name || *name == '')
  125.     {
  126.         return MVLC_UNKNOWN;
  127.     }
  128.     for( i = 0; StrToMacroTypeTab[i].psz_name != NULL; i++ )
  129.     {
  130.         if( !strcmp( name, StrToMacroTypeTab[i].psz_name ) )
  131.         {
  132.             return StrToMacroTypeTab[i].i_type;
  133.         }
  134.     }
  135.     return MVLC_UNKNOWN;
  136. }
  138. static void MacroDo( httpd_file_sys_t *p_args,
  139.                      macro_t *m,
  140.                      char *p_request, int i_request,
  141.                      char **pp_data,  int *pi_data,
  142.                      char **pp_dst )
  143. {
  144.     intf_thread_t  *p_intf = p_args->p_intf;
  145.     intf_sys_t     *p_sys = p_args->p_intf->p_sys;
  146.     char control[512];
  148. #define ALLOC( l ) 
  149.     {               
  150.         int __i__ = *pp_dst - *pp_data; 
  151.         *pi_data += (l);                  
  152.         *pp_data = realloc( *pp_data, *pi_data );   
  153.         *pp_dst = (*pp_data) + __i__;   
  154.     }
  155. #define PRINT( str ) 
  156.     ALLOC( strlen( str ) + 1 ); 
  157.     *pp_dst += sprintf( *pp_dst, "%s", str );
  159. #define PRINTS( str, s ) 
  160.     ALLOC( strlen( str ) + strlen( s ) + 1 ); 
  161.     { 
  162.         char * psz_cur = *pp_dst; 
  163.         *pp_dst += sprintf( *pp_dst, str, s ); 
  164.         while( psz_cur && *psz_cur ) 
  165.         {  
  166.             /* Prevent script injection */ 
  167.             if( *psz_cur == '<' ) *psz_cur = '*'; 
  168.             if( *psz_cur == '>' ) *psz_cur = '*'; 
  169.             psz_cur++ ; 
  170.         } 
  171.     }
  173.     switch( StrToMacroType( m->id ) )
  174.     {
  175.         case MVLC_CONTROL:
  176.             if( i_request <= 0 )
  177.             {
  178.                 break;
  179.             }
  180.             ExtractURIValue( p_request, "control", control, 512 );
  181.             if( *m->param1 && !strstr( m->param1, control ) )
  182.             {
  183.                 msg_Warn( p_intf, "unauthorized control=%s", control );
  184.                 break;
  185.             }
  186.             switch( StrToMacroType( control ) )
  187.             {
  188.                 case MVLC_PLAY:
  189.                 {
  190.                     int i_item;
  191.                     char item[512];
  193.                     ExtractURIValue( p_request, "item", item, 512 );
  194.                     i_item = atoi( item );
  195.                     /* id = 0 : simply ask playlist to play */
  196.                     if( i_item == 0 )
  197.                     {
  198.                         playlist_Play( p_sys->p_playlist );
  199.                         msg_Dbg( p_intf, "requested playlist play" );
  200.                         break;
  201.                     }
  202.                     //TODO: really locked here ?
  203.                     playlist_Control( p_sys->p_playlist, PLAYLIST_VIEWPLAY,
  204.                                       true, NULL,
  205.                                       playlist_ItemGetById( p_sys->p_playlist,
  206.                                       i_item ) );
  207.                     msg_Dbg( p_intf, "requested playlist item: %i", i_item );
  208.                     break;
  209.                 }
  210.                 case MVLC_STOP:
  211.                     playlist_Control( p_sys->p_playlist, PLAYLIST_STOP,
  212.                                       true );
  213.                     msg_Dbg( p_intf, "requested playlist stop" );
  214.                     break;
  215.                 case MVLC_PAUSE:
  216.                     playlist_Control( p_sys->p_playlist, PLAYLIST_PAUSE,
  217.                                       true );
  218.                     msg_Dbg( p_intf, "requested playlist pause" );
  219.                     break;
  220.                 case MVLC_NEXT:
  221.                     playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP,
  222.                                       true, 1 );
  223.                     msg_Dbg( p_intf, "requested playlist next" );
  224.                     break;
  225.                 case MVLC_PREVIOUS:
  226.                     playlist_Control( p_sys->p_playlist, PLAYLIST_SKIP,
  227.                                       true, -1 );
  228.                     msg_Dbg( p_intf, "requested playlist previous" );
  229.                     break;
  230.                 case MVLC_FULLSCREEN:
  231.                     if( p_sys->p_input )
  232.                     {
  233.                         vout_thread_t *p_vout;
  235.                         p_vout = input_GetVout( p_sys->p_input );
  236.                         if( p_vout )
  237.                         {
  238.                             var_SetBool( p_vout, "fullscreen", !var_GetBool( p_vout, "fullscreen" ) );
  239.                             vlc_object_release( p_vout );
  240.                             msg_Dbg( p_intf, "requested fullscreen toggle" );
  241.                         }
  242.                     }
  243.                     break;
  244.                 case MVLC_SEEK:
  245.                 {
  246.                     char value[30];
  247.                     ExtractURIValue( p_request, "seek_value", value, 30 );
  248.                     decode_URI( value );
  249.                     HandleSeek( p_intf, value );
  250.                     break;
  251.                 }
  252.                 case MVLC_VOLUME:
  253.                 {
  254.                     char vol[8];
  255.                     audio_volume_t i_volume;
  256.                     int i_value;
  258.                     ExtractURIValue( p_request, "value", vol, 8 );
  259.                     aout_VolumeGet( p_intf, &i_volume );
  260.                     decode_URI( vol );
  262.                     if( vol[0] == '+' )
  263.                     {
  264.                         i_value = atoi( vol + 1 );
  265.                         if( (i_volume + i_value) > AOUT_VOLUME_MAX )
  266.                         {
  267.                             aout_VolumeSet( p_intf , AOUT_VOLUME_MAX );
  268.                             msg_Dbg( p_intf, "requested volume set: max" );
  269.                         }
  270.                         else
  271.                         {
  272.                             aout_VolumeSet( p_intf , (i_volume + i_value) );
  273.                             msg_Dbg( p_intf, "requested volume set: +%i", (i_volume + i_value) );
  274.                         }
  275.                     }
  276.                     else if( vol[0] == '-' )
  277.                     {
  278.                         i_value = atoi( vol + 1 );
  279.                         if( (i_volume - i_value) < AOUT_VOLUME_MIN )
  280.                         {
  281.                             aout_VolumeSet( p_intf , AOUT_VOLUME_MIN );
  282.                             msg_Dbg( p_intf, "requested volume set: min" );
  283.                         }
  284.                         else
  285.                         {
  286.                             aout_VolumeSet( p_intf , (i_volume - i_value) );
  287.                             msg_Dbg( p_intf, "requested volume set: -%i", (i_volume - i_value) );
  288.                         }
  289.                     }
  290.                     else if( strstr(vol, "%") != NULL )
  291.                     {
  292.                         i_value = atoi( vol );
  293.                         if( (i_value <= 400) && (i_value>=0) ){
  294.                             aout_VolumeSet( p_intf, (i_value * (AOUT_VOLUME_MAX - AOUT_VOLUME_MIN))/400+AOUT_VOLUME_MIN);
  295.                             msg_Dbg( p_intf, "requested volume set: %i%%", atoi( vol ));
  296.                         }
  297.                     }
  298.                     else
  299.                     {
  300.                         i_value = atoi( vol );
  301.                         if( ( i_value <= AOUT_VOLUME_MAX ) && ( i_value >= AOUT_VOLUME_MIN ) )
  302.                         {
  303.                             aout_VolumeSet( p_intf , atoi( vol ) );
  304.                             msg_Dbg( p_intf, "requested volume set: %i", atoi( vol ) );
  305.                         }
  306.                     }
  307.                     break;
  308.                 }
  310.                 /* playlist management */
  311.                 case MVLC_ADD:
  312.                 {
  313.                     char mrl[1024], psz_name[1024], tmp[1024];
  314.                     char *p, *str;
  315.                     input_item_t *p_input;
  317.                     ExtractURIValue( p_request, "mrl", tmp, 1024 );
  318.                     decode_URI( tmp );
  319.                     ExtractURIValue( p_request, "name", psz_name, 1024 );
  320.                     decode_URI( psz_name );
  321.                     if( !*psz_name )
  322.                     {
  323.                         memcpy( psz_name, tmp, 1024 );
  324.                     }
  325.                     /* addslashes for backward compatibility with the old
  326.                      * http intf */
  327.                     p = mrl; str = tmp;
  328.                     while( *str != '' )
  329.                     {
  330.                         if( *str == '"' || *str == ''' || *str == '\' )
  331.                         {
  332.                             *p++ = '\';
  333.                         }
  334.                         *p++ = *str;
  335.                         str++;
  336.                     }
  337.                     *p = '';
  339.                     p_input = MRLParse( p_intf, mrl, psz_name );
  341.                     char *psz_uri = p_input ? input_item_GetURI( p_input ) : NULL;
  342.                     if( psz_uri && *psz_uri &&
  343.                         playlist_AddInput( p_sys->p_playlist, p_input,
  344.                                            PLAYLIST_APPEND, PLAYLIST_END,
  345.                                            true, false) == VLC_SUCCESS )
  346.                         msg_Dbg( p_intf, "requested mrl add: %s", mrl );
  347.                     else
  348.                         msg_Warn( p_intf, "adding mrl failed: %s", mrl );
  349.                     free( psz_uri );
  350.                     if( p_input )
  351.                         vlc_gc_decref( p_input );
  352.                     break;
  353.                 }
  354.                 case MVLC_DEL:
  355.                 {
  356.                     int i_item, *p_items = NULL, i_nb_items = 0;
  357.                     char item[512];
  358.                     const char *p_parser = p_request;
  360.                     /* Get the list of items to delete */
  361.                     while( (p_parser =
  362.                             ExtractURIValue( p_parser, "item", item, 512 )) )
  363.                     {
  364.                         if( !*item ) continue;
  366.                         i_item = atoi( item );
  367.                         p_items = realloc( p_items, (i_nb_items + 1) *
  368.                                            sizeof(int) );
  369.                         p_items[i_nb_items] = i_item;
  370.                         i_nb_items++;
  371.                     }
  373.                     if( i_nb_items )
  374.                     {
  375.                         int i;
  376.                         for( i = 0; i < i_nb_items; i++ )
  377.                         {
  378.                             playlist_DeleteFromInput( p_sys->p_playlist,
  379.                                                       p_items[i], false );
  380.                             msg_Dbg( p_intf, "requested playlist delete: %d",
  381.                                      p_items[i] );
  382.                             p_items[i] = -1;
  383.                         }
  384.                     }
  386.                     free( p_items );
  387.                     break;
  388.                 }
  389.                 case MVLC_KEEP:
  390.                 {
  391.                     int i_item, *p_items = NULL, i_nb_items = 0;
  392.                     char item[512];
  393.                     const char *p_parser = p_request;
  394.                     int i,j;
  396.                     /* Get the list of items to keep */
  397.                     while( (p_parser =
  398.                        ExtractURIValue( p_parser, "item", item, 512 )) )
  399.                     {
  400.                         if( !*item ) continue;
  402.                         i_item = atoi( item );
  403.                         p_items = realloc( p_items, (i_nb_items + 1) *
  404.                                            sizeof(int) );
  405.                         p_items[i_nb_items] = i_item;
  406.                         i_nb_items++;
  407.                     }
  409.                     for( i = p_sys->p_playlist->items.i_size - 1 ; i >= 0; i-- )
  410.                     {
  411.                         /* Check if the item is in the keep list */
  412.                         for( j = 0 ; j < i_nb_items ; j++ )
  413.                         {
  414.                             if( p_items[j] ==
  415.                                  ARRAY_VAL(p_sys->p_playlist->items,i)
  416.                                                 ->i_id)
  417.                                 break;
  418.                         }
  419.                         if( j == i_nb_items )
  420.                         {
  421.                             playlist_DeleteFromInput( p_sys->p_playlist,
  422.                                      p_sys->p_playlist->items.p_elems[i]->i_id,
  423.                                                       false );
  424.                             msg_Dbg( p_intf, "requested playlist delete: %d",
  425.                                      i );
  426.                         }
  427.                     }
  429.                     free( p_items );
  430.                     break;
  431.                 }
  432.                 case MVLC_EMPTY:
  433.                 {
  434.                     playlist_Clear( p_sys->p_playlist, false );
  435.                     msg_Dbg( p_intf, "requested playlist empty" );
  436.                     break;
  437.                 }
  438.                 case MVLC_SORT:
  439.                 {
  440.                     char type[12];
  441.                     char order[2];
  442.                     char item[512];
  443.                     int i_order;
  444.                     int i_item;
  446.                     ExtractURIValue( p_request, "type", type, 12 );
  447.                     ExtractURIValue( p_request, "order", order, 2 );
  448.                     ExtractURIValue( p_request, "item", item, 512 );
  449.                     i_item = atoi( item );
  451.                     if( order[0] == '0' ) i_order = ORDER_NORMAL;
  452.                     else i_order = ORDER_REVERSE;
  454.                     if( !strcmp( type , "title" ) )
  455.                     {
  456.                         playlist_RecursiveNodeSort( p_sys->p_playlist,
  457.                                                     /* Ugly hack,but not worse than before ... */
  458.                                                     p_sys->p_playlist->p_root_onelevel,
  459.                                                     SORT_TITLE_NODES_FIRST,
  460.                                                     ( i_order == 0 ) ? ORDER_NORMAL : ORDER_REVERSE );
  461.                         msg_Dbg( p_intf, "requested playlist sort by title (%d)" , i_order );
  462.                     }
  463.                     else if( !strcmp( type , "author" ) )
  464.                     {
  465.                         playlist_RecursiveNodeSort( p_sys->p_playlist, /*playlist_ItemGetById( p_sys->p_playlist, i_item ),*/
  466.                                                     p_sys->p_playlist->p_root_onelevel,
  467.                                                     SORT_ARTIST,
  468.                                                     ( i_order == 0 ) ? ORDER_NORMAL : ORDER_REVERSE );
  469.                         msg_Dbg( p_intf, "requested playlist sort by author (%d)" , i_order );
  470.                     }
  471.                     else if( !strcmp( type , "shuffle" ) )
  472.                     {
  473.                         playlist_RecursiveNodeSort( p_sys->p_playlist, /*playlist_ItemGetById( p_sys->p_playlist, i_item ),*/
  474.                                                     p_sys->p_playlist->p_root_onelevel,
  475.                                                     SORT_RANDOM,
  476.                                                     ( i_order == 0 ) ? ORDER_NORMAL : ORDER_REVERSE );
  477.                         msg_Dbg( p_intf, "requested playlist shuffle");
  478.                     }
  480.                     break;
  481.                 }
  482.                 case MVLC_MOVE:
  483.                 {
  484.                     char psz_pos[6];
  485.                     char psz_newpos[6];
  486.                     int i_pos;
  487.                     int i_newpos;
  488.                     ExtractURIValue( p_request, "psz_pos", psz_pos, 6 );
  489.                     ExtractURIValue( p_request, "psz_newpos", psz_newpos, 6 );
  490.                     i_pos = atoi( psz_pos );
  491.                     i_newpos = atoi( psz_newpos );
  492.                     /* FIXME FIXME TODO TODO XXX XXX
  493.                     ( duplicate from rpn.c )
  494.                     if ( i_pos < i_newpos )
  495.                     {
  496.                         playlist_Move( p_sys->p_playlist, i_pos, i_newpos + 1 );
  497.                     }
  498.                     else
  499.                     {
  500.                         playlist_Move( p_sys->p_playlist, i_pos, i_newpos );
  501.                     }
  502.                     msg_Dbg( p_intf, "requested move playlist item %d to %d", i_pos, i_newpos);
  503.                     FIXME FIXME TODO TODO XXX XXX */
  504.                     break;
  505.                 }
  507.                 /* admin function */
  508.                 case MVLC_CLOSE:
  509.                 {
  510.                     char id[512];
  511.                     ExtractURIValue( p_request, "id", id, 512 );
  512.                     msg_Dbg( p_intf, "requested close id=%s", id );
  513. #if 0
  514.                     if( p_sys->p_httpd->pf_control( p_sys->p_httpd, HTTPD_SET_CLOSE, id, NULL ) )
  515.                     {
  516.                         msg_Warn( p_intf, "close failed for id=%s", id );
  517.                     }
  518. #endif
  519.                     break;
  520.                 }
  521.                 case MVLC_SHUTDOWN:
  522.                 {
  523.                     msg_Dbg( p_intf, "requested shutdown" );
  524.                     libvlc_Quit( p_intf->p_libvlc );
  525.                     break;
  526.                 }
  527. #ifdef ENABLE_VLM
  528.                 /* vlm */
  529.                 case MVLC_VLM_NEW:
  530.                 case MVLC_VLM_SETUP:
  531.                 {
  532.                     static const char vlm_properties[][9] =
  533.                     {
  534.                         /* no args */
  535.                         "enabled", "disabled", "loop", "unloop",
  536.                         /* args required */
  537.                         "input", "output", "option", "date", "period",
  538.                         "repeat", "append", "",
  539.                     };
  540.                     vlm_message_t *vlm_answer;
  541.                     char name[512];
  542.                     char *psz = malloc( strlen( p_request ) + 1000 );
  543.                     char *p = psz;
  544.                     char *vlm_error;
  545.                     int i;
  547.                     if( p_intf->p_sys->p_vlm == NULL )
  548.                         p_intf->p_sys->p_vlm = vlm_New( p_intf );
  550.                     if( p_intf->p_sys->p_vlm == NULL )
  551.                     {
  552.                         free( psz );
  553.                         break;
  554.                     }
  556.                     ExtractURIValue( p_request, "name", name, 512 );
  557.                     if( StrToMacroType( control ) == MVLC_VLM_NEW )
  558.                     {
  559.                         char type[20];
  560.                         ExtractURIValue( p_request, "type", type, 20 );
  561.                         p += sprintf( psz, "new %s %s", name, type );
  562.                     }
  563.                     else
  564.                     {
  565.                         p += sprintf( psz, "setup %s", name );
  566.                     }
  567.                     /* Parse the request */
  568.                     for( i = 0; vlm_properties[i][0]; i++ )
  569.                     {
  570.                         char val[512];
  571.                         ExtractURIValue( p_request,
  572.                                                vlm_properties[i], val, 512 );
  573.                         decode_URI( val );
  574.                         if( strlen( val ) > 0 && i >= 4 )
  575.                         {
  576.                             p += sprintf( p, " %s %s", vlm_properties[i], val );
  577.                         }
  578.                         else if( TestURIParam( p_request, vlm_properties[i] ) && i < 4 )
  579.                         {
  580.                             p += sprintf( p, " %s", vlm_properties[i] );
  581.                         }
  582.                     }
  583.                     vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz, &vlm_answer );
  584.                     if( vlm_answer->psz_value == NULL ) /* there is no error */
  585.                     {
  586.                         vlm_error = strdup( "" );
  587.                     }
  588.                     else
  589.                     {
  590.                         if( asprintf( &vlm_error , "%s : %s" ,
  591.                                       vlm_answer->psz_name,
  592.                                       vlm_answer->psz_value ) == -1 )
  593.                             vlm_error = NULL;
  594.                     }
  596.                     mvar_AppendNewVar( p_args->vars, "vlm_error", vlm_error );
  598.                     vlm_MessageDelete( vlm_answer );
  599.                     free( vlm_error );
  600.                     free( psz );
  601.                     break;
  602.                 }
  604.                 case MVLC_VLM_DEL:
  605.                 {
  606.                     vlm_message_t *vlm_answer;
  607.                     char name[512];
  608.                     char psz[512+10];
  609.                     if( p_intf->p_sys->p_vlm == NULL )
  610.                         p_intf->p_sys->p_vlm = vlm_New( p_intf );
  612.                     if( p_intf->p_sys->p_vlm == NULL ) break;
  614.                     ExtractURIValue( p_request, "name", name, 512 );
  615.                     sprintf( psz, "del %s", name );
  617.                     vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz, &vlm_answer );
  618.                     /* FIXME do a vlm_answer -> var stack conversion */
  619.                     vlm_MessageDelete( vlm_answer );
  620.                     break;
  621.                 }
  623.                 case MVLC_VLM_PLAY:
  624.                 case MVLC_VLM_PAUSE:
  625.                 case MVLC_VLM_STOP:
  626.                 case MVLC_VLM_SEEK:
  627.                 {
  628.                     vlm_message_t *vlm_answer;
  629.                     char name[512];
  630.                     char psz[512+10];
  631.                     if( p_intf->p_sys->p_vlm == NULL )
  632.                         p_intf->p_sys->p_vlm = vlm_New( p_intf );
  634.                     if( p_intf->p_sys->p_vlm == NULL ) break;
  636.                     ExtractURIValue( p_request, "name", name, 512 );
  637.                     if( StrToMacroType( control ) == MVLC_VLM_PLAY )
  638.                         sprintf( psz, "control %s play", name );
  639.                     else if( StrToMacroType( control ) == MVLC_VLM_PAUSE )
  640.                         sprintf( psz, "control %s pause", name );
  641.                     else if( StrToMacroType( control ) == MVLC_VLM_STOP )
  642.                         sprintf( psz, "control %s stop", name );
  643.                     else if( StrToMacroType( control ) == MVLC_VLM_SEEK )
  644.                     {
  645.                         char percent[20];
  646.                         ExtractURIValue( p_request, "percent", percent, 512 );
  647.                         sprintf( psz, "control %s seek %s", name, percent );
  648.                     }
  650.                     vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz, &vlm_answer );
  651.                     /* FIXME do a vlm_answer -> var stack conversion */
  652.                     vlm_MessageDelete( vlm_answer );
  653.                     break;
  654.                 }
  655.                 case MVLC_VLM_LOAD:
  656.                 case MVLC_VLM_SAVE:
  657.                 {
  658.                     vlm_message_t *vlm_answer;
  659.                     char file[512];
  660.                     char psz[512];
  662.                     if( p_intf->p_sys->p_vlm == NULL )
  663.                         p_intf->p_sys->p_vlm = vlm_New( p_intf );
  665.                     if( p_intf->p_sys->p_vlm == NULL ) break;
  667.                     ExtractURIValue( p_request, "file", file, 512 );
  668.                     decode_URI( file );
  670.                     if( StrToMacroType( control ) == MVLC_VLM_LOAD )
  671.                         sprintf( psz, "load %s", file );
  672.                     else
  673.                         sprintf( psz, "save %s", file );
  675.                     vlm_ExecuteCommand( p_intf->p_sys->p_vlm, psz, &vlm_answer );
  676.                     /* FIXME do a vlm_answer -> var stack conversion */
  677.                     vlm_MessageDelete( vlm_answer );
  678.                     break;
  679.                 }
  680. #endif /* ENABLE_VLM */
  681.                 default:
  682.                     if( *control )
  683.                     {
  684.                         PRINTS( "<!-- control param(%s) unsupported -->", control );
  685.                     }
  686.                     break;
  687.             }
  688.             break;
  690.         case MVLC_SET:
  691.         {
  692.             char    value[512];
  693.             int     i;
  694.             float   f;
  696.             if( i_request <= 0 ||
  697.                 *m->param1  == '' ||
  698.                 strstr( p_request, m->param1 ) == NULL )
  699.             {
  700.                 break;
  701.             }
  702.             ExtractURIValue( p_request, m->param1,  value, 512 );
  703.             decode_URI( value );
  705.             switch( StrToMacroType( m->param2 ) )
  706.             {
  707.                 case MVLC_INT:
  708.                     i = atoi( value );
  709.                     config_PutInt( p_intf, m->param1, i );
  710.                     break;
  711.                 case MVLC_FLOAT:
  712.                     f = atof( value );
  713.                     config_PutFloat( p_intf, m->param1, f );
  714.                     break;
  715.                 case MVLC_STRING:
  716.                     config_PutPsz( p_intf, m->param1, value );
  717.                     break;
  718.                 default:
  719.                     PRINTS( "<!-- invalid type(%s) in set -->", m->param2 )
  720.             }
  721.             break;
  722.         }
  723.         case MVLC_GET:
  724.         {
  725.             char    value[512];
  726.             int     i;
  727.             float   f;
  728.             char    *psz;
  729.             lldiv_t div;
  731.             if( *m->param1  == '' )
  732.             {
  733.                 break;
  734.             }
  736.             switch( StrToMacroType( m->param2 ) )
  737.             {
  738.                 case MVLC_INT:
  739.                     i = config_GetInt( p_intf, m->param1 );
  740.                     sprintf( value, "%d", i );
  741.                     break;
  742.                 case MVLC_FLOAT:
  743.                     f = config_GetFloat( p_intf, m->param1 );
  744.                     div = lldiv( f * 1000000 , 1000000 );
  745.                     sprintf( value, "%lld.%06u", div.quot,
  746.                             (unsigned int)div.rem );
  747.                     break;
  748.                 case MVLC_STRING:
  749.                     psz = config_GetPsz( p_intf, m->param1 );
  750.                     if( psz != NULL )
  751.                     {
  752.                         strlcpy( value, psz,sizeof( value ) );
  753.                         free( psz );
  754.                     }
  755.                     else
  756.                         *value = '';
  757.                     msg_Dbg( p_intf, "%d: value = "%s"", __LINE__, value );
  758.                     break;
  759.                 default:
  760.                     snprintf( value, sizeof( value ),
  761.                               "invalid type(%s) in set", m->param2 );
  762.                     break;
  763.             }
  764.             PRINTS( "%s", value );
  765.             break;
  766.         }
  767.         case MVLC_VALUE:
  768.         {
  769.             char *s;
  770.             const char *v;
  772.             if( m->param1 )
  773.             {
  774.                 EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m->param1 );
  775.                 s = SSPop( &p_args->stack );
  776.                 v = mvar_GetValue( p_args->vars, s );
  777.             }
  778.             else
  779.             {
  780.                 v = s = SSPop( &p_args->stack );
  781.             }
  783.             PRINTS( "%s", v );
  784.             free( s );
  785.             break;
  786.         }
  787.         case MVLC_RPN:
  788.             EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m->param1 );
  789.             break;
  791.         /* Useful to learn stack management */
  792.         case MVLC_STACK:
  793.         {
  794.             int i;
  795.             msg_Dbg( p_intf, "stack" );
  796.             for (i=0;i<(&p_args->stack)->i_stack;i++)
  797.                 msg_Dbg( p_intf, "%d -> %s", i, (&p_args->stack)->stack[i] );
  798.             break;
  799.         }
  801.         case MVLC_UNKNOWN:
  802.         default:
  803.             PRINTS( "<!-- invalid macro id=`%s' -->", m->id );
  804.             msg_Dbg( p_intf, "invalid macro id=`%s'", m->id );
  805.             break;
  806.     }
  807. #undef PRINTS
  808. #undef PRINT
  809. #undef ALLOC
  810. }
  812. static
  813. char *MacroSearch( char *src, char *end, int i_mvlc, bool b_after )
  814. {
  815.     int     i_id;
  816.     int     i_level = 0;
  818.     while( src < end )
  819.     {
  820.         if( src + 4 < end  && !strncmp( (char *)src, "<vlc", 4 ) )
  821.         {
  822.             int i_skip;
  823.             macro_t m;
  825.             i_skip = MacroParse( &m, src );
  827.             i_id = StrToMacroType( m.id );
  829.             switch( i_id )
  830.             {
  831.                 case MVLC_IF:
  832.                 case MVLC_FOREACH:
  833.                     i_level++;
  834.                     break;
  835.                 case MVLC_END:
  836.                     i_level--;
  837.                     break;
  838.                 default:
  839.                     break;
  840.             }
  842.             MacroClean( &m );
  844.             if( ( i_mvlc == MVLC_END && i_level == -1 ) ||
  845.                 ( i_mvlc != MVLC_END && i_level == 0 && i_mvlc == i_id ) )
  846.             {
  847.                 return src + ( b_after ? i_skip : 0 );
  848.             }
  849.             else if( i_level < 0 )
  850.             {
  851.                 return NULL;
  852.             }
  854.             src += i_skip;
  855.         }
  856.         else
  857.         {
  858.             src++;
  859.         }
  860.     }
  862.     return NULL;
  863. }
  865. void Execute( httpd_file_sys_t *p_args,
  866.                      char *p_request, int i_request,
  867.                      char **pp_data, int *pi_data,
  868.                      char **pp_dst,
  869.                      char *_src, char *_end )
  870. {
  871.     intf_thread_t  *p_intf = p_args->p_intf;
  873.     char *src, *dup, *end;
  874.     char *dst = *pp_dst;
  876.     src = dup = malloc( _end - _src + 1 );
  877.     end = src +( _end - _src );
  879.     memcpy( src, _src, _end - _src );
  880.     *end = '';
  882.     /* we parse searching <vlc */
  883.     while( src < end )
  884.     {
  885.         char *p;
  886.         int i_copy;
  888.         p = (char *)strstr( (char *)src, "<vlc" );
  889.         if( p < end && p == src )
  890.         {
  891.             macro_t m;
  893.             src += MacroParse( &m, src );
  895.             //msg_Dbg( p_intf, "macro_id=%s", m.id );
  897.             switch( StrToMacroType( m.id ) )
  898.             {
  899.                 case MVLC_INCLUDE:
  900.                 {
  901.                     FILE *f;
  902.                     int  i_buffer;
  903.                     char *p_buffer;
  904.                     char psz_file[MAX_DIR_SIZE];
  905.                     char *p;
  906.                     char sep;
  908. #if defined( WIN32 )
  909.                     sep = '\';
  910. #else
  911.                     sep = '/';
  912. #endif
  914.                     if( m.param1[0] != sep )
  915.                     {
  916.                         strcpy( psz_file, p_args->file );
  917.                         p = strrchr( psz_file, sep );
  918.                         if( p != NULL )
  919.                             strcpy( p + 1, m.param1 );
  920.                         else
  921.                             strcpy( psz_file, m.param1 );
  922.                     }
  923.                     else
  924.                     {
  925.                         strcpy( psz_file, m.param1 );
  926.                     }
  928.                     /* We hereby assume that psz_file is in the
  929.                      * local character encoding */
  930.                     if( ( f = fopen( psz_file, "r" ) ) == NULL )
  931.                     {
  932.                         msg_Warn( p_args->p_intf,
  933.                                   "unable to include file %s (%m)",
  934.                                   psz_file );
  935.                         break;
  936.                     }
  938.                     /* first we load in a temporary buffer */
  939.                     FileLoad( f, &p_buffer, &i_buffer );
  941.                     /* we parse executing all  <vlc /> macros */
  942.                     Execute( p_args, p_request, i_request, pp_data, pi_data,
  943.                              &dst, &p_buffer[0], &p_buffer[i_buffer] );
  944.                     free( p_buffer );
  945.                     fclose(f);
  946.                     break;
  947.                 }
  948.                 case MVLC_IF:
  949.                 {
  950.                     bool i_test;
  951.                     char    *endif;
  953.                     EvaluateRPN( p_intf, p_args->vars, &p_args->stack, m.param1 );
  954.                     if( SSPopN( &p_args->stack, p_args->vars ) )
  955.                     {
  956.                         i_test = 1;
  957.                     }
  958.                     else
  959.                     {
  960.                         i_test = 0;
  961.                     }
  962.                     endif = MacroSearch( src, end, MVLC_END, true );
  964.                     if( i_test == 0 )
  965.                     {
  966.                         char *start = MacroSearch( src, endif, MVLC_ELSE, true );
  968.                         if( start )
  969.                         {
  970.                             char *stop  = MacroSearch( start, endif, MVLC_END, false );
  971.                             if( stop )
  972.                             {
  973.                                 Execute( p_args, p_request, i_request,
  974.                                          pp_data, pi_data, &dst, start, stop );
  975.                             }
  976.                         }
  977.                     }
  978.                     else if( i_test == 1 )
  979.                     {
  980.                         char *stop;
  981.                         if( ( stop = MacroSearch( src, endif, MVLC_ELSE, false ) ) == NULL )
  982.                         {
  983.                             stop = MacroSearch( src, endif, MVLC_END, false );
  984.                         }
  985.                         if( stop )
  986.                         {
  987.                             Execute( p_args, p_request, i_request,
  988.                                      pp_data, pi_data, &dst, src, stop );
  989.                         }
  990.                     }
  992.                     src = endif;
  993.                     break;
  994.                 }
  995.                 case MVLC_FOREACH:
  996.                 {
  997.                     char *endfor = MacroSearch( src, end, MVLC_END, true );
  998.                     char *start = src;
  999.                     char *stop = MacroSearch( src, end, MVLC_END, false );
  1001.                     if( stop )
  1002.                     {
  1003.                         mvar_t *index;
  1004.                         int    i_idx;
  1005.                         mvar_t *v;
  1006.                         if( !strcmp( m.param2, "integer" ) )
  1007.                         {
  1008.                             char *arg = SSPop( &p_args->stack );
  1009.                             index = mvar_IntegerSetNew( m.param1, arg );
  1010.                             free( arg );
  1011.                         }
  1012.                         else if( !strcmp( m.param2, "directory" ) )
  1013.                         {
  1014.                             char *arg = SSPop( &p_args->stack );
  1015.                             index = mvar_FileSetNew( p_intf, m.param1, arg );
  1016.                             free( arg );
  1017.                         }
  1018.                         else if( !strcmp( m.param2, "object" ) )
  1019.                         {
  1020.                             char *arg = SSPop( &p_args->stack );
  1021.                             index = mvar_ObjectSetNew( p_intf, m.param1, arg );
  1022.                             free( arg );
  1023.                         }
  1024.                         else if( !strcmp( m.param2, "playlist" ) )
  1025.                         {
  1026.                             index = mvar_PlaylistSetNew( p_intf, m.param1,
  1027.                                                     p_intf->p_sys->p_playlist );
  1028.                         }
  1029.                         else if( !strcmp( m.param2, "information" ) )
  1030.                         {
  1031.                             index = mvar_InfoSetNew( m.param1,
  1032.                                                      p_intf->p_sys->p_input );
  1033.                         }
  1034.                         else if( !strcmp( m.param2, "program" )
  1035.                                   || !strcmp( m.param2, "title" )
  1036.                                   || !strcmp( m.param2, "chapter" )
  1037.                                   || !strcmp( m.param2, "audio-es" )
  1038.                                   || !strcmp( m.param2, "video-es" )
  1039.                                   || !strcmp( m.param2, "spu-es" ) )
  1040.                         {
  1041.                             index = mvar_InputVarSetNew( p_intf, m.param1,
  1042.                                                          p_intf->p_sys->p_input,
  1043.                                                          m.param2 );
  1044.                         }
  1045. #ifdef ENABLE_VLM
  1046.                         else if( !strcmp( m.param2, "vlm" ) )
  1047.                         {
  1048.                             if( p_intf->p_sys->p_vlm == NULL )
  1049.                                 p_intf->p_sys->p_vlm = vlm_New( p_intf );
  1050.                             index = mvar_VlmSetNew( m.param1, p_intf->p_sys->p_vlm );
  1051.                         }
  1052. #endif
  1053. #if 0
  1054.                         else if( !strcmp( m.param2, "hosts" ) )
  1055.                         {
  1056.                             index = mvar_HttpdInfoSetNew( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_HOSTS );
  1057.                         }
  1058.                         else if( !strcmp( m.param2, "urls" ) )
  1059.                         {
  1060.                             index = mvar_HttpdInfoSetNew( m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_URLS );
  1061.                         }
  1062.                         else if( !strcmp( m.param2, "connections" ) )
  1063.                         {
  1064.                             index = mvar_HttpdInfoSetNew(m.param1, p_intf->p_sys->p_httpd, HTTPD_GET_CONNECTIONS);
  1065.                         }
  1066. #endif
  1067.                         else if( ( v = mvar_GetVar( p_args->vars, m.param2 ) ) )
  1068.                         {
  1069.                             index = mvar_Duplicate( v );
  1070.                         }
  1071.                         else
  1072.                         {
  1073.                             msg_Dbg( p_intf, "invalid index constructor (%s)", m.param2 );
  1074.                             src = endfor;
  1075.                             break;
  1076.                         }
  1078.                         for( i_idx = 0; i_idx < index->i_field; i_idx++ )
  1079.                         {
  1080.                             mvar_t *f = mvar_Duplicate( index->field[i_idx] );
  1082.                             //msg_Dbg( p_intf, "foreach field[%d] name=%s value=%s", i_idx, f->name, f->value );
  1084.                             free( f->name );
  1085.                             f->name = strdup( m.param1 );
  1088.                             mvar_PushVar( p_args->vars, f );
  1089.                             Execute( p_args, p_request, i_request,
  1090.                                      pp_data, pi_data, &dst, start, stop );
  1091.                             mvar_RemoveVar( p_args->vars, f );
  1093.                             mvar_Delete( f );
  1094.                         }
  1095.                         mvar_Delete( index );
  1097.                         src = endfor;
  1098.                     }
  1099.                     break;
  1100.                 }
  1101.                 default:
  1102.                     MacroDo( p_args, &m, p_request, i_request,
  1103.                              pp_data, pi_data, &dst );
  1104.                     break;
  1105.             }
  1107.             MacroClean( &m );
  1108.             continue;
  1109.         }
  1111.         i_copy =   ( (p == NULL || p > end ) ? end : p  ) - src;
  1112.         if( i_copy > 0 )
  1113.         {
  1114.             int i_index = dst - *pp_data;
  1116.             *pi_data += i_copy;
  1117.             *pp_data = realloc( *pp_data, *pi_data );
  1118.             dst = (*pp_data) + i_index;
  1120.             memcpy( dst, src, i_copy );
  1121.             dst += i_copy;
  1122.             src += i_copy;
  1123.         }
  1124.     }
  1126.     *pp_dst = dst;
  1127.     free( dup );
  1128. }