Compile fix
[vlc.git] / modules / control / http / util.c
1 /*****************************************************************************
2  * util.c : Utility functions for HTTP interface
3  *****************************************************************************
4  * Copyright (C) 2001-2005 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
8  *          Laurent Aimar <fenrir@via.ecp.fr>
9  *          Christophe Massiot <massiot@via.ecp.fr>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
24  *****************************************************************************/
25
26 #include <vlc/vlc.h>
27 #include <stdio.h>
28 #include "http.h"
29 #include "vlc_strings.h"
30
31 /****************************************************************************
32  * File and directory functions
33  ****************************************************************************/
34
35 /* ToUrl: create a good name for an url from filename */
36 char *E_(FileToUrl)( char *name, vlc_bool_t *pb_index )
37 {
38     char *url, *p;
39
40     url = p = malloc( strlen( name ) + 1 );
41
42     *pb_index = VLC_FALSE;
43     if( !url || !p )
44     {
45         return NULL;
46     }
47
48 #ifdef WIN32
49     while( *name == '\\' || *name == '/' )
50 #else
51     while( *name == '/' )
52 #endif
53     {
54         name++;
55     }
56
57     *p++ = '/';
58     strcpy( p, name );
59
60 #ifdef WIN32
61     /* convert '\\' into '/' */
62     name = p;
63     while( *name )
64     {
65         if( *name == '\\' )
66             *name = '/';
67         name++;
68     }
69 #endif
70
71     /* index.* -> / */
72     if( ( p = strrchr( url, '/' ) ) != NULL )
73     {
74         if( !strncmp( p, "/index.", 7 ) )
75         {
76             p[1] = '\0';
77             *pb_index = VLC_TRUE;
78         }
79     }
80     return url;
81 }
82
83 /* Load a file */
84 int E_(FileLoad)( FILE *f, char **pp_data, int *pi_data )
85 {
86     int i_read;
87
88     /* just load the file */
89     *pi_data = 0;
90     *pp_data = malloc( 1025 );  /* +1 for \0 */
91     while( ( i_read = fread( &(*pp_data)[*pi_data], 1, 1024, f ) ) == 1024 )
92     {
93         *pi_data += 1024;
94         *pp_data = realloc( *pp_data, *pi_data  + 1025 );
95     }
96     if( i_read > 0 )
97     {
98         *pi_data += i_read;
99     }
100     (*pp_data)[*pi_data] = '\0';
101
102     return VLC_SUCCESS;
103 }
104
105 /* Parse a directory and recursively add files */
106 int E_(ParseDirectory)( intf_thread_t *p_intf, char *psz_root,
107                         char *psz_dir )
108 {
109     intf_sys_t     *p_sys = p_intf->p_sys;
110     char           dir[MAX_DIR_SIZE];
111 #ifdef HAVE_SYS_STAT_H
112     struct stat   stat_info;
113 #endif
114     DIR           *p_dir;
115     vlc_acl_t     *p_acl;
116     FILE          *file;
117
118     char          *user = NULL;
119     char          *password = NULL;
120
121     int           i_dirlen;
122
123     char sep;
124
125 #if defined( WIN32 )
126     sep = '\\';
127 #else
128     sep = '/';
129 #endif
130
131 #ifdef HAVE_SYS_STAT_H
132     if( utf8_stat( psz_dir, &stat_info ) == -1 || !S_ISDIR( stat_info.st_mode ) )
133     {
134         return VLC_EGENERIC;
135     }
136 #endif
137
138     if( ( p_dir = utf8_opendir( psz_dir ) ) == NULL )
139     {
140         msg_Err( p_intf, "cannot open directory (%s)", psz_dir );
141         return VLC_EGENERIC;
142     }
143
144     i_dirlen = strlen( psz_dir );
145     if( i_dirlen + 10 > MAX_DIR_SIZE )
146     {
147         msg_Warn( p_intf, "skipping too deep directory (%s)", psz_dir );
148         return 0;
149     }
150
151     msg_Dbg( p_intf, "dir=%s", psz_dir );
152
153     sprintf( dir, "%s%c.access", psz_dir, sep );
154     if( ( file = utf8_fopen( dir, "r" ) ) != NULL )
155     {
156         char line[1024];
157         int  i_size;
158
159         msg_Dbg( p_intf, "find .access in dir=%s", psz_dir );
160
161         i_size = fread( line, 1, 1023, file );
162         if( i_size > 0 )
163         {
164             char *p;
165             while( i_size > 0 && ( line[i_size-1] == '\n' ||
166                    line[i_size-1] == '\r' ) )
167             {
168                 i_size--;
169             }
170
171             line[i_size] = '\0';
172
173             p = strchr( line, ':' );
174             if( p )
175             {
176                 *p++ = '\0';
177                 user = strdup( line );
178                 password = strdup( p );
179             }
180         }
181         msg_Dbg( p_intf, "using user=%s password=%s (read=%d)",
182                  user, password, i_size );
183
184         fclose( file );
185     }
186
187     sprintf( dir, "%s%c.hosts", psz_dir, sep );
188     p_acl = ACL_Create( p_intf, VLC_FALSE );
189     if( ACL_LoadFile( p_acl, dir ) )
190     {
191         ACL_Destroy( p_acl );
192         p_acl = NULL;
193     }
194
195     for( ;; )
196     {
197         const char *psz_filename;
198         /* parse psz_src dir */
199         if( ( psz_filename = utf8_readdir( p_dir ) ) == NULL )
200         {
201             break;
202         }
203
204         if( ( psz_filename[0] == '.' )
205          || ( i_dirlen + strlen( psz_filename ) > MAX_DIR_SIZE ) )
206             continue;
207
208         sprintf( dir, "%s%c%s", psz_dir, sep, psz_filename );
209         free( (char*) psz_filename );
210
211         if( E_(ParseDirectory)( p_intf, psz_root, dir ) )
212         {
213             httpd_file_sys_t *f = NULL;
214             httpd_handler_sys_t *h = NULL;
215             vlc_bool_t b_index;
216             char *psz_name, *psz_ext;
217
218             psz_name = E_(FileToUrl)( &dir[strlen( psz_root )], &b_index );
219             psz_ext = strrchr( dir, '.' );
220             if( psz_ext != NULL )
221             {
222                 int i;
223                 psz_ext++;
224                 for( i = 0; i < p_sys->i_handlers; i++ )
225                     if( !strcmp( p_sys->pp_handlers[i]->psz_ext, psz_ext ) )
226                         break;
227                 if( i < p_sys->i_handlers )
228                 {
229                     f = malloc( sizeof( httpd_handler_sys_t ) );
230                     h = (httpd_handler_sys_t *)f;
231                     f->b_handler = VLC_TRUE;
232                     h->p_association = p_sys->pp_handlers[i];
233                 }
234             }
235             if( f == NULL )
236             {
237                 f = malloc( sizeof( httpd_file_sys_t ) );
238                 f->b_handler = VLC_FALSE;
239             }
240
241             f->p_intf  = p_intf;
242             f->p_file = NULL;
243             f->p_redir = NULL;
244             f->p_redir2 = NULL;
245             f->file = strdup (dir);
246             f->name = psz_name;
247             f->b_html = strstr( &dir[strlen( psz_root )], ".htm" ) || strstr( &dir[strlen( psz_root )], ".xml" ) ? VLC_TRUE : VLC_FALSE;
248
249             if( !f->name )
250             {
251                 msg_Err( p_intf , "unable to parse directory" );
252                 closedir( p_dir );
253                 free( f );
254                 return( VLC_ENOMEM );
255             }
256             msg_Dbg( p_intf, "file=%s (url=%s)",
257                      f->file, f->name );
258
259             if( !f->b_handler )
260             {
261                 char *psz_type = strdup( p_sys->psz_html_type );
262                 if( strstr( &dir[strlen( psz_root )], ".xml" ) )
263                 {
264                     char *psz = strstr( psz_type, "html;" );
265                     if( psz )
266                     {
267                         psz[0] = 'x';
268                         psz[1] = 'm';
269                         psz[2] = 'l';
270                         psz[3] = ';';
271                         psz[4] = ' ';
272                     }
273                 }
274                 f->p_file = httpd_FileNew( p_sys->p_httpd_host,
275                                            f->name,
276                                            f->b_html ? psz_type : NULL,
277                                            user, password, p_acl,
278                                            E_(HttpCallback), f );
279                 free( psz_type );
280                 if( f->p_file != NULL )
281                 {
282                     TAB_APPEND( p_sys->i_files, p_sys->pp_files, f );
283                 }
284             }
285             else
286             {
287                 h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
288                                                  f->name,
289                                                  user, password, p_acl,
290                                                  E_(HandlerCallback), h );
291                 if( h->p_handler != NULL )
292                 {
293                     TAB_APPEND( p_sys->i_files, p_sys->pp_files,
294                                 (httpd_file_sys_t *)h );
295                 }
296             }
297
298             /* for url that ends by / add
299              *  - a redirect from rep to rep/
300              *  - in case of index.* rep/index.html to rep/ */
301             if( f && f->name[strlen(f->name) - 1] == '/' )
302             {
303                 char *psz_redir = strdup( f->name );
304                 char *p;
305                 psz_redir[strlen( psz_redir ) - 1] = '\0';
306
307                 msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
308                 f->p_redir = httpd_RedirectNew( p_sys->p_httpd_host, f->name, psz_redir );
309                 free( psz_redir );
310
311                 if( b_index && ( p = strstr( f->file, "index." ) ) )
312                 {
313                     asprintf( &psz_redir, "%s%s", f->name, p );
314
315                     msg_Dbg( p_intf, "redir=%s -> %s", psz_redir, f->name );
316                     f->p_redir2 = httpd_RedirectNew( p_sys->p_httpd_host,
317                                                      f->name, psz_redir );
318
319                     free( psz_redir );
320                 }
321             }
322         }
323     }
324
325     if( user )
326     {
327         free( user );
328     }
329     if( password )
330     {
331         free( password );
332     }
333
334     ACL_Destroy( p_acl );
335     closedir( p_dir );
336
337     return VLC_SUCCESS;
338 }
339
340
341 /**************************************************************************
342  * Locale functions
343  **************************************************************************/
344 char *E_(FromUTF8)( intf_thread_t *p_intf, char *psz_utf8 )
345 {
346     intf_sys_t    *p_sys = p_intf->p_sys;
347
348     if ( p_sys->iconv_from_utf8 != (vlc_iconv_t)-1 )
349     {
350         size_t i_in = strlen(psz_utf8);
351         size_t i_out = i_in * 2;
352         char *psz_local = malloc(i_out + 1);
353         char *psz_out = psz_local;
354         size_t i_ret;
355         char psz_tmp[i_in + 1];
356         const char *psz_in = psz_tmp;
357         strcpy( psz_tmp, psz_utf8 );
358
359         i_in = strlen( psz_tmp );
360
361         i_ret = vlc_iconv( p_sys->iconv_from_utf8, &psz_in, &i_in,
362                            &psz_out, &i_out );
363         if( i_ret == (size_t)-1 || i_in )
364         {
365             msg_Warn( p_intf,
366                       "failed to convert \"%s\" to desired charset (%s)",
367                       psz_utf8, strerror(errno) );
368             free( psz_local );
369             return strdup( psz_utf8 );
370         }
371
372         *psz_out = '\0';
373         return psz_local;
374     }
375     else
376         return strdup( psz_utf8 );
377 }
378
379 char *E_(ToUTF8)( intf_thread_t *p_intf, char *psz_local )
380 {
381     intf_sys_t    *p_sys = p_intf->p_sys;
382
383     if ( p_sys->iconv_to_utf8 != (vlc_iconv_t)-1 )
384     {
385         const char *psz_in = psz_local;
386         size_t i_in = strlen(psz_in);
387         size_t i_out = i_in * 6;
388         char *psz_utf8 = malloc(i_out + 1);
389         char *psz_out = psz_utf8;
390
391         size_t i_ret = vlc_iconv( p_sys->iconv_to_utf8, &psz_in, &i_in,
392                                   &psz_out, &i_out );
393         if( i_ret == (size_t)-1 || i_in )
394         {
395             msg_Warn( p_intf,
396                       "failed to convert \"%s\" to desired charset (%s)",
397                       psz_local, strerror(errno) );
398             free( psz_utf8 );
399             return strdup( psz_local );
400         }
401
402         *psz_out = '\0';
403         return psz_utf8;
404     }
405     else
406         return strdup( psz_local );
407 }
408
409 /*************************************************************************
410  * Playlist stuff
411  *************************************************************************/
412 void E_(PlaylistListNode)( intf_thread_t *p_intf, playlist_t *p_pl,
413                            playlist_item_t *p_node, char *name, mvar_t *s,
414                            int i_depth )
415 {
416     if( p_node != NULL )
417     {
418         if( p_node->i_children == -1 )
419         {
420             char value[512];
421             char *psz;
422             mvar_t *itm = E_(mvar_New)( name, "set" );
423
424             if( p_pl->status.p_item && p_node &&
425                 p_pl->status.p_item->p_input && p_node->p_input &&
426                 p_pl->status.p_item->p_input->i_id == p_node->p_input->i_id )
427             {
428                 E_(mvar_AppendNewVar)( itm, "current", "1" );
429             }
430             else
431             {
432                 E_(mvar_AppendNewVar)( itm, "current", "0" );
433             }
434
435             sprintf( value, "%d", p_node->p_input->i_id );
436             E_(mvar_AppendNewVar)( itm, "index", value );
437
438             psz = E_(FromUTF8)( p_intf, p_node->p_input->psz_name );
439             E_(mvar_AppendNewVar)( itm, "name", psz );
440             free( psz );
441
442             psz = E_(FromUTF8)( p_intf, p_node->p_input->psz_uri );
443             E_(mvar_AppendNewVar)( itm, "uri", psz );
444             free( psz );
445
446             sprintf( value, "Item");
447             E_(mvar_AppendNewVar)( itm, "type", value );
448
449             sprintf( value, "%d", i_depth );
450             E_(mvar_AppendNewVar)( itm, "depth", value );
451
452             if( p_node->i_flags & PLAYLIST_RO_FLAG )
453             {
454                 E_(mvar_AppendNewVar)( itm, "ro", "ro" );
455             }
456             else
457             {
458                 E_(mvar_AppendNewVar)( itm, "ro", "rw" );
459             }
460
461             sprintf( value, "%ld", (long)p_node->p_input->i_duration );
462             E_(mvar_AppendNewVar)( itm, "duration", value );
463
464             E_(mvar_AppendVar)( s, itm );
465         }
466         else
467         {
468             char value[512];
469             char *psz;
470             int i_child;
471             mvar_t *itm = E_(mvar_New)( name, "set" );
472
473             psz = E_(FromUTF8)( p_intf, p_node->p_input->psz_name );
474             E_(mvar_AppendNewVar)( itm, "name", psz );
475             E_(mvar_AppendNewVar)( itm, "uri", psz );
476             free( psz );
477
478             sprintf( value, "Node" );
479             E_(mvar_AppendNewVar)( itm, "type", value );
480
481             sprintf( value, "%d", p_node->p_input->i_id );
482             E_(mvar_AppendNewVar)( itm, "index", value );
483
484             sprintf( value, "%d", p_node->i_children);
485             E_(mvar_AppendNewVar)( itm, "i_children", value );
486
487             sprintf( value, "%d", i_depth );
488             E_(mvar_AppendNewVar)( itm, "depth", value );
489
490             if( p_node->i_flags & PLAYLIST_RO_FLAG )
491             {
492                 E_(mvar_AppendNewVar)( itm, "ro", "ro" );
493             }
494             else
495             {
496                 E_(mvar_AppendNewVar)( itm, "ro", "rw" );
497             }
498
499             E_(mvar_AppendVar)( s, itm );
500
501             for (i_child = 0 ; i_child < p_node->i_children ; i_child++)
502                 E_(PlaylistListNode)( p_intf, p_pl,
503                                       p_node->pp_children[i_child],
504                                       name, s, i_depth + 1);
505
506         }
507     }
508 }
509
510 /****************************************************************************
511  * Seek command parsing handling
512  ****************************************************************************/
513 void E_(HandleSeek)( intf_thread_t *p_intf, char *p_value )
514 {
515     intf_sys_t     *p_sys = p_intf->p_sys;
516     vlc_value_t val;
517     int i_stock = 0;
518     uint64_t i_length;
519     int i_value = 0;
520     int i_relative = 0;
521 #define POSITION_ABSOLUTE 12
522 #define POSITION_REL_FOR 13
523 #define POSITION_REL_BACK 11
524 #define VL_TIME_ABSOLUTE 0
525 #define VL_TIME_REL_FOR 1
526 #define VL_TIME_REL_BACK -1
527     if( p_sys->p_input )
528     {
529         var_Get( p_sys->p_input, "length", &val );
530         i_length = val.i_time;
531
532         while( p_value[0] != '\0' )
533         {
534             switch(p_value[0])
535             {
536                 case '+':
537                 {
538                     i_relative = VL_TIME_REL_FOR;
539                     p_value++;
540                     break;
541                 }
542                 case '-':
543                 {
544                     i_relative = VL_TIME_REL_BACK;
545                     p_value++;
546                     break;
547                 }
548                 case '0': case '1': case '2': case '3': case '4':
549                 case '5': case '6': case '7': case '8': case '9':
550                 {
551                     i_stock = strtol( p_value , &p_value , 10 );
552                     break;
553                 }
554                 case '%': /* for percentage ie position */
555                 {
556                     i_relative += POSITION_ABSOLUTE;
557                     i_value = i_stock;
558                     i_stock = 0;
559                     p_value[0] = '\0';
560                     break;
561                 }
562                 case ':':
563                 {
564                     i_value = 60 * (i_value + i_stock) ;
565                     i_stock = 0;
566                     p_value++;
567                     break;
568                 }
569                 case 'h': case 'H': /* hours */
570                 {
571                     i_value += 3600 * i_stock;
572                     i_stock = 0;
573                     /* other characters which are not numbers are not
574                      * important */
575                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
576                            && (p_value[0] != '\0') )
577                     {
578                         p_value++;
579                     }
580                     break;
581                 }
582                 case 'm': case 'M': case '\'': /* minutes */
583                 {
584                     i_value += 60 * i_stock;
585                     i_stock = 0;
586                     p_value++;
587                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
588                            && (p_value[0] != '\0') )
589                     {
590                         p_value++;
591                     }
592                     break;
593                 }
594                 case 's': case 'S': case '"':  /* seconds */
595                 {
596                     i_value += i_stock;
597                     i_stock = 0;
598                     while( ((p_value[0] < '0') || (p_value[0] > '9'))
599                            && (p_value[0] != '\0') )
600                     {
601                         p_value++;
602                     }
603                     break;
604                 }
605                 default:
606                 {
607                     p_value++;
608                     break;
609                 }
610             }
611         }
612
613         /* if there is no known symbol, I consider it as seconds.
614          * Otherwise, i_stock = 0 */
615         i_value += i_stock;
616
617         switch(i_relative)
618         {
619             case VL_TIME_ABSOLUTE:
620             {
621                 if( (uint64_t)( i_value ) * 1000000 <= i_length )
622                     val.i_time = (uint64_t)( i_value ) * 1000000;
623                 else
624                     val.i_time = i_length;
625
626                 var_Set( p_sys->p_input, "time", val );
627                 msg_Dbg( p_intf, "requested seek position: %dsec", i_value );
628                 break;
629             }
630             case VL_TIME_REL_FOR:
631             {
632                 var_Get( p_sys->p_input, "time", &val );
633                 if( (uint64_t)( i_value ) * 1000000 + val.i_time <= i_length )
634                 {
635                     val.i_time = ((uint64_t)( i_value ) * 1000000) + val.i_time;
636                 } else
637                 {
638                     val.i_time = i_length;
639                 }
640                 var_Set( p_sys->p_input, "time", val );
641                 msg_Dbg( p_intf, "requested seek position forward: %dsec", i_value );
642                 break;
643             }
644             case VL_TIME_REL_BACK:
645             {
646                 var_Get( p_sys->p_input, "time", &val );
647                 if( (int64_t)( i_value ) * 1000000 > val.i_time )
648                 {
649                     val.i_time = 0;
650                 } else
651                 {
652                     val.i_time = val.i_time - ((uint64_t)( i_value ) * 1000000);
653                 }
654                 var_Set( p_sys->p_input, "time", val );
655                 msg_Dbg( p_intf, "requested seek position backward: %dsec", i_value );
656                 break;
657             }
658             case POSITION_ABSOLUTE:
659             {
660                 val.f_float = __MIN( __MAX( ((float) i_value ) / 100.0 ,
661                                             0.0 ), 100.0 );
662                 var_Set( p_sys->p_input, "position", val );
663                 msg_Dbg( p_intf, "requested seek percent: %d%%", i_value );
664                 break;
665             }
666             case POSITION_REL_FOR:
667             {
668                 var_Get( p_sys->p_input, "position", &val );
669                 val.f_float += __MIN( __MAX( ((float) i_value ) / 100.0,
670                                              0.0 ) , 100.0 );
671                 var_Set( p_sys->p_input, "position", val );
672                 msg_Dbg( p_intf, "requested seek percent forward: %d%%",
673                          i_value );
674                 break;
675             }
676             case POSITION_REL_BACK:
677             {
678                 var_Get( p_sys->p_input, "position", &val );
679                 val.f_float -= __MIN( __MAX( ((float) i_value ) / 100.0,
680                                              0.0 ) , 100.0 );
681                 var_Set( p_sys->p_input, "position", val );
682                 msg_Dbg( p_intf, "requested seek percent backward: %d%%",
683                          i_value );
684                 break;
685             }
686             default:
687             {
688                 msg_Dbg( p_intf, "invalid seek request" );
689                 break;
690             }
691         }
692     }
693 #undef POSITION_ABSOLUTE
694 #undef POSITION_REL_FOR
695 #undef POSITION_REL_BACK
696 #undef VL_TIME_ABSOLUTE
697 #undef VL_TIME_REL_FOR
698 #undef VL_TIME_REL_BACK
699 }
700
701
702 /****************************************************************************
703  * URI Parsing functions
704  ****************************************************************************/
705 int E_(TestURIParam)( char *psz_uri, const char *psz_name )
706 {
707     char *p = psz_uri;
708
709     while( (p = strstr( p, psz_name )) )
710     {
711         /* Verify that we are dealing with a post/get argument */
712         if( (p == psz_uri || *(p - 1) == '&' || *(p - 1) == '\n')
713               && p[strlen(psz_name)] == '=' )
714         {
715             return VLC_TRUE;
716         }
717         p++;
718     }
719
720     return VLC_FALSE;
721 }
722
723 static char *FindURIValue( char *psz_uri, const char *restrict psz_name,
724                            size_t *restrict p_len )
725 {
726     char *p = psz_uri, *end;
727     size_t len;
728
729     while( (p = strstr( p, psz_name )) )
730     {
731         /* Verify that we are dealing with a post/get argument */
732         if( (p == psz_uri || *(p - 1) == '&' || *(p - 1) == '\n')
733               && p[strlen(psz_name)] == '=' )
734             break;
735         p++;
736     }
737
738     if( p == NULL )
739     {
740         *p_len = 0;
741         return NULL;
742     }
743
744     p += strlen( psz_name );
745     if( *p == '=' ) p++;
746
747     if( ( end = strchr( p, '\n' ) ) != NULL )
748     {
749         /* POST method */
750         if( ( end > p ) && ( end[-1] == '\r' ) )
751             end--;
752
753         len = end - p;
754     }
755     else
756     {
757         /* GET method */
758         if( ( end = strchr( p, '&' ) ) != NULL )
759             len = end - p;
760         else
761             len = strlen( p );
762     }
763
764     *p_len = len;
765     return p;
766 }
767
768 char *E_(ExtractURIValue)( char *restrict psz_uri,
769                            const char *restrict psz_name,
770                            char *restrict psz_buf, size_t bufsize )
771 {
772     size_t len;
773     char *psz_value = FindURIValue( psz_uri, psz_name, &len );
774     char *psz_next;
775
776     if( psz_value == NULL )
777     {
778         if( bufsize > 0 )
779             *psz_buf = '\0';
780         return NULL;
781     }
782
783     psz_next = psz_value + len;
784
785     if( len >= bufsize )
786         len = bufsize - 1;
787
788     if( len > 0 )
789         strncpy( psz_buf, psz_value, len );
790     if( bufsize > 0 )
791         psz_buf[len] = '\0';
792
793     return psz_next;
794 }
795
796 char *E_(ExtractURIString)( char *restrict psz_uri,
797                             const char *restrict psz_name )
798 {
799     size_t len;
800     char *psz_value = FindURIValue( psz_uri, psz_name, &len );
801
802     if( psz_value == NULL )
803         return NULL;
804
805     char *res = malloc( len + 1 );
806     if( res == NULL )
807         return NULL;
808
809     memcpy( res, psz_value, len );
810     res[len] = '\0';
811
812     return res;
813 }
814
815 /* Since the resulting string is smaller we can work in place, so it is
816  * permitted to have psz == new. new points to the first word of the
817  * string, the function returns the remaining string. */
818 char *E_(FirstWord)( char *psz, char *new )
819 {
820     vlc_bool_t b_end;
821
822     while( *psz == ' ' )
823         psz++;
824
825     while( *psz != '\0' && *psz != ' ' )
826     {
827         if( *psz == '\'' )
828         {
829             char c = *psz++;
830             while( *psz != '\0' && *psz != c )
831             {
832                 if( *psz == '\\' && psz[1] != '\0' )
833                     psz++;
834                 *new++ = *psz++;
835             }
836             if( *psz == c )
837                 psz++;
838         }
839         else
840         {
841             if( *psz == '\\' && psz[1] != '\0' )
842                 psz++;
843             *new++ = *psz++;
844         }
845     }
846     b_end = !*psz;
847
848     *new++ = '\0';
849     if( !b_end )
850         return psz + 1;
851     else
852         return NULL;
853 }
854
855 /**********************************************************************
856  * MRLParse: parse the MRL, find the MRL string and the options,
857  * create an item with all information in it, and return the item.
858  * return NULL if there is an error.
859  **********************************************************************/
860
861 /* Function analog to FirstWord except that it relies on colon instead
862  * of space to delimit option boundaries. */
863 static char *FirstOption( char *psz, char *new )
864 {
865     vlc_bool_t b_end, b_start = VLC_TRUE;
866
867     while( *psz == ' ' )
868         psz++;
869
870     while( *psz != '\0' && (*psz != ' ' || psz[1] != ':') )
871     {
872         if( *psz == '\'' )
873         {
874             char c = *psz++;
875             while( *psz != '\0' && *psz != c )
876             {
877                 if( *psz == '\\' && psz[1] != '\0' )
878                     psz++;
879                 *new++ = *psz++;
880                 b_start = VLC_FALSE;
881             }
882             if( *psz == c )
883                 psz++;
884         }
885         else
886         {
887             if( *psz == '\\' && psz[1] != '\0' )
888                 psz++;
889             *new++ = *psz++;
890             b_start = VLC_FALSE;
891         }
892     }
893     b_end = !*psz;
894
895     if ( !b_start )
896         while (new[-1] == ' ')
897             new--;
898
899     *new++ = '\0';
900     if( !b_end )
901         return psz + 1;
902     else
903         return NULL;
904 }
905
906 input_item_t *E_(MRLParse)( intf_thread_t *p_intf, char *_psz,
907                                    char *psz_name )
908 {
909     char *psz = strdup( _psz );
910     char *s_mrl = psz;
911     char *s_temp;
912     input_item_t * p_input = NULL;
913
914     /* extract the mrl */
915     s_temp = FirstOption( s_mrl, s_mrl );
916     if( s_temp == NULL )
917     {
918         s_temp = s_mrl + strlen( s_mrl );
919     }
920
921     p_input = input_ItemNew( p_intf, s_mrl, psz_name );
922     s_mrl = s_temp;
923
924     /* now we can take care of the options */
925     while ( *s_mrl != '\0' )
926     {
927         s_temp = FirstOption( s_mrl, s_mrl );
928         if( s_mrl == '\0' )
929             break;
930         if( s_temp == NULL )
931         {
932             s_temp = s_mrl + strlen( s_mrl );
933         }
934         input_ItemAddOption( p_input, s_mrl );
935         s_mrl = s_temp;
936     }
937
938     free( psz );
939     return p_input;
940 }
941
942 /**********************************************************************
943  * RealPath: parse ../, ~ and path stuff
944  **********************************************************************/
945 char *E_(RealPath)( intf_thread_t *p_intf, const char *psz_src )
946 {
947     char *psz_dir;
948     char *p;
949     int i_len = strlen(psz_src);
950     const char sep = DIR_SEP_CHAR;
951
952     psz_dir = malloc( i_len + 2 );
953     strcpy( psz_dir, psz_src );
954
955     /* Add a trailing sep to ease the .. step */
956     psz_dir[i_len] = sep;
957     psz_dir[i_len + 1] = '\0';
958
959 #if (DIR_SEP_CHAR != '/')
960     /* Convert all / to native separator */
961     p = psz_dir;
962     while( (p = strchr( p, '/' )) != NULL )
963     {
964         *p = sep;
965     }
966 #endif
967
968     /* FIXME: this could be O(N) rather than O(N²)... */
969     /* Remove multiple separators and /./ */
970     p = psz_dir;
971     while( (p = strchr( p, sep )) != NULL )
972     {
973         if( p[1] == sep )
974             memmove( &p[1], &p[2], strlen(&p[2]) + 1 );
975         else if( p[1] == '.' && p[2] == sep )
976             memmove( &p[1], &p[3], strlen(&p[3]) + 1 );
977         else
978             p++;
979     }
980
981     if( psz_dir[0] == '~' )
982     {
983         char dir;
984         /* This is incomplete : we should also support the ~cmassiot/ syntax. */
985         asprintf( &dir, "%s%s", p_intf->p_libvlc->psz_userdir, psz_dir + 1 );
986         free( psz_dir );
987         psz_dir = dir;
988     }
989
990     if( strlen(psz_dir) > 2 )
991     {
992         /* Fix all .. dir */
993         p = psz_dir + 3;
994         while( (p = strchr( p, sep )) != NULL )
995         {
996             if( p[-1] == '.' && p[-2] == '.' && p[-3] == sep )
997             {
998                 char *q;
999                 p[-3] = '\0';
1000                 if( (q = strrchr( psz_dir, sep )) != NULL )
1001                 {
1002                     memmove( q + 1, p + 1, strlen(p + 1) + 1 );
1003                     p = q + 1;
1004                 }
1005                 else
1006                 {
1007                     memmove( psz_dir, p, strlen(p) + 1 );
1008                     p = psz_dir + 3;
1009                 }
1010             }
1011             else
1012                 p++;
1013         }
1014     }
1015
1016     /* Remove trailing sep if there are at least 2 sep in the string
1017      * (handles the C:\ stuff) */
1018     p = strrchr( psz_dir, sep );
1019     if( p != NULL && p[1] == '\0' && p != strchr( psz_dir, sep ) )
1020         *p = '\0';
1021
1022     return psz_dir;
1023 }