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

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

midi

开发平台：

Unix_Linux

util.c：源码内容
  1. /*****************************************************************************
  2.  * util.c : Utility functions for HTTP interface
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2005 the VideoLAN team
  5.  * $Id: aee0199cfec637c129fb21e699d8f71cc59533a4 $
  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.  *****************************************************************************/
  26. #ifdef HAVE_CONFIG_H
  27. # include "config.h"
  28. #endif
  30. #include <vlc_common.h>
  31. #include "http.h"
  32. #include "vlc_strings.h"
  34. /****************************************************************************
  35.  * File and directory functions
  36.  ****************************************************************************/
  38. /* ToUrl: create a good name for an url from filename */
  39. char *FileToUrl( char *name, bool *pb_index )
  40. {
  41.     char *url, *p;
  43.     url = p = malloc( strlen( name ) + 1 );
  45.     *pb_index = false;
  46.     if( !url || !p )
  47.     {
  48.         return NULL;
  49.     }
  51. #ifdef WIN32
  52.     while( *name == '\' || *name == '/' )
  53. #else
  54.     while( *name == '/' )
  55. #endif
  56.     {
  57.         name++;
  58.     }
  60.     *p++ = '/';
  61.     strcpy( p, name );
  63. #ifdef WIN32
  64.     /* convert '\' into '/' */
  65.     name = p;
  66.     while( *name )
  67.     {
  68.         if( *name == '\' )
  69.             *name = '/';
  70.         name++;
  71.     }
  72. #endif
  74.     /* index.* -> / */
  75.     if( ( p = strrchr( url, '/' ) ) != NULL )
  76.     {
  77.         if( !strncmp( p, "/index.", 7 ) )
  78.         {
  79.             p[1] = '';
  80.             *pb_index = true;
  81.         }
  82.     }
  83.     return url;
  84. }
  86. /* Load a file */
  87. int FileLoad( FILE *f, char **pp_data, int *pi_data )
  88. {
  89.     int i_read;
  91.     /* just load the file */
  92.     *pi_data = 0;
  93.     *pp_data = malloc( 1025 );  /* +1 for  */
  94.     while( ( i_read = fread( &(*pp_data)[*pi_data], 1, 1024, f ) ) == 1024 )
  95.     {
  96.         *pi_data += 1024;
  97.         *pp_data = realloc( *pp_data, *pi_data  + 1025 );
  98.     }
  99.     if( i_read > 0 )
  100.     {
  101.         *pi_data += i_read;
  102.     }
  103.     (*pp_data)[*pi_data] = '';
  105.     return VLC_SUCCESS;
  106. }
  108. /* Parse a directory and recursively add files */
  109. int ParseDirectory( intf_thread_t *p_intf, char *psz_root,
  110.                         char *psz_dir )
  111. {
  112.     intf_sys_t     *p_sys = p_intf->p_sys;
  113.     char           dir[MAX_DIR_SIZE];
  114.     DIR           *p_dir;
  115.     vlc_acl_t     *p_acl;
  116.     FILE          *file;
  118.     char          *user = NULL;
  119.     char          *password = NULL;
  121.     int           i_dirlen;
  123.     if( ( p_dir = utf8_opendir( psz_dir ) ) == NULL )
  124.     {
  125.         if( errno != ENOENT && errno != ENOTDIR )
  126.             msg_Err( p_intf, "cannot open directory (%s)", psz_dir );
  127.         return VLC_EGENERIC;
  128.     }
  130.     i_dirlen = strlen( psz_dir );
  131.     if( i_dirlen + 10 > MAX_DIR_SIZE )
  132.     {
  133.         msg_Warn( p_intf, "skipping too deep directory (%s)", psz_dir );
  134.         closedir( p_dir );
  135.         return 0;
  136.     }
  138.     msg_Dbg( p_intf, "dir=%s", psz_dir );
  140.     snprintf( dir, sizeof( dir ), "%s"DIR_SEP".access", psz_dir );
  141.     if( ( file = utf8_fopen( dir, "r" ) ) != NULL )
  142.     {
  143.         char line[1024];
  144.         int  i_size;
  146.         msg_Dbg( p_intf, "find .access in dir=%s", psz_dir );
  148.         i_size = fread( line, 1, 1023, file );
  149.         if( i_size > 0 )
  150.         {
  151.             char *p;
  152.             while( i_size > 0 && ( line[i_size-1] == 'n' ||
  153.                    line[i_size-1] == 'r' ) )
  154.             {
  155.                 i_size--;
  156.             }
  158.             line[i_size] = '';
  160.             p = strchr( line, ':' );
  161.             if( p )
  162.             {
  163.                 *p++ = '';
  164.                 user = strdup( line );
  165.                 password = strdup( p );
  166.             }
  167.         }
  168.         msg_Dbg( p_intf, "using user=%s (read=%d)", user, i_size );
  170.         fclose( file );
  171.     }
  173.     snprintf( dir, sizeof( dir ), "%s"DIR_SEP".hosts", psz_dir );
  174.     p_acl = ACL_Create( p_intf, false );
  175.     if( ACL_LoadFile( p_acl, dir ) )
  176.     {
  177.         ACL_Destroy( p_acl );
  179.         struct stat st;
  180.         if( stat( dir, &st ) == 0 )
  181.         {
  182.             free( user );
  183.             free( password );
  184.             closedir( p_dir );
  185.             return VLC_EGENERIC;
  186.         }
  187.         p_acl = NULL;
  188.     }
  190.     for( ;; )
  191.     {
  192.         char *psz_filename;
  193.         /* parse psz_src dir */
  194.         if( ( psz_filename = utf8_readdir( p_dir ) ) == NULL )
  195.         {
  196.             break;
  197.         }
  199.         if( ( psz_filename[0] == '.' )
  200.          || ( i_dirlen + strlen( psz_filename ) > MAX_DIR_SIZE ) )
  201.         {
  202.             free( psz_filename );
  203.             continue;
  204.         }
  206.         snprintf( dir, sizeof( dir ), "%s"DIR_SEP"%s", psz_dir, psz_filename );
  207.         free( psz_filename );
  209.         if( ParseDirectory( p_intf, psz_root, dir ) )
  210.         {
  211.             httpd_file_sys_t *f = NULL;
  212.             httpd_handler_sys_t *h = NULL;
  213.             bool b_index;
  214.             char *psz_name, *psz_ext;
  216.             psz_name = FileToUrl( &dir[strlen( psz_root )], &b_index );
  217.             psz_ext = strrchr( dir, '.' );
  218.             if( psz_ext != NULL )
  219.             {
  220.                 int i;
  221.                 psz_ext++;
  222.                 for( i = 0; i < p_sys->i_handlers; i++ )
  223.                     if( !strcmp( p_sys->pp_handlers[i]->psz_ext, psz_ext ) )
  224.                         break;
  225.                 if( i < p_sys->i_handlers )
  226.                 {
  227.                     f = malloc( sizeof( httpd_handler_sys_t ) );
  228.                     h = (httpd_handler_sys_t *)f;
  229.                     f->b_handler = true;
  230.                     h->p_association = p_sys->pp_handlers[i];
  231.                 }
  232.             }
  233.             if( f == NULL )
  234.             {
  235.                 f = malloc( sizeof( httpd_file_sys_t ) );
  236.                 f->b_handler = false;
  237.             }
  239.             f->p_intf  = p_intf;
  240.             f->p_file = NULL;
  241.             f->p_redir = NULL;
  242.             f->p_redir2 = NULL;
  243.             f->file = strdup (dir);
  244.             f->name = psz_name;
  245.             f->b_html = strstr( &dir[strlen( psz_root )], ".htm" ) || strstr( &dir[strlen( psz_root )], ".xml" ) ? true : false;
  247.             if( !f->name )
  248.             {
  249.                 msg_Err( p_intf , "unable to parse directory" );
  250.                 closedir( p_dir );
  251.                 free( f );
  252.                 return( VLC_ENOMEM );
  253.             }
  254.             msg_Dbg( p_intf, "file=%s (url=%s)",
  255.                      f->file, f->name );
  257.             if( !f->b_handler )
  258.             {
  259.                 char *psz_type = strdup( "text/html; charset=UTF-8" );
  260.                 if( strstr( &dir[strlen( psz_root )], ".xml" ) )
  261.                 {
  262.                     char *psz = strstr( psz_type, "html;" );
  263.                     if( psz )
  264.                     {
  265.                         psz[0] = 'x';
  266.                         psz[1] = 'm';
  267.                         psz[2] = 'l';
  268.                         psz[3] = ';';
  269.                         psz[4] = ' ';
  270.                     }
  271.                 }
  272.                 f->p_file = httpd_FileNew( p_sys->p_httpd_host,
  273.                                            f->name,
  274.                                            f->b_html ? psz_type : NULL,
  275.                                            user, password, p_acl,
  276.                                            HttpCallback, f );
  277.                 free( psz_type );
  278.                 if( f->p_file != NULL )
  279.                 {
  280.                     TAB_APPEND( p_sys->i_files, p_sys->pp_files, f );
  281.                 }
  282.             }
  283.             else
  284.             {
  285.                 h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
  286.                                                  f->name,
  287.                                                  user, password, p_acl,
  288.                                                  HandlerCallback, h );
  289.                 if( h->p_handler != NULL )
  290.                 {
  291.                     TAB_APPEND( p_sys->i_files, p_sys->pp_files,
  292.                                 (httpd_file_sys_t *)h );
  293.                 }
  294.             }
  296.             /* for url that ends by / add
  297.              *  - a redirect from rep to rep/
  298.              *  - in case of index.* rep/index.html to rep/ */
  299.             if( f && f->name[strlen(f->name) - 1] == '/' )
  300.             {
  301.                 char *psz_redir = strdup( f->name );
  302.                 char *p;
  303.                 psz_redir[strlen( psz_redir ) - 1] = '';
  305.                 msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
  306.                 f->p_redir = httpd_RedirectNew( p_sys->p_httpd_host, f->name, psz_redir );
  307.                 free( psz_redir );
  309.                 if( b_index && ( p = strstr( f->file, "index." ) ) )
  310.                 {
  311.                     if( asprintf( &psz_redir, "%s%s", f->name, p ) != -1 )
  312.                     {
  313.                         msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
  314.                         f->p_redir2 = httpd_RedirectNew( p_sys->p_httpd_host,
  315.                                                          f->name, psz_redir );
  317.                         free( psz_redir );
  318.                     }
  319.                 }
  320.             }
  321.         }
  322.     }
  324.     free( user );
  325.     free( password );
  327.     ACL_Destroy( p_acl );
  328.     closedir( p_dir );
  330.     return VLC_SUCCESS;
  331. }
  334. /*************************************************************************
  335.  * Playlist stuff
  336.  *************************************************************************/
  337. void PlaylistListNode( intf_thread_t *p_intf, playlist_t *p_pl,
  338.                            playlist_item_t *p_node, char *name, mvar_t *s,
  339.                            int i_depth )
  340. {
  341.     if( !p_node || !p_node->p_input )
  342.         return;
  344.     if( p_node->i_children == -1 )
  345.     {
  346.         char value[512];
  347.         char *psz;
  348.         playlist_item_t * p_item = playlist_CurrentPlayingItem( p_pl );
  349.         if( !p_item || !p_item->p_input )
  350.             return;
  352.         mvar_t *itm = mvar_New( name, "set" );
  353.         if( p_item->p_input->i_id == p_node->p_input->i_id )
  354.             mvar_AppendNewVar( itm, "current", "1" );
  355.         else
  356.             mvar_AppendNewVar( itm, "current", "0" );
  358.         sprintf( value, "%d", p_node->i_id );
  359.         mvar_AppendNewVar( itm, "index", value );
  361.         psz = input_item_GetName( p_node->p_input );
  362.         mvar_AppendNewVar( itm, "name", psz );
  363.         free( psz );
  365.         psz = input_item_GetURI( p_node->p_input );
  366.         mvar_AppendNewVar( itm, "uri", psz );
  367.         free( psz );
  369.         sprintf( value, "Item");
  370.         mvar_AppendNewVar( itm, "type", value );
  372.         sprintf( value, "%d", i_depth );
  373.         mvar_AppendNewVar( itm, "depth", value );
  375.         if( p_node->i_flags & PLAYLIST_RO_FLAG )
  376.             mvar_AppendNewVar( itm, "ro", "ro" );
  377.         else
  378.             mvar_AppendNewVar( itm, "ro", "rw" );
  380.         sprintf( value, "%"PRId64, input_item_GetDuration( p_node->p_input ) );
  381.         mvar_AppendNewVar( itm, "duration", value );
  383.         //Adding extra meta-information to each playlist item
  385.         psz = input_item_GetTitle( p_node->p_input );
  386.         mvar_AppendNewVar( itm, "title", psz );
  387.         free( psz );
  389.         psz = input_item_GetArtist( p_node->p_input );
  390.         mvar_AppendNewVar( itm, "artist", psz );
  391.         free( psz );
  393.         psz = input_item_GetGenre( p_node->p_input );
  394.         mvar_AppendNewVar( itm, "genre", psz );
  395.         free( psz );
  397.         psz = input_item_GetCopyright( p_node->p_input );
  398.         mvar_AppendNewVar( itm, "copyright", psz );
  399.         free( psz );
  401.         psz = input_item_GetAlbum( p_node->p_input );
  402.         mvar_AppendNewVar( itm, "album", psz );
  403.         free( psz );
  405.         psz = input_item_GetTrackNum( p_node->p_input );
  406.         mvar_AppendNewVar( itm, "track", psz );
  407.         free( psz );
  409.         psz = input_item_GetDescription( p_node->p_input );
  410.         mvar_AppendNewVar( itm, "description", psz );
  411.         free( psz );
  413.         psz = input_item_GetRating( p_node->p_input );
  414.         mvar_AppendNewVar( itm, "rating", psz );
  415.         free( psz );
  417.         psz = input_item_GetDate( p_node->p_input );
  418.         mvar_AppendNewVar( itm, "date", psz );
  419.         free( psz );
  421.         psz = input_item_GetURL( p_node->p_input );
  422.         mvar_AppendNewVar( itm, "url", psz );
  423.         free( psz );
  425.         psz = input_item_GetLanguage( p_node->p_input );
  426.         mvar_AppendNewVar( itm, "language", psz );
  427.         free( psz );
  429.         psz = input_item_GetNowPlaying( p_node->p_input );
  430.         mvar_AppendNewVar( itm, "now_playing", psz );
  431.         free( psz );
  433.         psz = input_item_GetPublisher( p_node->p_input );
  434.         mvar_AppendNewVar( itm, "publisher", psz );
  435.         free( psz );
  437.         psz = input_item_GetEncodedBy( p_node->p_input );
  438.         mvar_AppendNewVar( itm, "encoded_by", psz );
  439.         free( psz );
  441.         psz = input_item_GetArtURL( p_node->p_input );
  442.         mvar_AppendNewVar( itm, "art_url", psz );
  443.         free( psz );
  445.         psz = input_item_GetTrackID( p_node->p_input );
  446.         mvar_AppendNewVar( itm, "track_id", psz );
  447.         free( psz );
  449.         mvar_AppendVar( s, itm );
  450.     }
  451.     else
  452.     {
  453.         char value[512];
  454.         int i_child;
  455.         mvar_t *itm = mvar_New( name, "set" );
  457.         mvar_AppendNewVar( itm, "name", p_node->p_input->psz_name );
  458.         mvar_AppendNewVar( itm, "uri", p_node->p_input->psz_name );
  460.         sprintf( value, "Node" );
  461.         mvar_AppendNewVar( itm, "type", value );
  463.         sprintf( value, "%d", p_node->i_id );
  464.         mvar_AppendNewVar( itm, "index", value );
  466.         sprintf( value, "%d", p_node->i_children);
  467.         mvar_AppendNewVar( itm, "i_children", value );
  469.         sprintf( value, "%d", i_depth );
  470.         mvar_AppendNewVar( itm, "depth", value );
  472.         if( p_node->i_flags & PLAYLIST_RO_FLAG )
  473.             mvar_AppendNewVar( itm, "ro", "ro" );
  474.         else
  475.             mvar_AppendNewVar( itm, "ro", "rw" );
  477.         mvar_AppendVar( s, itm );
  479.         for( i_child = 0 ; i_child < p_node->i_children ; i_child++ )
  480.              PlaylistListNode( p_intf, p_pl, p_node->pp_children[i_child],
  481.                                name, s, i_depth + 1);
  482.     }
  483. }
  485. /****************************************************************************
  486.  * Seek command parsing handling
  487.  ****************************************************************************/
  488. void HandleSeek( intf_thread_t *p_intf, char *p_value )
  489. {
  490.     intf_sys_t     *p_sys = p_intf->p_sys;
  491.     vlc_value_t val;
  492.     int i_stock = 0;
  493.     uint64_t i_length;
  494.     int i_value = 0;
  495.     int i_relative = 0;
  496. #define POSITION_ABSOLUTE 12
  497. #define POSITION_REL_FOR 13
  498. #define POSITION_REL_BACK 11
  499. #define VL_TIME_ABSOLUTE 0
  500. #define VL_TIME_REL_FOR 1
  501. #define VL_TIME_REL_BACK -1
  502.     if( p_sys->p_input )
  503.     {
  504.         var_Get( p_sys->p_input, "length", &val );
  505.         i_length = val.i_time;
  507.         while( p_value[0] != '' )
  508.         {
  509.             switch(p_value[0])
  510.             {
  511.                 case '+':
  512.                 {
  513.                     i_relative = VL_TIME_REL_FOR;
  514.                     p_value++;
  515.                     break;
  516.                 }
  517.                 case '-':
  518.                 {
  519.                     i_relative = VL_TIME_REL_BACK;
  520.                     p_value++;
  521.                     break;
  522.                 }
  523.                 case '0': case '1': case '2': case '3': case '4':
  524.                 case '5': case '6': case '7': case '8': case '9':
  525.                 {
  526.                     i_stock = strtol( p_value , &p_value , 10 );
  527.                     break;
  528.                 }
  529.                 case '%': /* for percentage ie position */
  530.                 {
  531.                     i_relative += POSITION_ABSOLUTE;
  532.                     i_value = i_stock;
  533.                     i_stock = 0;
  534.                     p_value[0] = '';
  535.                     break;
  536.                 }
  537.                 case ':':
  538.                 {
  539.                     i_value = 60 * (i_value + i_stock) ;
  540.                     i_stock = 0;
  541.                     p_value++;
  542.                     break;
  543.                 }
  544.                 case 'h': case 'H': /* hours */
  545.                 {
  546.                     i_value += 3600 * i_stock;
  547.                     i_stock = 0;
  548.                     /* other characters which are not numbers are not
  549.                      * important */
  550.                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
  551.                            && (p_value[0] != '') )
  552.                     {
  553.                         p_value++;
  554.                     }
  555.                     break;
  556.                 }
  557.                 case 'm': case 'M': case ''': /* minutes */
  558.                 {
  559.                     i_value += 60 * i_stock;
  560.                     i_stock = 0;
  561.                     p_value++;
  562.                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
  563.                            && (p_value[0] != '') )
  564.                     {
  565.                         p_value++;
  566.                     }
  567.                     break;
  568.                 }
  569.                 case 's': case 'S': case '"':  /* seconds */
  570.                 {
  571.                     i_value += i_stock;
  572.                     i_stock = 0;
  573.                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
  574.                            && (p_value[0] != '') )
  575.                     {
  576.                         p_value++;
  577.                     }
  578.                     break;
  579.                 }
  580.                 default:
  581.                 {
  582.                     p_value++;
  583.                     break;
  584.                 }
  585.             }
  586.         }
  588.         /* if there is no known symbol, I consider it as seconds.
  589.          * Otherwise, i_stock = 0 */
  590.         i_value += i_stock;
  592.         switch(i_relative)
  593.         {
  594.             case VL_TIME_ABSOLUTE:
  595.             {
  596.                 if( (uint64_t)( i_value ) * 1000000 <= i_length )
  597.                     val.i_time = (uint64_t)( i_value ) * 1000000;
  598.                 else
  599.                     val.i_time = i_length;
  601.                 var_Set( p_sys->p_input, "time", val );
  602.                 msg_Dbg( p_intf, "requested seek position: %dsec", i_value );
  603.                 break;
  604.             }
  605.             case VL_TIME_REL_FOR:
  606.             {
  607.                 var_Get( p_sys->p_input, "time", &val );
  608.                 if( (uint64_t)( i_value ) * 1000000 + val.i_time <= i_length )
  609.                 {
  610.                     val.i_time = ((uint64_t)( i_value ) * 1000000) + val.i_time;
  611.                 } else
  612.                 {
  613.                     val.i_time = i_length;
  614.                 }
  615.                 var_Set( p_sys->p_input, "time", val );
  616.                 msg_Dbg( p_intf, "requested seek position forward: %dsec", i_value );
  617.                 break;
  618.             }
  619.             case VL_TIME_REL_BACK:
  620.             {
  621.                 var_Get( p_sys->p_input, "time", &val );
  622.                 if( (int64_t)( i_value ) * 1000000 > val.i_time )
  623.                 {
  624.                     val.i_time = 0;
  625.                 } else
  626.                 {
  627.                     val.i_time = val.i_time - ((uint64_t)( i_value ) * 1000000);
  628.                 }
  629.                 var_Set( p_sys->p_input, "time", val );
  630.                 msg_Dbg( p_intf, "requested seek position backward: %dsec", i_value );
  631.                 break;
  632.             }
  633.             case POSITION_ABSOLUTE:
  634.             {
  635.                 val.f_float = __MIN( __MAX( ((float) i_value ) / 100.0 ,
  636.                                             0.0 ), 100.0 );
  637.                 var_Set( p_sys->p_input, "position", val );
  638.                 msg_Dbg( p_intf, "requested seek percent: %d%%", i_value );
  639.                 break;
  640.             }
  641.             case POSITION_REL_FOR:
  642.             {
  643.                 var_Get( p_sys->p_input, "position", &val );
  644.                 val.f_float += __MIN( __MAX( ((float) i_value ) / 100.0,
  645.                                              0.0 ) , 100.0 );
  646.                 var_Set( p_sys->p_input, "position", val );
  647.                 msg_Dbg( p_intf, "requested seek percent forward: %d%%",
  648.                          i_value );
  649.                 break;
  650.             }
  651.             case POSITION_REL_BACK:
  652.             {
  653.                 var_Get( p_sys->p_input, "position", &val );
  654.                 val.f_float -= __MIN( __MAX( ((float) i_value ) / 100.0,
  655.                                              0.0 ) , 100.0 );
  656.                 var_Set( p_sys->p_input, "position", val );
  657.                 msg_Dbg( p_intf, "requested seek percent backward: %d%%",
  658.                          i_value );
  659.                 break;
  660.             }
  661.             default:
  662.             {
  663.                 msg_Dbg( p_intf, "invalid seek request" );
  664.                 break;
  665.             }
  666.         }
  667.     }
  668. #undef POSITION_ABSOLUTE
  669. #undef POSITION_REL_FOR
  670. #undef POSITION_REL_BACK
  671. #undef VL_TIME_ABSOLUTE
  672. #undef VL_TIME_REL_FOR
  673. #undef VL_TIME_REL_BACK
  674. }
  677. /****************************************************************************
  678.  * URI Parsing functions
  679.  ****************************************************************************/
  680. int TestURIParam( char *psz_uri, const char *psz_name )
  681. {
  682.     char *p = psz_uri;
  684.     while( (p = strstr( p, psz_name )) )
  685.     {
  686.         /* Verify that we are dealing with a post/get argument */
  687.         if( (p == psz_uri || *(p - 1) == '&' || *(p - 1) == 'n')
  688.               && p[strlen(psz_name)] == '=' )
  689.         {
  690.             return true;
  691.         }
  692.         p++;
  693.     }
  695.     return false;
  696. }
  698. static const char *FindURIValue( const char *psz_uri, const char *restrict psz_name,
  699.                            size_t *restrict p_len )
  700. {
  701.     const char *p = psz_uri, *end;
  702.     size_t len;
  704.     while( (p = strstr( p, psz_name )) )
  705.     {
  706.         /* Verify that we are dealing with a post/get argument */
  707.         if( (p == psz_uri || *(p - 1) == '&' || *(p - 1) == 'n')
  708.               && p[strlen(psz_name)] == '=' )
  709.             break;
  710.         p++;
  711.     }
  713.     if( p == NULL )
  714.     {
  715.         *p_len = 0;
  716.         return NULL;
  717.     }
  719.     p += strlen( psz_name );
  720.     if( *p == '=' ) p++;
  722.     if( ( end = strchr( p, 'n' ) ) != NULL )
  723.     {
  724.         /* POST method */
  725.         if( ( end > p ) && ( end[-1] == 'r' ) )
  726.             end--;
  728.         len = end - p;
  729.     }
  730.     else
  731.     {
  732.         /* GET method */
  733.         if( ( end = strchr( p, '&' ) ) != NULL )
  734.             len = end - p;
  735.         else
  736.             len = strlen( p );
  737.     }
  739.     *p_len = len;
  740.     return p;
  741. }
  743. const char *ExtractURIValue( const char *restrict psz_uri,
  744.                            const char *restrict psz_name,
  745.                            char *restrict psz_buf, size_t bufsize )
  746. {
  747.     size_t len;
  748.     const char *psz_value = FindURIValue( psz_uri, psz_name, &len );
  749.     const char *psz_next;
  751.     if( psz_value == NULL )
  752.     {
  753.         if( bufsize > 0 )
  754.             *psz_buf = '';
  755.         return NULL;
  756.     }
  758.     psz_next = psz_value + len;
  760.     if( len >= bufsize )
  761.         len = bufsize - 1;
  763.     if( len > 0 )
  764.         strncpy( psz_buf, psz_value, len );
  765.     if( bufsize > 0 )
  766.         psz_buf[len] = '';
  768.     return psz_next;
  769. }
  771. char *ExtractURIString( const char *restrict psz_uri,
  772.                             const char *restrict psz_name )
  773. {
  774.     size_t len;
  775.     const char *psz_value = FindURIValue( psz_uri, psz_name, &len );
  777.     if( psz_value == NULL )
  778.         return NULL;
  780.     char *res = malloc( len + 1 );
  781.     if( res == NULL )
  782.         return NULL;
  784.     memcpy( res, psz_value, len );
  785.     res[len] = '';
  787.     return res;
  788. }
  790. /* Since the resulting string is smaller we can work in place, so it is
  791.  * permitted to have psz == new. new points to the first word of the
  792.  * string, the function returns the remaining string. */
  793. char *FirstWord( char *psz, char *new )
  794. {
  795.     bool b_end;
  797.     while( *psz == ' ' )
  798.         psz++;
  800.     while( *psz != '' && *psz != ' ' )
  801.     {
  802.         if( *psz == ''' )
  803.         {
  804.             char c = *psz++;
  805.             while( *psz != '' && *psz != c )
  806.             {
  807.                 if( *psz == '\' && psz[1] != '' )
  808.                     psz++;
  809.                 *new++ = *psz++;
  810.             }
  811.             if( *psz == c )
  812.                 psz++;
  813.         }
  814.         else
  815.         {
  816.             if( *psz == '\' && psz[1] != '' )
  817.                 psz++;
  818.             *new++ = *psz++;
  819.         }
  820.     }
  821.     b_end = !*psz;
  823.     *new++ = '';
  824.     if( !b_end )
  825.         return psz + 1;
  826.     else
  827.         return NULL;
  828. }
  830. /**********************************************************************
  831.  * MRLParse: parse the MRL, find the MRL string and the options,
  832.  * create an item with all information in it, and return the item.
  833.  * return NULL if there is an error.
  834.  **********************************************************************/
  836. /* Function analog to FirstWord except that it relies on colon instead
  837.  * of space to delimit option boundaries. */
  838. static char *FirstOption( char *psz, char *new )
  839. {
  840.     bool b_end, b_start = true;
  842.     while( *psz == ' ' )
  843.         psz++;
  845.     while( *psz != '' && (*psz != ' ' || psz[1] != ':') )
  846.     {
  847.         if( *psz == ''' )
  848.         {
  849.             char c = *psz++;
  850.             while( *psz != '' && *psz != c )
  851.             {
  852.                 if( *psz == '\' && psz[1] != '' )
  853.                     psz++;
  854.                 *new++ = *psz++;
  855.                 b_start = false;
  856.             }
  857.             if( *psz == c )
  858.                 psz++;
  859.         }
  860.         else
  861.         {
  862.             if( *psz == '\' && psz[1] != '' )
  863.                 psz++;
  864.             *new++ = *psz++;
  865.             b_start = false;
  866.         }
  867.     }
  868.     b_end = !*psz;
  870.     if ( !b_start )
  871.         while (new[-1] == ' ')
  872.             new--;
  874.     *new++ = '';
  875.     if( !b_end )
  876.         return psz + 1;
  877.     else
  878.         return NULL;
  879. }
  881. input_item_t *MRLParse( intf_thread_t *p_intf, const char *mrl,
  882.                                    char *psz_name )
  883. {
  884.     char *psz = strdup( mrl ), *s_mrl = psz, *s_temp;
  885.     if( psz == NULL )
  886.         return NULL;
  887.     /* extract the mrl */
  888.     s_temp = FirstOption( s_mrl, s_mrl );
  889.     if( s_temp == NULL )
  890.     {
  891.         s_temp = s_mrl + strlen( s_mrl );
  892.     }
  894.     input_item_t *p_input = input_item_New( p_intf, s_mrl, psz_name );
  895.     if( p_input == NULL )
  896.         return NULL;
  897.     s_mrl = s_temp;
  899.     /* now we can take care of the options */
  900.     while ( *s_mrl != '' )
  901.     {
  902.         s_temp = FirstOption( s_mrl, s_mrl );
  903.         if( s_mrl == '' )
  904.             break;
  905.         if( s_temp == NULL )
  906.         {
  907.             s_temp = s_mrl + strlen( s_mrl );
  908.         }
  909.         input_item_AddOption( p_input, s_mrl, VLC_INPUT_OPTION_TRUSTED );
  910.         s_mrl = s_temp;
  911.     }
  913.     return p_input;
  914. }
  916. /**********************************************************************
  917.  * RealPath: parse ../, ~ and path stuff
  918.  **********************************************************************/
  919. char *RealPath( const char *psz_src )
  920. {
  921.     char *psz_dir;
  922.     char *p;
  923.     int i_len = strlen(psz_src);
  925.     psz_dir = malloc( i_len + 2 );
  926.     strcpy( psz_dir, psz_src );
  928.     /* Add a trailing sep to ease the .. step */
  929.     psz_dir[i_len] = DIR_SEP_CHAR;
  930.     psz_dir[i_len + 1] = '';
  932. #if (DIR_SEP_CHAR != '/')
  933.     /* Convert all / to native separator */
  934.     p = psz_dir;
  935.     while( (p = strchr( p, '/' )) != NULL )
  936.     {
  937.         *p = DIR_SEP_CHAR;
  938.     }
  939. #endif
  941.     /* FIXME: this could be O(N) rather than O(N²)... */
  942.     /* Remove multiple separators and /./ */
  943.     p = psz_dir;
  944.     while( (p = strchr( p, DIR_SEP_CHAR )) != NULL )
  945.     {
  946.         if( p[1] == DIR_SEP_CHAR )
  947.             memmove( &p[1], &p[2], strlen(&p[2]) + 1 );
  948.         else if( p[1] == '.' && p[2] == DIR_SEP_CHAR )
  949.             memmove( &p[1], &p[3], strlen(&p[3]) + 1 );
  950.         else
  951.             p++;
  952.     }
  954.     if( psz_dir[0] == '~' )
  955.     {
  956.         char *dir;
  957.         asprintf( &dir, "%s%s", config_GetHomeDir(), psz_dir + 1 );
  958.         free( psz_dir );
  959.         psz_dir = dir;
  960.     }
  962.     if( strlen(psz_dir) > 2 )
  963.     {
  964.         /* Fix all .. dir */
  965.         p = psz_dir + 3;
  966.         while( (p = strchr( p, DIR_SEP_CHAR )) != NULL )
  967.         {
  968.             if( p[-1] == '.' && p[-2] == '.' && p[-3] == DIR_SEP_CHAR )
  969.             {
  970.                 char *q;
  971.                 p[-3] = '';
  972.                 if( (q = strrchr( psz_dir, DIR_SEP_CHAR )) != NULL )
  973.                 {
  974.                     memmove( q + 1, p + 1, strlen(p + 1) + 1 );
  975.                     p = q + 1;
  976.                 }
  977.                 else
  978.                 {
  979.                     memmove( psz_dir, p, strlen(p) + 1 );
  980.                     p = psz_dir + 3;
  981.                 }
  982.             }
  983.             else
  984.                 p++;
  985.         }
  986.     }
  988.     /* Remove trailing sep if there are at least 2 sep in the string
  989.      * (handles the C: stuff) */
  990.     p = strrchr( psz_dir, DIR_SEP_CHAR );
  991.     if( p != NULL && p[1] == '' && p != strchr( psz_dir, DIR_SEP_CHAR ) )
  992.         *p = '';
  994.     return psz_dir;
  995. }