rc: header inclusion fix
[vlc.git] / modules / control / http / http.c
1 /*****************************************************************************
2  * http.c : HTTP/HTTPS Remote control interface
3  *****************************************************************************
4  * Copyright (C) 2001-2006 the VideoLAN team
5  *
6  * Authors: Gildas Bazin <gbazin@netcourrier.com>
7  *          Laurent Aimar <fenrir@via.ecp.fr>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
23  *****************************************************************************/
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include "http.h"
29 #include <vlc_plugin.h>
30 #include <vlc_url.h>
31
32 #include <assert.h>
33
34 /*****************************************************************************
35  * Module descriptor
36  *****************************************************************************/
37 static int  Open ( vlc_object_t * );
38 static void Close( vlc_object_t * );
39
40 #define HOST_TEXT N_( "Host address" )
41 #define HOST_LONGTEXT N_( \
42     "Address and port the HTTP interface will listen on. It defaults to " \
43     "all network interfaces (0.0.0.0)." \
44     " If you want the HTTP interface to be available only on the local " \
45     "machine, enter 127.0.0.1" )
46 #define SRC_TEXT N_( "Source directory" )
47 #define SRC_LONGTEXT N_( "Source directory" )
48 #define HANDLERS_TEXT N_( "Handlers" )
49 #define HANDLERS_LONGTEXT N_( \
50         "List of handler extensions and executable paths (for instance: " \
51         "php=/usr/bin/php,pl=/usr/bin/perl)." )
52 #define ART_TEXT N_( "Export album art as /art." )
53 #define ART_LONGTEXT N_( \
54         "Allow exporting album art for current playlist items at the " \
55         "/art and /art?id=<id> URLs." )
56 #define CERT_TEXT N_( "Certificate file" )
57 #define CERT_LONGTEXT N_( "HTTP interface x509 PEM certificate file " \
58                           "(enables SSL)." )
59 #define KEY_TEXT N_( "Private key file" )
60 #define KEY_LONGTEXT N_( "HTTP interface x509 PEM private key file." )
61 #define CA_TEXT N_( "Root CA file" )
62 #define CA_LONGTEXT N_( "HTTP interface x509 PEM trusted root CA " \
63                         "certificates file." )
64 #define CRL_TEXT N_( "CRL file" )
65 #define CRL_LONGTEXT N_( "HTTP interace Certificates Revocation List file." )
66
67 vlc_module_begin ()
68     set_shortname( N_("HTTP"))
69     set_description( N_("HTTP remote control interface") )
70     set_category( CAT_INTERFACE )
71     set_subcategory( SUBCAT_INTERFACE_MAIN )
72         add_string ( "http-host", NULL, NULL, HOST_TEXT, HOST_LONGTEXT, true )
73         add_string ( "http-src",  NULL, NULL, SRC_TEXT,  SRC_LONGTEXT,  true )
74         add_obsolete_string ( "http-charset" )
75 #if defined( HAVE_FORK ) || defined( WIN32 )
76         add_string ( "http-handlers", NULL, NULL, HANDLERS_TEXT, HANDLERS_LONGTEXT, true )
77 #endif
78         add_bool   ( "http-album-art", false, NULL, ART_TEXT, ART_LONGTEXT, true )
79         set_section( N_("HTTP SSL" ), 0 )
80         add_string ( "http-intf-cert", NULL, NULL, CERT_TEXT, CERT_LONGTEXT, true )
81         add_string ( "http-intf-key",  NULL, NULL, KEY_TEXT,  KEY_LONGTEXT,  true )
82         add_string ( "http-intf-ca",   NULL, NULL, CA_TEXT,   CA_LONGTEXT,   true )
83         add_string ( "http-intf-crl",  NULL, NULL, CRL_TEXT,  CRL_LONGTEXT,  true )
84     set_capability( "interface", 0 )
85     set_callbacks( Open, Close )
86 vlc_module_end ()
87
88
89 /*****************************************************************************
90  * Local prototypes
91  *****************************************************************************/
92 int  ArtCallback( httpd_handler_sys_t *p_args,
93                           httpd_handler_t *p_handler, char *_p_url,
94                           uint8_t *_p_request, int i_type,
95                           uint8_t *_p_in, int i_in,
96                           char *psz_remote_addr, char *psz_remote_host,
97                           uint8_t **pp_data, int *pi_data );
98
99 /*****************************************************************************
100  * Activate: initialize and create stuff
101  *****************************************************************************/
102 static int Open( vlc_object_t *p_this )
103 {
104     intf_thread_t *p_intf = (intf_thread_t*)p_this;
105     intf_sys_t    *p_sys;
106     char          *psz_address;
107     char          *psz_cert = NULL, *psz_key = NULL, *psz_ca = NULL,
108                   *psz_crl = NULL;
109     int           i_port       = 0;
110     char          *psz_src = NULL;
111
112     psz_address = var_CreateGetNonEmptyString( p_intf, "http-host" );
113     if( psz_address != NULL )
114     {
115         char *psz_parser = strrchr( psz_address, ':' );
116         if( psz_parser )
117         {
118             *psz_parser++ = '\0';
119             i_port = atoi( psz_parser );
120         }
121     }
122     else
123         psz_address = strdup("");
124
125     p_intf->p_sys = p_sys = malloc( sizeof( intf_sys_t ) );
126     if( !p_intf->p_sys )
127     {
128         free( psz_address );
129         return( VLC_ENOMEM );
130     }
131
132     p_sys->p_playlist = pl_Hold( p_this );
133     p_sys->p_input    = NULL;
134     p_sys->p_vlm      = NULL;
135     p_sys->psz_address = psz_address;
136     p_sys->i_port     = i_port;
137     p_sys->p_art_handler = NULL;
138
139     /* determine file handler associations */
140     p_sys->i_handlers = 0;
141     p_sys->pp_handlers = NULL;
142 #if defined( HAVE_FORK ) || defined( WIN32 )
143     psz_src = config_GetPsz( p_intf, "http-handlers" );
144     if( psz_src != NULL && *psz_src )
145     {
146         char *p = psz_src;
147         while( p != NULL )
148         {
149             http_association_t *p_handler;
150             char *psz_ext = p;
151             char *psz_program, *psz_options;
152             p = strchr( p, '=' );
153             if( p == NULL ) break;
154             *p++ = '\0';
155             psz_program = p;
156             p = strchr( p, ',' );
157             if( p != NULL )
158                 *p++ = '\0';
159
160             p_handler = malloc( sizeof( http_association_t ) );
161             p_handler->psz_ext = strdup( psz_ext );
162             psz_options = FirstWord( psz_program, psz_program );
163             p_handler->i_argc = 0;
164             p_handler->ppsz_argv = NULL;
165             TAB_APPEND( p_handler->i_argc, p_handler->ppsz_argv,
166                         strdup( psz_program ) );
167             while( psz_options != NULL && *psz_options )
168             {
169                 char *psz_next = FirstWord( psz_options, psz_options );
170                 TAB_APPEND( p_handler->i_argc, p_handler->ppsz_argv,
171                             strdup( psz_options ) );
172                 psz_options = psz_next;
173             }
174             /* NULL will be appended later on */
175
176             TAB_APPEND( p_sys->i_handlers, p_sys->pp_handlers, p_handler );
177         }
178     }
179     free( psz_src );
180 #endif
181
182     /* determine SSL configuration */
183     psz_cert = config_GetPsz( p_intf, "http-intf-cert" );
184     if ( psz_cert != NULL )
185     {
186         msg_Dbg( p_intf, "enabling TLS for HTTP interface (cert file: %s)",
187                  psz_cert );
188         psz_key = var_GetNonEmptyString( p_intf, "http-intf-key" );
189         psz_ca = var_GetNonEmptyString( p_intf, "http-intf-ca" );
190         psz_crl = var_GetNonEmptyString( p_intf, "http-intf-crl" );
191
192         if( i_port <= 0 )
193             i_port = 8443;
194     }
195     else
196     {
197         if( i_port <= 0 )
198             i_port= 8080;
199     }
200
201     msg_Dbg( p_intf, "base %s:%d", psz_address, i_port );
202
203     p_sys->p_httpd_host = httpd_TLSHostNew( VLC_OBJECT(p_intf), psz_address,
204                                             i_port, psz_cert, psz_key, psz_ca,
205                                             psz_crl );
206     free( psz_cert );
207     free( psz_key );
208     free( psz_ca );
209     free( psz_crl );
210
211     if( p_sys->p_httpd_host == NULL )
212     {
213         msg_Err( p_intf, "cannot listen on %s:%d", psz_address, i_port );
214         pl_Release( p_this );
215         free( p_sys->psz_address );
216         free( p_sys );
217         return VLC_EGENERIC;
218     }
219     else
220     {
221         char psz_tmp[NI_MAXHOST + 6];
222
223         /* Ugly hack to run several HTTP servers on different ports */
224         snprintf( psz_tmp, sizeof (psz_tmp), "%s:%d", psz_address, i_port + 1 );
225         var_Create(p_intf->p_libvlc, "http-host", VLC_VAR_STRING );
226         var_SetString( p_intf->p_libvlc, "http-host", psz_tmp );
227     }
228
229     p_sys->i_files  = 0;
230     p_sys->pp_files = NULL;
231
232     psz_src = config_GetPsz( p_intf, "http-src" );
233     if( ( psz_src == NULL ) || ( *psz_src == '\0' ) )
234     {
235         const char *data_path = config_GetDataDir ();
236         if( asprintf( &psz_src, "%s" DIR_SEP "http", data_path ) == -1 )
237             psz_src = NULL;
238     }
239
240     if( !psz_src || *psz_src == '\0' )
241     {
242         msg_Err( p_intf, "invalid web interface source directory" );
243         goto failed;
244     }
245
246     /* remove trainling \ or / */
247     if( psz_src[strlen( psz_src ) - 1] == '\\' ||
248         psz_src[strlen( psz_src ) - 1] == '/' )
249     {
250         psz_src[strlen( psz_src ) - 1] = '\0';
251     }
252
253     ParseDirectory( p_intf, psz_src, psz_src );
254     if( p_sys->i_files <= 0 )
255     {
256         msg_Err( p_intf, "cannot find any file in directory %s", psz_src );
257         goto failed;
258     }
259
260     free( psz_src );
261
262     if( config_GetInt( p_intf, "http-album-art" ) )
263     {
264         /* FIXME: we're leaking h */
265         httpd_handler_sys_t *h = malloc( sizeof( httpd_handler_sys_t ) );
266         if( !h )
267             goto failed;
268         h->file.p_intf = p_intf;
269         h->file.file = NULL;
270         h->file.name = NULL;
271         /* TODO: use ACL and login/password stuff here too */
272         h->p_handler = httpd_HandlerNew( p_sys->p_httpd_host,
273                                          "/art", NULL, NULL, NULL,
274                                          ArtCallback, h );
275         p_sys->p_art_handler = h->p_handler;
276     }
277
278     return VLC_SUCCESS;
279
280 failed:
281     free( psz_src );
282     free( p_sys->pp_files );
283     httpd_HostDelete( p_sys->p_httpd_host );
284     free( p_sys->psz_address );
285     free( p_sys );
286     pl_Release( p_this );
287     return VLC_EGENERIC;
288 }
289
290 /*****************************************************************************
291  * Close: destroy interface
292  *****************************************************************************/
293 static void Close ( vlc_object_t *p_this )
294 {
295     intf_thread_t *p_intf = (intf_thread_t *)p_this;
296     intf_sys_t    *p_sys = p_intf->p_sys;
297     int i;
298
299 #ifdef ENABLE_VLM
300     if( p_sys->p_vlm )
301         vlm_Delete( p_sys->p_vlm );
302 #endif
303     for( i = 0; i < p_sys->i_files; i++ )
304     {
305         if( p_sys->pp_files[i]->b_handler )
306             httpd_HandlerDelete( ((httpd_handler_sys_t *)p_sys->pp_files[i])->p_handler );
307         else
308             httpd_FileDelete( p_sys->pp_files[i]->p_file );
309         if( p_sys->pp_files[i]->p_redir )
310             httpd_RedirectDelete( p_sys->pp_files[i]->p_redir );
311         if( p_sys->pp_files[i]->p_redir2 )
312             httpd_RedirectDelete( p_sys->pp_files[i]->p_redir2 );
313
314         free( p_sys->pp_files[i]->file );
315         free( p_sys->pp_files[i]->name );
316         free( p_sys->pp_files[i] );
317     }
318     free( p_sys->pp_files );
319     for( i = 0; i < p_sys->i_handlers; i++ )
320     {
321         http_association_t *p_handler = p_sys->pp_handlers[i];
322         int j;
323         free( p_handler->psz_ext );
324         for( j = 0; j < p_handler->i_argc; j++ )
325             free( p_handler->ppsz_argv[j] );
326         if( p_handler->i_argc )
327             free( p_handler->ppsz_argv );
328         free( p_handler );
329     }
330     if( p_sys->i_handlers )
331         free( p_sys->pp_handlers );
332     if( p_sys->p_art_handler )
333         httpd_HandlerDelete( p_sys->p_art_handler );
334     httpd_HostDelete( p_sys->p_httpd_host );
335     free( p_sys->psz_address );
336     free( p_sys );
337     pl_Release( p_this );
338 }
339
340 /****************************************************************************
341  * HttpCallback:
342  ****************************************************************************
343  * a file with b_html is parsed and all "macro" replaced
344  ****************************************************************************/
345 static void Callback404( httpd_file_sys_t *p_args, char **pp_data,
346                          int *pi_data )
347 {
348     char *p = *pp_data = malloc( 10240 );
349     if( !p )
350     {
351         return;
352     }
353     p += sprintf( p, "Content-Type: text/html\n" );
354     p += sprintf( p, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n" );
355     p += sprintf( p, "<head>\n" );
356     p += sprintf( p, "<title>Error loading %s</title>\n", p_args->file );
357     p += sprintf( p, "</head>\n" );
358     p += sprintf( p, "<body>\n" );
359     p += sprintf( p, "<h1><center>Error loading %s for %s</center></h1>\n", p_args->file, p_args->name );
360     p += sprintf( p, "<a href=\"http://www.videolan.org/\">VideoLAN</a>\n" );
361     p += sprintf( p, "</body>\n" );
362     p += sprintf( p, "</html>\n" );
363
364     *pi_data = strlen( *pp_data );
365 }
366
367 static void ParseExecute( httpd_file_sys_t *p_args, char *p_buffer,
368                           int i_buffer, char *p_request,
369                           char **pp_data, int *pi_data )
370 {
371     intf_sys_t *p_sys = p_args->p_intf->p_sys;
372     int i_request = p_request != NULL ? strlen( p_request ) : 0;
373     char *dst;
374     vlc_value_t val;
375     char position[4]; /* percentage */
376     char time[12]; /* in seconds */
377     char length[12]; /* in seconds */
378     audio_volume_t i_volume;
379     char volume[5];
380     const char *state;
381     char stats[20];
382
383     assert( p_sys->p_input == NULL );
384     /* FIXME: proper locking anyone? */
385     p_sys->p_input = playlist_CurrentInput( p_sys->p_playlist );
386     if( p_sys->p_input )
387     {
388         var_Get( p_sys->p_input, "position", &val);
389         sprintf( position, "%d" , (int)((val.f_float) * 100.0));
390         var_Get( p_sys->p_input, "time", &val);
391         sprintf( time, "%"PRIi64, (int64_t)val.i_time / INT64_C(1000000) );
392         var_Get( p_sys->p_input, "length", &val);
393         sprintf( length, "%"PRIi64, (int64_t)val.i_time / INT64_C(1000000) );
394
395         var_Get( p_sys->p_input, "state", &val );
396         if( val.i_int == PLAYING_S )
397         {
398             state = "playing";
399         }
400         else if( val.i_int == OPENING_S )
401         {
402             state = "opening/connecting";
403         }
404         else if( val.i_int == PAUSE_S )
405         {
406             state = "paused";
407         }
408         else
409         {
410             state = "stop";
411         }
412     }
413     else
414     {
415         sprintf( position, "%d", 0 );
416         sprintf( time, "%d", 0 );
417         sprintf( length, "%d", 0 );
418         state = "stop";
419     }
420
421     aout_VolumeGet( p_args->p_intf, &i_volume );
422     sprintf( volume, "%d", (int)i_volume );
423
424     p_args->vars = mvar_New( "variables", "" );
425     mvar_AppendNewVar( p_args->vars, "url_param",
426                            i_request > 0 ? "1" : "0" );
427     mvar_AppendNewVar( p_args->vars, "url_value", p_request );
428     mvar_AppendNewVar( p_args->vars, "version", VLC_Version() );
429     mvar_AppendNewVar( p_args->vars, "copyright", COPYRIGHT_MESSAGE );
430     mvar_AppendNewVar( p_args->vars, "vlc_compile_by", VLC_CompileBy() );
431     mvar_AppendNewVar( p_args->vars, "vlc_compile_host",
432                            VLC_CompileHost() );
433     mvar_AppendNewVar( p_args->vars, "vlc_compile_domain",
434                            VLC_CompileDomain() );
435     mvar_AppendNewVar( p_args->vars, "vlc_compiler", VLC_Compiler() );
436     mvar_AppendNewVar( p_args->vars, "stream_position", position );
437     mvar_AppendNewVar( p_args->vars, "stream_time", time );
438     mvar_AppendNewVar( p_args->vars, "stream_length", length );
439     mvar_AppendNewVar( p_args->vars, "volume", volume );
440     mvar_AppendNewVar( p_args->vars, "stream_state", state );
441     mvar_AppendNewVar( p_args->vars, "charset", "UTF-8" );
442
443     /* Stats */
444     if( p_sys->p_input )
445     {
446         /* FIXME: Workarround a stupid assert in input_GetItem */
447         input_item_t *p_item = p_sys->p_input && p_sys->p_input->p
448                                ? input_GetItem( p_sys->p_input )
449                                : NULL;
450
451         if( p_item )
452         {
453             vlc_mutex_lock( &p_item->p_stats->lock );
454 #define STATS_INT( n ) sprintf( stats, "%d", p_item->p_stats->i_ ## n ); \
455                        mvar_AppendNewVar( p_args->vars, #n, stats );
456 #define STATS_FLOAT( n ) sprintf( stats, "%f", p_item->p_stats->f_ ## n ); \
457                        mvar_AppendNewVar( p_args->vars, #n, stats );
458             STATS_INT( read_bytes )
459             STATS_FLOAT( input_bitrate )
460             STATS_INT( demux_read_bytes )
461             STATS_FLOAT( demux_bitrate )
462             STATS_INT( decoded_video )
463             STATS_INT( displayed_pictures )
464             STATS_INT( lost_pictures )
465             STATS_INT( decoded_audio )
466             STATS_INT( played_abuffers )
467             STATS_INT( lost_abuffers )
468             STATS_INT( sent_packets )
469             STATS_INT( sent_bytes )
470             STATS_FLOAT( send_bitrate )
471 #undef STATS_INT
472 #undef STATS_FLOAT
473             vlc_mutex_unlock( &p_item->p_stats->lock );
474         }
475     }
476
477     SSInit( &p_args->stack );
478
479     /* allocate output */
480     *pi_data = i_buffer + 1000;
481     dst = *pp_data = malloc( *pi_data );
482
483     /* we parse executing all  <vlc /> macros */
484     Execute( p_args, p_request, i_request, pp_data, pi_data, &dst,
485                  &p_buffer[0], &p_buffer[i_buffer] );
486
487     *dst     = '\0';
488     *pi_data = dst - *pp_data;
489
490     if( p_sys->p_input != NULL )
491     {
492         vlc_object_release( p_sys->p_input );
493         p_sys->p_input = NULL;
494     }
495     SSClean( &p_args->stack );
496     mvar_Delete( p_args->vars );
497 }
498
499 int  HttpCallback( httpd_file_sys_t *p_args,
500                        httpd_file_t *p_file,
501                        uint8_t *_p_request,
502                        uint8_t **_pp_data, int *pi_data )
503 {
504     VLC_UNUSED(p_file);
505     char *p_request = (char *)_p_request;
506     char **pp_data = (char **)_pp_data;
507     FILE *f;
508
509     if( ( f = utf8_fopen( p_args->file, "r" ) ) == NULL )
510     {
511         Callback404( p_args, pp_data, pi_data );
512         return VLC_SUCCESS;
513     }
514
515     if( !p_args->b_html )
516     {
517         FileLoad( f, pp_data, pi_data );
518     }
519     else
520     {
521         int  i_buffer;
522         char *p_buffer;
523
524         /* first we load in a temporary buffer */
525         FileLoad( f, &p_buffer, &i_buffer );
526
527         ParseExecute( p_args, p_buffer, i_buffer, p_request, pp_data, pi_data );
528
529         free( p_buffer );
530     }
531
532     fclose( f );
533
534     return VLC_SUCCESS;
535 }
536
537 /****************************************************************************
538  * HandlerCallback:
539  ****************************************************************************
540  * call the external handler and parse vlc macros if Content-Type is HTML
541  ****************************************************************************/
542 int  HandlerCallback( httpd_handler_sys_t *p_args,
543                           httpd_handler_t *p_handler, char *_p_url,
544                           uint8_t *_p_request, int i_type,
545                           uint8_t *_p_in, int i_in,
546                           char *psz_remote_addr, char *psz_remote_host,
547                           uint8_t **_pp_data, int *pi_data )
548 {
549     VLC_UNUSED(p_handler); VLC_UNUSED(_p_in);
550     char *p_url = (char *)_p_url;
551     char *p_request = (char *)_p_request;
552     char **pp_data = (char **)_pp_data;
553     char *p_in = (char *)_p_in;
554     int i_request = p_request != NULL ? strlen( p_request ) : 0;
555     char *p;
556     int i_env = 0;
557     char **ppsz_env = NULL;
558     char *psz_tmp;
559     size_t i_buffer;
560     char *p_buffer;
561     char *psz_cwd, *psz_file = NULL;
562     int i_ret;
563
564     /* Create environment for the CGI */
565     TAB_APPEND( i_env, ppsz_env, strdup("GATEWAY_INTERFACE=CGI/1.1") );
566     TAB_APPEND( i_env, ppsz_env, strdup("SERVER_PROTOCOL=HTTP/1.1") );
567     TAB_APPEND( i_env, ppsz_env, strdup("SERVER_SOFTWARE=" COPYRIGHT_MESSAGE) );
568
569     switch( i_type )
570     {
571     case HTTPD_MSG_GET:
572         TAB_APPEND( i_env, ppsz_env, strdup("REQUEST_METHOD=GET") );
573         break;
574     case HTTPD_MSG_POST:
575         TAB_APPEND( i_env, ppsz_env, strdup("REQUEST_METHOD=POST") );
576         break;
577     case HTTPD_MSG_HEAD:
578         TAB_APPEND( i_env, ppsz_env, strdup("REQUEST_METHOD=HEAD") );
579         break;
580     default:
581         break;
582     }
583
584     if( i_request )
585     {
586         asprintf( &psz_tmp, "QUERY_STRING=%s", p_request );
587         TAB_APPEND( i_env, ppsz_env, psz_tmp );
588
589         asprintf( &psz_tmp, "REQUEST_URI=%s?%s", p_url, p_request );
590         TAB_APPEND( i_env, ppsz_env, psz_tmp );
591     }
592     else
593     {
594         asprintf( &psz_tmp, "REQUEST_URI=%s", p_url );
595         TAB_APPEND( i_env, ppsz_env, psz_tmp );
596     }
597
598     asprintf( &psz_tmp, "SCRIPT_NAME=%s", p_url );
599     TAB_APPEND( i_env, ppsz_env, psz_tmp );
600
601 #define p_sys p_args->file.p_intf->p_sys
602     asprintf( &psz_tmp, "SERVER_NAME=%s", p_sys->psz_address );
603     TAB_APPEND( i_env, ppsz_env, psz_tmp );
604
605     asprintf( &psz_tmp, "SERVER_PORT=%u", p_sys->i_port );
606     TAB_APPEND( i_env, ppsz_env, psz_tmp );
607 #undef p_sys
608
609     p = getenv( "PATH" );
610     if( p != NULL )
611     {
612         asprintf( &psz_tmp, "PATH=%s", p );
613         TAB_APPEND( i_env, ppsz_env, psz_tmp );
614     }
615
616 #ifdef WIN32
617     p = getenv( "windir" );
618     if( p != NULL )
619     {
620         asprintf( &psz_tmp, "SYSTEMROOT=%s", p );
621         TAB_APPEND( i_env, ppsz_env, psz_tmp );
622     }
623 #endif
624
625     if( psz_remote_addr != NULL && *psz_remote_addr )
626     {
627         asprintf( &psz_tmp, "REMOTE_ADDR=%s", psz_remote_addr );
628         TAB_APPEND( i_env, ppsz_env, psz_tmp );
629     }
630
631     if( psz_remote_host != NULL && *psz_remote_host )
632     {
633         asprintf( &psz_tmp, "REMOTE_HOST=%s", psz_remote_host );
634         TAB_APPEND( i_env, ppsz_env, psz_tmp );
635     }
636
637     if( i_in )
638     {
639         p = p_in;
640         for ( ; ; )
641         {
642             if( !strncasecmp( p, "Content-Type: ", strlen("Content-Type: ") ) )
643             {
644                 char *end = strchr( p, '\r' );
645                 if( end == NULL )
646                     break;
647                 *end = '\0';
648                 asprintf( &psz_tmp, "CONTENT_TYPE=%s", p );
649                 TAB_APPEND( i_env, ppsz_env, psz_tmp );
650                 *end = '\r';
651             }
652             if( !strncasecmp( p, "Content-Length: ",
653                               strlen("Content-Length: ") ) )
654             {
655                 char *end = strchr( p, '\r' );
656                 if( end == NULL )
657                     break;
658                 *end = '\0';
659                 asprintf( &psz_tmp, "CONTENT_LENGTH=%s", p );
660                 TAB_APPEND( i_env, ppsz_env, psz_tmp );
661                 *end = '\r';
662             }
663
664             p = strchr( p, '\n' );
665             if( p == NULL || p[1] == '\r' )
666             {
667                 p = NULL;
668                 break;
669             }
670             p++;
671         }
672     }
673
674     psz_file = strrchr( p_args->file.file, DIR_SEP_CHAR );
675     if( psz_file != NULL )
676     {
677         psz_file++;
678         asprintf( &psz_tmp, "SCRIPT_FILENAME=%s", psz_file );
679         TAB_APPEND( i_env, ppsz_env, psz_tmp );
680
681         TAB_APPEND( p_args->p_association->i_argc,
682                     p_args->p_association->ppsz_argv, psz_file );
683     }
684
685     TAB_APPEND( i_env, ppsz_env, NULL );
686
687     TAB_APPEND( p_args->p_association->i_argc, p_args->p_association->ppsz_argv,
688                 NULL );
689
690     psz_tmp = strdup( p_args->file.file );
691     p = strrchr( psz_tmp, DIR_SEP_CHAR );
692     if( p != NULL )
693     {
694         *p = '\0';
695         psz_cwd = psz_tmp;
696     }
697     else
698     {
699         free( psz_tmp );
700         psz_cwd = NULL;
701     }
702
703     i_ret = vlc_execve( p_args->file.p_intf, p_args->p_association->i_argc,
704                         p_args->p_association->ppsz_argv, ppsz_env, psz_cwd,
705                         (char *)p_in, i_in, &p_buffer, &i_buffer );
706     TAB_REMOVE( p_args->p_association->i_argc, p_args->p_association->ppsz_argv,
707                 NULL );
708     TAB_REMOVE( p_args->p_association->i_argc, p_args->p_association->ppsz_argv,
709                 psz_file );
710     free( psz_cwd );
711     while( i_env )
712         TAB_REMOVE( i_env, ppsz_env, ppsz_env[0] );
713
714     if( i_ret == -1 )
715     {
716         Callback404( (httpd_file_sys_t *)p_args, pp_data, pi_data );
717         return VLC_SUCCESS;
718     }
719     p = p_buffer;
720     while( strncasecmp( p, "Content-Type: text/html",
721                         strlen("Content-Type: text/html") ) )
722     {
723         p = strchr( p, '\n' );
724         if( p == NULL || p[1] == '\r' )
725         {
726             p = NULL;
727             break;
728         }
729         p++;
730     }
731
732     if( p == NULL )
733     {
734         *pp_data = p_buffer;
735         *pi_data = i_buffer;
736     }
737     else
738     {
739         ParseExecute( (httpd_file_sys_t *)p_args, p_buffer, i_buffer,
740                       p_request, pp_data, pi_data );
741
742         free( p_buffer );
743     }
744
745     return VLC_SUCCESS;
746 }
747
748 int  ArtCallback( httpd_handler_sys_t *p_args,
749                           httpd_handler_t *p_handler, char *_p_url,
750                           uint8_t *p_request, int i_type,
751                           uint8_t *p_in, int i_in,
752                           char *psz_remote_addr, char *psz_remote_host,
753                           uint8_t **pp_data, int *pi_data )
754 {
755     VLC_UNUSED(p_handler); VLC_UNUSED(_p_url); VLC_UNUSED(i_type); 
756     VLC_UNUSED(p_in); VLC_UNUSED(i_in); VLC_UNUSED(psz_remote_addr); 
757     VLC_UNUSED(psz_remote_host); 
758
759     char *psz_art = NULL;
760     intf_thread_t *p_intf = p_args->file.p_intf;
761     intf_sys_t *p_sys = p_intf->p_sys;
762     char psz_id[16];
763     input_item_t *p_item = NULL;
764     int i_id;
765
766     psz_id[0] = '\0';
767     if( p_request )
768         ExtractURIValue( (char *)p_request, "id", psz_id, 15 );
769     i_id = atoi( psz_id );
770     if( i_id )
771     {
772         playlist_Lock( p_sys->p_playlist );
773         playlist_item_t *p_pl_item = playlist_ItemGetById( p_sys->p_playlist,
774                                                            i_id );
775         if( p_pl_item )
776             p_item = p_pl_item->p_input;
777         playlist_Unlock( p_sys->p_playlist );
778     }
779     else
780     {
781         /* FIXME: Workarround a stupid assert in input_GetItem */
782         if( p_sys->p_input && p_sys->p_input->p )
783             p_item = input_GetItem( p_sys->p_input );
784     }
785
786     if( p_item )
787     {
788         psz_art = input_item_GetArtURL( p_item );
789     }
790
791     if( psz_art && !strncmp( psz_art, "file://", strlen( "file://" ) ) &&
792         decode_URI( psz_art + 7 ) )
793     {
794         FILE *f;
795         char *psz_ext;
796         char *psz_header;
797         char *p_data = NULL;
798         int i_header_size, i_data;
799
800         if( ( f = utf8_fopen( psz_art + strlen( "file://" ), "r" ) ) == NULL )
801         {
802             msg_Dbg( p_intf, "Couldn't open album art file %s",
803                      psz_art + strlen( "file://" ) );
804             Callback404( &p_args->file, (char**)pp_data, pi_data );
805             free( psz_art );
806             return VLC_SUCCESS;
807         }
808
809         FileLoad( f, &p_data, &i_data );
810
811         fclose( f );
812
813         psz_ext = strrchr( psz_art, '.' );
814         if( psz_ext ) psz_ext++;
815
816 #define HEADER  "Content-Type: image/%s\n" \
817                 "Content-Length: %d\n" \
818                 "\n"
819         i_header_size = asprintf( &psz_header, HEADER, psz_ext, i_data );
820 #undef HEADER
821
822         *pi_data = i_header_size + i_data;
823         *pp_data = (uint8_t*)malloc( *pi_data );
824         memcpy( *pp_data, psz_header, i_header_size );
825         memcpy( *pp_data+i_header_size, p_data, i_data );
826         free( psz_header );
827         free( p_data );
828     }
829     else
830     {
831         msg_Dbg( p_intf, "No album art found" );
832         Callback404( &p_args->file, (char**)pp_data, pi_data );
833     }
834
835     free( psz_art );
836
837     return VLC_SUCCESS;
838 }