Qt: Change almost all icons
[vlc.git] / modules / access / http.c
1 /*****************************************************************************
2  * http.c: HTTP input module
3  *****************************************************************************
4  * Copyright (C) 2001-2008 VLC authors and VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *          Christophe Massiot <massiot@via.ecp.fr>
9  *          Rémi Denis-Courmont <rem # videolan.org>
10  *          Antoine Cellerier <dionoea at videolan dot org>
11  *
12  * This program is free software; you can redistribute it and/or modify it
13  * under the terms of the GNU Lesser General Public License as published by
14  * the Free Software Foundation; either version 2.1 of the License, or
15  * (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  * GNU Lesser General Public License for more details.
21  *
22  * You should have received a copy of the GNU Lesser General Public License
23  * along with this program; if not, write to the Free Software Foundation,
24  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25  *****************************************************************************/
26
27 /*****************************************************************************
28  * Preamble
29  *****************************************************************************/
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <errno.h>
35
36 #include <vlc_common.h>
37 #include <vlc_plugin.h>
38 #include <vlc_access.h>
39 #include <vlc_meta.h>
40 #include <vlc_network.h>
41 #include <vlc_url.h>
42 #include <vlc_strings.h>
43 #include <vlc_charset.h>
44 #include <vlc_input.h>
45 #include <vlc_http.h>
46 #include <vlc_interrupt.h>
47 #include <vlc_keystore.h>
48 #include <vlc_memstream.h>
49
50 #include <assert.h>
51 #include <limits.h>
52
53 /*****************************************************************************
54  * Module descriptor
55  *****************************************************************************/
56 static int  Open ( vlc_object_t * );
57 static void Close( vlc_object_t * );
58
59 #define PROXY_TEXT N_("HTTP proxy")
60 #define PROXY_LONGTEXT N_( \
61     "HTTP proxy to be used It must be of the form " \
62     "http://[user@]myproxy.mydomain:myport/ ; " \
63     "if empty, the http_proxy environment variable will be tried." )
64
65 #define PROXY_PASS_TEXT N_("HTTP proxy password")
66 #define PROXY_PASS_LONGTEXT N_( \
67     "If your HTTP proxy requires a password, set it here." )
68
69 #define RECONNECT_TEXT N_("Auto re-connect")
70 #define RECONNECT_LONGTEXT N_( \
71     "Automatically try to reconnect to the stream in case of a sudden " \
72     "disconnect." )
73
74 vlc_module_begin ()
75     set_description( N_("HTTP input") )
76     set_capability( "access", 0 )
77     set_shortname( N_( "HTTP(S)" ) )
78     set_category( CAT_INPUT )
79     set_subcategory( SUBCAT_INPUT_ACCESS )
80
81     add_string( "http-proxy", NULL, PROXY_TEXT, PROXY_LONGTEXT,
82                 false )
83     add_password( "http-proxy-pwd", NULL,
84                   PROXY_PASS_TEXT, PROXY_PASS_LONGTEXT, false )
85     add_obsolete_bool( "http-use-IE-proxy" )
86     add_bool( "http-reconnect", false, RECONNECT_TEXT,
87               RECONNECT_LONGTEXT, true )
88     /* 'itpc' = iTunes Podcast */
89     add_shortcut( "http", "unsv", "itpc", "icyx" )
90     set_callbacks( Open, Close )
91 vlc_module_end ()
92
93 /*****************************************************************************
94  * Local prototypes
95  *****************************************************************************/
96
97 struct access_sys_t
98 {
99     int fd;
100
101     /* From uri */
102     vlc_url_t url;
103     char    *psz_user_agent;
104     char    *psz_referrer;
105     char    *psz_username;
106     char    *psz_password;
107     vlc_http_auth_t auth;
108
109     /* Proxy */
110     bool b_proxy;
111     vlc_url_t  proxy;
112     vlc_http_auth_t proxy_auth;
113     char       *psz_proxy_passbuf;
114
115     /* */
116     int        i_code;
117
118     char       *psz_mime;
119     char       *psz_location;
120     bool b_icecast;
121
122     int        i_icy_meta;
123     uint64_t   i_icy_offset;
124     char       *psz_icy_name;
125     char       *psz_icy_genre;
126     char       *psz_icy_title;
127
128     uint64_t offset;
129     uint64_t size;
130
131     bool b_reconnect;
132     bool b_continuous;
133     bool b_has_size;
134 };
135
136 /* */
137 static ssize_t Read( stream_t *, void *, size_t );
138 static int Seek( stream_t *, uint64_t );
139 static int Control( stream_t *, int, va_list );
140
141 /* */
142 static int Connect( stream_t * );
143 static void Disconnect( stream_t * );
144
145
146 static int AuthCheckReply( stream_t *p_access, const char *psz_header,
147                            vlc_url_t *p_url, vlc_http_auth_t *p_auth );
148
149 /*****************************************************************************
150  * Open:
151  *****************************************************************************/
152 static int Open( vlc_object_t *p_this )
153 {
154     stream_t *p_access = (stream_t*)p_this;
155     const char *psz_url = p_access->psz_url;
156     char *psz;
157     int ret = VLC_EGENERIC;
158     vlc_credential credential;
159
160     access_sys_t *p_sys = vlc_malloc( p_this, sizeof(*p_sys) );
161     if( unlikely(p_sys == NULL) )
162         return VLC_ENOMEM;
163
164     p_sys->fd = -1;
165     p_sys->b_proxy = false;
166     p_sys->psz_proxy_passbuf = NULL;
167     p_sys->psz_mime = NULL;
168     p_sys->b_icecast = false;
169     p_sys->psz_location = NULL;
170     p_sys->psz_user_agent = NULL;
171     p_sys->psz_referrer = NULL;
172     p_sys->psz_username = NULL;
173     p_sys->psz_password = NULL;
174     p_sys->i_icy_meta = 0;
175     p_sys->i_icy_offset = 0;
176     p_sys->psz_icy_name = NULL;
177     p_sys->psz_icy_genre = NULL;
178     p_sys->psz_icy_title = NULL;
179     p_sys->b_has_size = false;
180     p_sys->offset = 0;
181     p_sys->size = 0;
182     p_access->p_sys = p_sys;
183
184     if( vlc_UrlParse( &p_sys->url, psz_url ) || p_sys->url.psz_host == NULL )
185     {
186         msg_Err( p_access, "invalid URL" );
187         vlc_UrlClean( &p_sys->url );
188         return VLC_EGENERIC;
189     }
190     if( p_sys->url.i_port <= 0 )
191         p_sys->url.i_port = 80;
192
193     vlc_http_auth_Init( &p_sys->auth );
194     vlc_http_auth_Init( &p_sys->proxy_auth );
195     vlc_credential_init( &credential, &p_sys->url );
196
197     /* Determine the HTTP user agent */
198     /* See RFC2616 §2.2 token and comment definition, and §3.8 and
199      * §14.43 user-agent header */
200     p_sys->psz_user_agent = var_InheritString( p_access, "http-user-agent" );
201     if (p_sys->psz_user_agent)
202     {
203         unsigned comment_level = 0;
204         for( char *p = p_sys->psz_user_agent; *p; p++ )
205         {
206             uint8_t c = *p;
207             if (comment_level == 0)
208             {
209                 if( c < 32 || strchr( ")<>@,;:\\\"[]?={}", c ) )
210                     *p = '_'; /* remove potentially harmful characters */
211             }
212             else
213             {
214                 if (c == ')')
215                     comment_level--;
216                 else if( c < 32 && strchr( "\t\r\n", c ) == NULL)
217                     *p = '_'; /* remove potentially harmful characters */
218             }
219             if (c == '(')
220             {
221                 if (comment_level == UINT_MAX)
222                     break;
223                 comment_level++;
224             }
225         }
226         /* truncate evil unclosed comments */
227         if (comment_level > 0)
228         {
229             char *p = strchr(p_sys->psz_user_agent, '(');
230             *p = '\0';
231         }
232     }
233
234     /* HTTP referrer */
235     p_sys->psz_referrer = var_InheritString( p_access, "http-referrer" );
236
237     /* Check proxy */
238     psz = var_InheritString( p_access, "http-proxy" );
239     if( psz == NULL )
240     {
241         msg_Dbg(p_access, "querying proxy for %s", psz_url);
242         psz = vlc_getProxyUrl(psz_url);
243
244         if (psz != NULL)
245             msg_Dbg(p_access, "proxy: %s", psz);
246         else
247             msg_Dbg(p_access, "no proxy");
248     }
249     if( psz != NULL )
250     {
251         p_sys->b_proxy = true;
252         vlc_UrlParse( &p_sys->proxy, psz );
253         free( psz );
254
255         psz = var_InheritString( p_access, "http-proxy-pwd" );
256         if( psz )
257             p_sys->proxy.psz_password = p_sys->psz_proxy_passbuf = psz;
258
259         if( p_sys->proxy.psz_host == NULL || *p_sys->proxy.psz_host == '\0' )
260         {
261             msg_Warn( p_access, "invalid proxy host" );
262             goto error;
263         }
264         if( p_sys->proxy.i_port <= 0 )
265         {
266             p_sys->proxy.i_port = 80;
267         }
268     }
269
270     msg_Dbg( p_access, "http: server='%s' port=%d file='%s'",
271              p_sys->url.psz_host, p_sys->url.i_port,
272              p_sys->url.psz_path != NULL ? p_sys->url.psz_path : "" );
273     if( p_sys->b_proxy )
274     {
275         msg_Dbg( p_access, "      proxy %s:%d", p_sys->proxy.psz_host,
276                  p_sys->proxy.i_port );
277     }
278     if( p_sys->url.psz_username && *p_sys->url.psz_username )
279     {
280         msg_Dbg( p_access, "      user='%s'", p_sys->url.psz_username );
281     }
282
283     p_sys->b_reconnect = var_InheritBool( p_access, "http-reconnect" );
284     p_sys->b_continuous = var_InheritBool( p_access, "http-continuous" );
285
286     if( vlc_credential_get( &credential, p_access, NULL, NULL, NULL, NULL ) )
287     {
288         p_sys->url.psz_username = (char *) credential.psz_username;
289         p_sys->url.psz_password = (char *) credential.psz_password;
290     }
291
292 connect:
293     /* Connect */
294     if( Connect( p_access ) )
295         goto error;
296
297     if( p_sys->i_code == 401 )
298     {
299         if( p_sys->auth.psz_realm == NULL )
300         {
301             msg_Err( p_access, "authentication failed without realm" );
302             goto error;
303         }
304         /* FIXME ? */
305         if( p_sys->url.psz_username && p_sys->url.psz_password &&
306             p_sys->auth.psz_nonce && p_sys->auth.i_nonce == 0 )
307         {
308             Disconnect( p_access );
309             goto connect;
310         }
311         free( p_sys->psz_username );
312         free( p_sys->psz_password );
313         p_sys->psz_username = p_sys->psz_password = NULL;
314
315         msg_Dbg( p_access, "authentication failed for realm %s",
316                  p_sys->auth.psz_realm );
317
318         credential.psz_realm = p_sys->auth.psz_realm;
319         credential.psz_authtype = p_sys->auth.psz_nonce  ? "Digest" : "Basic";
320
321         if( vlc_credential_get( &credential, p_access, NULL, NULL,
322                                _("HTTP authentication"),
323                                _("Please enter a valid login name and a "
324                                "password for realm %s."), p_sys->auth.psz_realm ) )
325         {
326             p_sys->psz_username = strdup(credential.psz_username);
327             p_sys->psz_password = strdup(credential.psz_password);
328             if (!p_sys->psz_username || !p_sys->psz_password)
329                 goto error;
330             msg_Err( p_access, "retrying with user=%s", p_sys->psz_username );
331             p_sys->url.psz_username = p_sys->psz_username;
332             p_sys->url.psz_password = p_sys->psz_password;
333             Disconnect( p_access );
334             goto connect;
335         }
336         else
337             goto error;
338     }
339     else
340         vlc_credential_store( &credential, p_access );
341
342     if( ( p_sys->i_code == 301 || p_sys->i_code == 302 ||
343           p_sys->i_code == 303 || p_sys->i_code == 307 ) &&
344         p_sys->psz_location != NULL )
345     {
346         p_access->psz_url = p_sys->psz_location;
347         p_sys->psz_location = NULL;
348         ret = VLC_ACCESS_REDIRECT;
349         goto error;
350     }
351
352     if( p_sys->b_reconnect ) msg_Dbg( p_access, "auto re-connect enabled" );
353
354     /* Set up p_access */
355     p_access->pf_read = Read;
356     p_access->pf_control = Control;
357     p_access->pf_seek = Seek;
358
359     vlc_credential_clean( &credential );
360
361     return VLC_SUCCESS;
362
363 error:
364     vlc_credential_clean( &credential );
365     vlc_UrlClean( &p_sys->url );
366     if( p_sys->b_proxy )
367         vlc_UrlClean( &p_sys->proxy );
368     free( p_sys->psz_proxy_passbuf );
369     free( p_sys->psz_mime );
370     free( p_sys->psz_location );
371     free( p_sys->psz_user_agent );
372     free( p_sys->psz_referrer );
373     free( p_sys->psz_username );
374     free( p_sys->psz_password );
375
376     Disconnect( p_access );
377
378     return ret;
379 }
380
381 /*****************************************************************************
382  * Close:
383  *****************************************************************************/
384 static void Close( vlc_object_t *p_this )
385 {
386     stream_t     *p_access = (stream_t*)p_this;
387     access_sys_t *p_sys = p_access->p_sys;
388
389     vlc_UrlClean( &p_sys->url );
390     vlc_http_auth_Deinit( &p_sys->auth );
391     if( p_sys->b_proxy )
392         vlc_UrlClean( &p_sys->proxy );
393     vlc_http_auth_Deinit( &p_sys->proxy_auth );
394
395     free( p_sys->psz_mime );
396     free( p_sys->psz_location );
397
398     free( p_sys->psz_icy_name );
399     free( p_sys->psz_icy_genre );
400     free( p_sys->psz_icy_title );
401
402     free( p_sys->psz_user_agent );
403     free( p_sys->psz_referrer );
404     free( p_sys->psz_username );
405     free( p_sys->psz_password );
406
407     Disconnect( p_access );
408 }
409
410 /* Read data from the socket */
411 static int ReadData( stream_t *p_access, int *pi_read,
412                      void *p_buffer, size_t i_len )
413 {
414     access_sys_t *p_sys = p_access->p_sys;
415
416     *pi_read = vlc_recv_i11e( p_sys->fd, p_buffer, i_len, 0 );
417     if( *pi_read < 0 && errno != EINTR && errno != EAGAIN )
418         return VLC_EGENERIC;
419     return VLC_SUCCESS;
420 }
421
422 /*****************************************************************************
423  * Read: Read up to i_len bytes from the http connection and place in
424  * p_buffer. Return the actual number of bytes read
425  *****************************************************************************/
426 static int ReadICYMeta( stream_t *p_access );
427 static ssize_t Read( stream_t *p_access, void *p_buffer, size_t i_len )
428 {
429     access_sys_t *p_sys = p_access->p_sys;
430     int i_read;
431
432     if( p_sys->fd == -1 )
433         return 0;
434
435     if( i_len == 0 )
436         return 0;
437
438     if( p_sys->i_icy_meta > 0 && p_sys->offset - p_sys->i_icy_offset > 0 )
439     {
440         int i_next = p_sys->i_icy_meta -
441                    (p_sys->offset - p_sys->i_icy_offset) % p_sys->i_icy_meta;
442
443         if( i_next == p_sys->i_icy_meta )
444         {
445             if( ReadICYMeta( p_access ) )
446                 return 0;
447         }
448         if( i_len > (size_t)i_next )
449             i_len = i_next;
450     }
451
452     if( ReadData( p_access, &i_read, p_buffer, i_len ) )
453         return 0;
454
455     if( i_read < 0 )
456         return -1; /* EINTR / EAGAIN */
457
458     if( i_read == 0 )
459     {
460         Disconnect( p_access );
461         if( p_sys->b_reconnect )
462         {
463             msg_Dbg( p_access, "got disconnected, trying to reconnect" );
464             if( Connect( p_access ) )
465                 msg_Dbg( p_access, "reconnection failed" );
466             else
467                 return -1;
468         }
469         return 0;
470     }
471
472     assert( i_read >= 0 );
473     p_sys->offset += i_read;
474
475     return i_read;
476 }
477
478 static int ReadICYMeta( stream_t *p_access )
479 {
480     access_sys_t *p_sys = p_access->p_sys;
481
482     uint8_t buffer;
483     char *p, *psz_meta;
484     int i_read;
485
486     /* Read meta data length */
487     if( ReadData( p_access, &i_read, &buffer, 1 ) )
488         return VLC_EGENERIC;
489     if( i_read != 1 )
490         return VLC_EGENERIC;
491     const int i_size = buffer << 4;
492     /* msg_Dbg( p_access, "ICY meta size=%u", i_size); */
493
494     psz_meta = malloc( i_size + 1 );
495     for( i_read = 0; i_read < i_size; )
496     {
497         int i_tmp;
498         if( ReadData( p_access, &i_tmp, (uint8_t *)&psz_meta[i_read], i_size - i_read ) || i_tmp <= 0 )
499         {
500             free( psz_meta );
501             return VLC_EGENERIC;
502         }
503         i_read += i_tmp;
504     }
505     psz_meta[i_read] = '\0'; /* Just in case */
506
507     /* msg_Dbg( p_access, "icy-meta=%s", psz_meta ); */
508
509     /* Now parse the meta */
510     /* Look for StreamTitle= */
511     p = strcasestr( (char *)psz_meta, "StreamTitle=" );
512     if( p )
513     {
514         p += strlen( "StreamTitle=" );
515         if( *p == '\'' || *p == '"' )
516         {
517             char closing[] = { p[0], ';', '\0' };
518             char *psz = strstr( &p[1], closing );
519             if( !psz )
520                 psz = strchr( &p[1], ';' );
521
522             if( psz ) *psz = '\0';
523         }
524         else
525         {
526             char *psz = strchr( &p[1], ';' );
527             if( psz ) *psz = '\0';
528         }
529
530         if( !p_sys->psz_icy_title ||
531             strcmp( p_sys->psz_icy_title, &p[1] ) )
532         {
533             free( p_sys->psz_icy_title );
534             char *psz_tmp = strdup( &p[1] );
535             p_sys->psz_icy_title = EnsureUTF8( psz_tmp );
536             if( !p_sys->psz_icy_title )
537                 free( psz_tmp );
538
539             msg_Dbg( p_access, "New Icy-Title=%s", p_sys->psz_icy_title );
540             input_thread_t *p_input = p_access->p_input;
541             if( p_input )
542             {
543                 input_item_t *p_input_item = input_GetItem( p_access->p_input );
544                 if( p_input_item )
545                     input_item_SetMeta( p_input_item, vlc_meta_NowPlaying, p_sys->psz_icy_title );
546             }
547         }
548     }
549     free( psz_meta );
550
551     return VLC_SUCCESS;
552 }
553
554 /*****************************************************************************
555  * Seek: close and re-open a connection at the right place
556  *****************************************************************************/
557 static int Seek( stream_t *p_access, uint64_t i_pos )
558 {
559     (void) p_access; (void) i_pos;
560     return VLC_EGENERIC;
561 }
562
563 /*****************************************************************************
564  * Control:
565  *****************************************************************************/
566 static int Control( stream_t *p_access, int i_query, va_list args )
567 {
568     access_sys_t *p_sys = p_access->p_sys;
569     bool       *pb_bool;
570     int64_t    *pi_64;
571
572     switch( i_query )
573     {
574         /* */
575         case STREAM_CAN_SEEK:
576         case STREAM_CAN_FASTSEEK:
577             pb_bool = va_arg( args, bool* );
578             *pb_bool = false;
579             break;
580         case STREAM_CAN_PAUSE:
581         case STREAM_CAN_CONTROL_PACE:
582             pb_bool = va_arg( args, bool* );
583             *pb_bool = true;
584             break;
585
586         /* */
587         case STREAM_GET_PTS_DELAY:
588             pi_64 = va_arg( args, int64_t * );
589             *pi_64 = INT64_C(1000)
590                 * var_InheritInteger( p_access, "network-caching" );
591             break;
592
593         case STREAM_GET_SIZE:
594             if( !p_sys->b_has_size )
595                 return VLC_EGENERIC;
596             *va_arg( args, uint64_t*) = p_sys->size;
597            break;
598
599         /* */
600         case STREAM_SET_PAUSE_STATE:
601             break;
602
603         case STREAM_GET_CONTENT_TYPE:
604         {
605             char **type = va_arg( args, char ** );
606
607             if( p_sys->b_icecast && p_sys->psz_mime == NULL )
608                 *type = strdup( "audio/mpeg" );
609             else if( !strcasecmp( p_access->psz_name, "itpc" ) )
610                 *type = strdup( "application/rss+xml" );
611             else if( !strcasecmp( p_access->psz_name, "unsv" ) &&
612                 p_sys->psz_mime != NULL &&
613                 !strcasecmp( p_sys->psz_mime, "misc/ultravox" ) )
614                 /* Grrrr! detect ultravox server and force NSV demuxer */
615                 *type = strdup( "video/nsa" );
616             else if( p_sys->psz_mime )
617                 *type = strdup( p_sys->psz_mime );
618             else
619                 return VLC_EGENERIC;
620             break;
621         }
622
623         default:
624             return VLC_EGENERIC;
625
626     }
627     return VLC_SUCCESS;
628 }
629
630 /*****************************************************************************
631  * Connect:
632  *****************************************************************************/
633 static int Connect( stream_t *p_access )
634 {
635     access_sys_t   *p_sys = p_access->p_sys;
636     vlc_url_t      srv = p_sys->b_proxy ? p_sys->proxy : p_sys->url;
637     ssize_t val;
638
639     /* Clean info */
640     free( p_sys->psz_location );
641     free( p_sys->psz_mime );
642
643     free( p_sys->psz_icy_genre );
644     free( p_sys->psz_icy_name );
645     free( p_sys->psz_icy_title );
646
647
648     p_sys->psz_location = NULL;
649     p_sys->psz_mime = NULL;
650     p_sys->i_icy_meta = 0;
651     p_sys->i_icy_offset = 0;
652     p_sys->psz_icy_name = NULL;
653     p_sys->psz_icy_genre = NULL;
654     p_sys->psz_icy_title = NULL;
655     p_sys->b_has_size = false;
656     p_sys->offset = 0;
657     p_sys->size = 0;
658
659     struct vlc_memstream stream;
660
661     vlc_memstream_open(&stream);
662
663     vlc_memstream_puts(&stream, "GET ");
664     if( p_sys->b_proxy )
665         vlc_memstream_printf( &stream, "http://%s:%d",
666                               p_sys->url.psz_host, p_sys->url.i_port );
667     if( p_sys->url.psz_path == NULL || p_sys->url.psz_path[0] == '\0' )
668         vlc_memstream_putc( &stream, '/' );
669     else
670         vlc_memstream_puts( &stream, p_sys->url.psz_path );
671     if( p_sys->url.psz_option != NULL )
672         vlc_memstream_printf( &stream, "?%s", p_sys->url.psz_option );
673     vlc_memstream_puts( &stream, " HTTP/1.0\r\n" );
674
675     vlc_memstream_printf( &stream, "Host: %s", p_sys->url.psz_host );
676     if( p_sys->url.i_port != 80 )
677         vlc_memstream_printf( &stream, ":%d", p_sys->url.i_port );
678     vlc_memstream_puts( &stream, "\r\n" );
679
680     /* User Agent */
681     vlc_memstream_printf( &stream, "User-Agent: %s\r\n",
682                           p_sys->psz_user_agent );
683     /* Referrer */
684     if (p_sys->psz_referrer)
685         vlc_memstream_printf( &stream, "Referer: %s\r\n",
686                               p_sys->psz_referrer );
687
688     /* Authentication */
689     if( p_sys->url.psz_username != NULL && p_sys->url.psz_password != NULL )
690     {
691         char *auth;
692
693         auth = vlc_http_auth_FormatAuthorizationHeader( VLC_OBJECT(p_access),
694                             &p_sys->auth, "GET", p_sys->url.psz_path,
695                             p_sys->url.psz_username, p_sys->url.psz_password );
696         if( auth != NULL )
697              vlc_memstream_printf( &stream, "Authorization: %s\r\n", auth );
698         free( auth );
699     }
700
701     /* Proxy Authentication */
702     if( p_sys->b_proxy && p_sys->proxy.psz_username != NULL
703      && p_sys->proxy.psz_password != NULL )
704     {
705         char *auth;
706
707         auth = vlc_http_auth_FormatAuthorizationHeader( VLC_OBJECT(p_access),
708                         &p_sys->proxy_auth, "GET", p_sys->url.psz_path,
709                         p_sys->proxy.psz_username, p_sys->proxy.psz_password );
710         if( auth != NULL )
711              vlc_memstream_printf( &stream, "Proxy-Authorization: %s\r\n",
712                                    auth );
713         free( auth );
714     }
715
716     /* ICY meta data request */
717     vlc_memstream_puts( &stream, "Icy-MetaData: 1\r\n" );
718
719     vlc_memstream_puts( &stream, "\r\n" );
720
721     if( vlc_memstream_close( &stream ) )
722         return -1;
723
724     /* Open connection */
725     assert( p_sys->fd == -1 ); /* No open sockets (leaking fds is BAD) */
726     p_sys->fd = net_ConnectTCP( p_access, srv.psz_host, srv.i_port );
727     if( p_sys->fd == -1 )
728     {
729         msg_Err( p_access, "cannot connect to %s:%d", srv.psz_host, srv.i_port );
730         free( stream.ptr );
731         return -1;
732     }
733     setsockopt (p_sys->fd, SOL_SOCKET, SO_KEEPALIVE, &(int){ 1 }, sizeof (int));
734
735     msg_Dbg( p_access, "sending request:\n%s", stream.ptr );
736     val = net_Write( p_access, p_sys->fd, stream.ptr, stream.length );
737     free( stream.ptr );
738
739     if( val < (ssize_t)stream.length )
740     {
741         msg_Err( p_access, "failed to send request" );
742         Disconnect( p_access );
743         return -2;
744     }
745
746     /* Read Answer */
747     char *psz = net_Gets( p_access, p_sys->fd );
748     if( psz == NULL )
749     {
750         msg_Err( p_access, "failed to read answer" );
751         goto error;
752     }
753     if( !strncmp( psz, "HTTP/1.", 7 ) )
754     {
755         p_sys->i_code = atoi( &psz[9] );
756         msg_Dbg( p_access, "HTTP answer code %d", p_sys->i_code );
757     }
758     else if( !strncmp( psz, "ICY", 3 ) )
759     {
760         p_sys->i_code = atoi( &psz[4] );
761         msg_Dbg( p_access, "ICY answer code %d", p_sys->i_code );
762         p_sys->b_icecast = true;
763         p_sys->b_reconnect = true;
764     }
765     else
766     {
767         msg_Err( p_access, "invalid HTTP reply '%s'", psz );
768         free( psz );
769         goto error;
770     }
771     /* Authentication error - We'll have to display the dialog */
772     if( p_sys->i_code == 401 )
773     {
774
775     }
776     /* Other fatal error */
777     else if( p_sys->i_code >= 400 )
778     {
779         msg_Err( p_access, "error: %s", psz );
780         free( psz );
781         goto error;
782     }
783     free( psz );
784
785     for( ;; )
786     {
787         char *p, *p_trailing;
788
789         psz = net_Gets( p_access, p_sys->fd );
790         if( psz == NULL )
791         {
792             msg_Err( p_access, "failed to read answer" );
793             goto error;
794         }
795
796         /* msg_Dbg( p_input, "Line=%s", psz ); */
797         if( *psz == '\0' )
798         {
799             free( psz );
800             break;
801         }
802
803         if( ( p = strchr( psz, ':' ) ) == NULL )
804         {
805             msg_Err( p_access, "malformed header line: %s", psz );
806             free( psz );
807             goto error;
808         }
809         *p++ = '\0';
810         p += strspn( p, " \t" );
811
812         /* trim trailing white space */
813         p_trailing = p + strlen( p );
814         if( p_trailing > p )
815         {
816             p_trailing--;
817             while( ( *p_trailing == ' ' || *p_trailing == '\t' ) && p_trailing > p )
818             {
819                 *p_trailing = '\0';
820                 p_trailing--;
821             }
822         }
823
824         if( !strcasecmp( psz, "Content-Length" ) )
825         {
826             uint64_t i_size = (uint64_t)atoll( p );
827             if(i_size > p_sys->size) {
828                 p_sys->b_has_size = true;
829                 p_sys->size = i_size;
830             }
831         }
832         else if( !strcasecmp( psz, "Location" ) )
833         {
834             char * psz_new_loc;
835
836             /* This does not follow RFC 2068, but yet if the url is not absolute,
837              * handle it as everyone does. */
838             if( p[0] == '/' )
839             {
840                 if( p_sys->url.i_port == 80 )
841                 {
842                     if( asprintf(&psz_new_loc, "http://%s%s",
843                                  p_sys->url.psz_host, p) < 0 )
844                         goto error;
845                 }
846                 else
847                 {
848                     if( asprintf(&psz_new_loc, "http://%s:%d%s",
849                                  p_sys->url.psz_host, p_sys->url.i_port, p) < 0 )
850                         goto error;
851                 }
852             }
853             else
854             {
855                 psz_new_loc = strdup( p );
856             }
857
858             free( p_sys->psz_location );
859             p_sys->psz_location = psz_new_loc;
860         }
861         else if( !strcasecmp( psz, "Content-Type" ) )
862         {
863             free( p_sys->psz_mime );
864             p_sys->psz_mime = strdup( p );
865             msg_Dbg( p_access, "Content-Type: %s", p_sys->psz_mime );
866         }
867         else if( !strcasecmp( psz, "Content-Encoding" ) )
868         {
869             msg_Dbg( p_access, "Content-Encoding: %s", p );
870         }
871         else if( !strcasecmp( psz, "Server" ) )
872         {
873             msg_Dbg( p_access, "Server: %s", p );
874             if( !strncasecmp( p, "Icecast", 7 ) ||
875                 !strncasecmp( p, "Nanocaster", 10 ) )
876             {
877                 /* Remember if this is Icecast
878                  * we need to force demux in this case without breaking
879                  *  autodetection */
880
881                 /* Let live 365 streams (nanocaster) piggyback on the icecast
882                  * routine. They look very similar */
883
884                 p_sys->b_reconnect = true;
885                 p_sys->b_icecast = true;
886             }
887         }
888         else if( !strcasecmp( psz, "Icy-MetaInt" ) )
889         {
890             msg_Dbg( p_access, "Icy-MetaInt: %s", p );
891             p_sys->i_icy_meta = atoi( p );
892             if( p_sys->i_icy_meta < 0 )
893                 p_sys->i_icy_meta = 0;
894             if( p_sys->i_icy_meta > 0 )
895                 p_sys->b_icecast = true;
896
897             msg_Warn( p_access, "ICY metaint=%d", p_sys->i_icy_meta );
898         }
899         else if( !strcasecmp( psz, "Icy-Name" ) )
900         {
901             free( p_sys->psz_icy_name );
902             char *psz_tmp = strdup( p );
903             p_sys->psz_icy_name = EnsureUTF8( psz_tmp );
904             if( !p_sys->psz_icy_name )
905                 free( psz_tmp );
906             else
907                 vlc_xml_decode( p_sys->psz_icy_name );
908             msg_Dbg( p_access, "Icy-Name: %s", p_sys->psz_icy_name );
909             input_thread_t *p_input = p_access->p_input;
910             if ( p_input )
911             {
912                 input_item_t *p_input_item = input_GetItem( p_access->p_input );
913                 if ( p_input_item )
914                     input_item_SetMeta( p_input_item, vlc_meta_Title, p_sys->psz_icy_name );
915             }
916
917             p_sys->b_icecast = true; /* be on the safeside. set it here as well. */
918             p_sys->b_reconnect = true;
919         }
920         else if( !strcasecmp( psz, "Icy-Genre" ) )
921         {
922             free( p_sys->psz_icy_genre );
923             char *psz_tmp = strdup( p );
924             p_sys->psz_icy_genre = EnsureUTF8( psz_tmp );
925             if( !p_sys->psz_icy_genre )
926                 free( psz_tmp );
927             else
928                 vlc_xml_decode( p_sys->psz_icy_genre );
929             msg_Dbg( p_access, "Icy-Genre: %s", p_sys->psz_icy_genre );
930             input_thread_t *p_input = p_access->p_input;
931             if( p_input )
932             {
933                 input_item_t *p_input_item = input_GetItem( p_access->p_input );
934                 if( p_input_item )
935                     input_item_SetMeta( p_input_item, vlc_meta_Genre, p_sys->psz_icy_genre );
936             }
937         }
938         else if( !strncasecmp( psz, "Icy-Notice", 10 ) )
939         {
940             msg_Dbg( p_access, "Icy-Notice: %s", p );
941         }
942         else if( !strncasecmp( psz, "icy-", 4 ) ||
943                  !strncasecmp( psz, "ice-", 4 ) ||
944                  !strncasecmp( psz, "x-audiocast", 11 ) )
945         {
946             msg_Dbg( p_access, "Meta-Info: %s: %s", psz, p );
947         }
948         else if( !strcasecmp( psz, "www-authenticate" ) )
949         {
950             msg_Dbg( p_access, "Authentication header: %s", p );
951             vlc_http_auth_ParseWwwAuthenticateHeader( VLC_OBJECT(p_access),
952                                                       &p_sys->auth, p );
953         }
954         else if( !strcasecmp( psz, "proxy-authenticate" ) )
955         {
956             msg_Dbg( p_access, "Proxy authentication header: %s", p );
957             vlc_http_auth_ParseWwwAuthenticateHeader( VLC_OBJECT(p_access),
958                                                       &p_sys->proxy_auth, p );
959         }
960         else if( !strcasecmp( psz, "authentication-info" ) )
961         {
962             msg_Dbg( p_access, "Authentication Info header: %s", p );
963             if( AuthCheckReply( p_access, p, &p_sys->url, &p_sys->auth ) )
964                 goto error;
965         }
966         else if( !strcasecmp( psz, "proxy-authentication-info" ) )
967         {
968             msg_Dbg( p_access, "Proxy Authentication Info header: %s", p );
969             if( AuthCheckReply( p_access, p, &p_sys->proxy, &p_sys->proxy_auth ) )
970                 goto error;
971         }
972
973         free( psz );
974     }
975     return 0;
976
977 error:
978     Disconnect( p_access );
979     return -2;
980 }
981
982 /*****************************************************************************
983  * Disconnect:
984  *****************************************************************************/
985 static void Disconnect( stream_t *p_access )
986 {
987     access_sys_t *p_sys = p_access->p_sys;
988
989     if( p_sys->fd != -1)
990         net_Close(p_sys->fd);
991     p_sys->fd = -1;
992 }
993
994 /*****************************************************************************
995  * HTTP authentication
996  *****************************************************************************/
997
998 static int AuthCheckReply( stream_t *p_access, const char *psz_header,
999                            vlc_url_t *p_url, vlc_http_auth_t *p_auth )
1000 {
1001     return
1002         vlc_http_auth_ParseAuthenticationInfoHeader( VLC_OBJECT(p_access),
1003                                                      p_auth,
1004                                                      psz_header, "",
1005                                                      p_url->psz_path,
1006                                                      p_url->psz_username,
1007                                                      p_url->psz_password );
1008 }