http: avoid NULL dereference
[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 <vlc_common.h>
35 #include <vlc_plugin.h>
36
37
38 #include <vlc_access.h>
39
40 #include <vlc_dialog.h>
41 #include <vlc_meta.h>
42 #include <vlc_network.h>
43 #include <vlc_url.h>
44 #include <vlc_tls.h>
45 #include <vlc_strings.h>
46 #include <vlc_charset.h>
47 #include <vlc_input.h>
48 #include <vlc_md5.h>
49 #include <vlc_http.h>
50
51 #ifdef HAVE_ZLIB_H
52 #   include <zlib.h>
53 #endif
54
55 #include <assert.h>
56 #include <limits.h>
57
58 /*****************************************************************************
59  * Module descriptor
60  *****************************************************************************/
61 static int  Open ( vlc_object_t * );
62 static void Close( vlc_object_t * );
63
64 #define PROXY_TEXT N_("HTTP proxy")
65 #define PROXY_LONGTEXT N_( \
66     "HTTP proxy to be used It must be of the form " \
67     "http://[user@]myproxy.mydomain:myport/ ; " \
68     "if empty, the http_proxy environment variable will be tried." )
69
70 #define PROXY_PASS_TEXT N_("HTTP proxy password")
71 #define PROXY_PASS_LONGTEXT N_( \
72     "If your HTTP proxy requires a password, set it here." )
73
74 #define RECONNECT_TEXT N_("Auto re-connect")
75 #define RECONNECT_LONGTEXT N_( \
76     "Automatically try to reconnect to the stream in case of a sudden " \
77     "disconnect." )
78
79 #define CONTINUOUS_TEXT N_("Continuous stream")
80 #define CONTINUOUS_LONGTEXT N_("Read a file that is " \
81     "being constantly updated (for example, a JPG file on a server). " \
82     "You should not globally enable this option as it will break all other " \
83     "types of HTTP streams." )
84
85 #define FORWARD_COOKIES_TEXT N_("Forward Cookies")
86 #define FORWARD_COOKIES_LONGTEXT N_("Forward Cookies across http redirections.")
87
88 #define REFERER_TEXT N_("HTTP referer value")
89 #define REFERER_LONGTEXT N_("Customize the HTTP referer, simulating a previous document")
90
91 #define UA_TEXT N_("User Agent")
92 #define UA_LONGTEXT N_("The name and version of the program will be " \
93     "provided to the HTTP server. They must be separated by a forward " \
94     "slash, e.g. FooBar/1.2.3. This option can only be specified per input " \
95     "item, not globally.")
96
97 vlc_module_begin ()
98     set_description( N_("HTTP input") )
99     set_capability( "access", 0 )
100     set_shortname( N_( "HTTP(S)" ) )
101     set_category( CAT_INPUT )
102     set_subcategory( SUBCAT_INPUT_ACCESS )
103
104     add_string( "http-proxy", NULL, PROXY_TEXT, PROXY_LONGTEXT,
105                 false )
106     add_password( "http-proxy-pwd", NULL,
107                   PROXY_PASS_TEXT, PROXY_PASS_LONGTEXT, false )
108     add_obsolete_bool( "http-use-IE-proxy" )
109     add_string( "http-referrer", NULL, REFERER_TEXT, REFERER_LONGTEXT, false )
110         change_safe()
111     add_string( "http-user-agent", NULL, UA_TEXT, UA_LONGTEXT, false )
112         change_safe()
113         change_private()
114     add_bool( "http-reconnect", false, RECONNECT_TEXT,
115               RECONNECT_LONGTEXT, true )
116     add_bool( "http-continuous", false, CONTINUOUS_TEXT,
117               CONTINUOUS_LONGTEXT, true )
118         change_safe()
119     add_bool( "http-forward-cookies", true, FORWARD_COOKIES_TEXT,
120               FORWARD_COOKIES_LONGTEXT, true )
121     /* 'itpc' = iTunes Podcast */
122     add_shortcut( "http", "https", "unsv", "itpc", "icyx" )
123     set_callbacks( Open, Close )
124 vlc_module_end ()
125
126 /*****************************************************************************
127  * Local prototypes
128  *****************************************************************************/
129
130 struct access_sys_t
131 {
132     int fd;
133     bool b_error;
134     vlc_tls_creds_t *p_creds;
135     vlc_tls_t *p_tls;
136     v_socket_t *p_vs;
137
138     /* From uri */
139     vlc_url_t url;
140     char    *psz_user_agent;
141     char    *psz_referrer;
142     http_auth_t auth;
143
144     /* Proxy */
145     bool b_proxy;
146     vlc_url_t  proxy;
147     http_auth_t proxy_auth;
148     char       *psz_proxy_passbuf;
149
150     /* */
151     int        i_code;
152     const char *psz_protocol;
153     int        i_version;
154
155     char       *psz_mime;
156     char       *psz_pragma;
157     char       *psz_location;
158     bool b_mms;
159     bool b_icecast;
160 #ifdef HAVE_ZLIB_H
161     bool b_compressed;
162     struct
163     {
164         z_stream   stream;
165         uint8_t   *p_buffer;
166     } inflate;
167 #endif
168
169     bool b_chunked;
170     int64_t    i_chunk;
171
172     int        i_icy_meta;
173     uint64_t   i_icy_offset;
174     char       *psz_icy_name;
175     char       *psz_icy_genre;
176     char       *psz_icy_title;
177
178     uint64_t i_remaining;
179     uint64_t size;
180
181     bool b_seekable;
182     bool b_reconnect;
183     bool b_continuous;
184     bool b_pace_control;
185     bool b_persist;
186     bool b_has_size;
187
188     vlc_array_t * cookies;
189 };
190
191 /* */
192 static int OpenWithCookies( vlc_object_t *p_this, const char *psz_access,
193                             unsigned i_redirect, vlc_array_t *cookies );
194
195 /* */
196 static ssize_t Read( access_t *, uint8_t *, size_t );
197 static ssize_t ReadCompressed( access_t *, uint8_t *, size_t );
198 static int Seek( access_t *, uint64_t );
199 static int Control( access_t *, int, va_list );
200
201 /* */
202 static int Connect( access_t *, uint64_t );
203 static int Request( access_t *p_access, uint64_t i_tell );
204 static void Disconnect( access_t * );
205
206 /* Small Cookie utilities. Cookies support is partial. */
207 static char * cookie_get_content( const char * cookie );
208 static char * cookie_get_domain( const char * cookie );
209 static char * cookie_get_name( const char * cookie );
210 static void cookie_append( vlc_array_t * cookies, char * cookie );
211
212
213 static void AuthReply( access_t *p_acces, const char *psz_prefix,
214                        vlc_url_t *p_url, http_auth_t *p_auth );
215 static int AuthCheckReply( access_t *p_access, const char *psz_header,
216                            vlc_url_t *p_url, http_auth_t *p_auth );
217
218 /*****************************************************************************
219  * Open:
220  *****************************************************************************/
221 static int Open( vlc_object_t *p_this )
222 {
223     access_t *p_access = (access_t*)p_this;
224     return OpenWithCookies( p_this, p_access->psz_access, 5, NULL );
225 }
226
227 /**
228  * Open the given url using the given cookies
229  * @param p_this: the vlc object
230  * @psz_access: the acces to use (http, https, ...) (this value must be used
231  *              instead of p_access->psz_access)
232  * @i_redirect: number of redirections remaining
233  * @cookies: the available cookies
234  * @return vlc error codes
235  */
236 static int OpenWithCookies( vlc_object_t *p_this, const char *psz_access,
237                             unsigned i_redirect, vlc_array_t *cookies )
238 {
239     access_t     *p_access = (access_t*)p_this;
240     access_sys_t *p_sys;
241     char         *psz, *p;
242
243     /* Set up p_access */
244     STANDARD_READ_ACCESS_INIT;
245 #ifdef HAVE_ZLIB_H
246     p_access->pf_read = ReadCompressed;
247 #endif
248     p_sys->fd = -1;
249     p_sys->b_proxy = false;
250     p_sys->psz_proxy_passbuf = NULL;
251     p_sys->i_version = 1;
252     p_sys->b_seekable = true;
253     p_sys->psz_mime = NULL;
254     p_sys->psz_pragma = NULL;
255     p_sys->b_mms = false;
256     p_sys->b_icecast = false;
257     p_sys->psz_location = NULL;
258     p_sys->psz_user_agent = NULL;
259     p_sys->psz_referrer = NULL;
260     p_sys->b_pace_control = true;
261 #ifdef HAVE_ZLIB_H
262     p_sys->b_compressed = false;
263     /* 15 is the max windowBits, +32 to enable optional gzip decoding */
264     if( inflateInit2( &p_sys->inflate.stream, 32+15 ) != Z_OK )
265         msg_Warn( p_access, "Error during zlib initialisation: %s",
266                   p_sys->inflate.stream.msg );
267     if( zlibCompileFlags() & (1<<17) )
268         msg_Warn( p_access, "Your zlib was compiled without gzip support." );
269     p_sys->inflate.p_buffer = NULL;
270 #endif
271     p_sys->p_tls = NULL;
272     p_sys->p_vs = NULL;
273     p_sys->i_icy_meta = 0;
274     p_sys->i_icy_offset = 0;
275     p_sys->psz_icy_name = NULL;
276     p_sys->psz_icy_genre = NULL;
277     p_sys->psz_icy_title = NULL;
278     p_sys->i_remaining = 0;
279     p_sys->b_persist = false;
280     p_sys->b_has_size = false;
281     p_sys->size = 0;
282     p_access->info.i_pos  = 0;
283     p_access->info.b_eof  = false;
284
285     /* Only forward an store cookies if the corresponding option is activated */
286     if( var_CreateGetBool( p_access, "http-forward-cookies" ) )
287         p_sys->cookies = (cookies != NULL) ? cookies : vlc_array_new();
288     else
289         p_sys->cookies = NULL;
290
291     http_auth_Init( &p_sys->auth );
292     http_auth_Init( &p_sys->proxy_auth );
293
294     /* Parse URI - remove spaces */
295     p = psz = strdup( p_access->psz_location );
296     while( (p = strchr( p, ' ' )) != NULL )
297         *p = '+';
298     vlc_UrlParse( &p_sys->url, psz, 0 );
299     free( psz );
300
301     if( p_sys->url.psz_host == NULL || *p_sys->url.psz_host == '\0' )
302     {
303         msg_Warn( p_access, "invalid host" );
304         goto error;
305     }
306     if( !strncmp( psz_access, "https", 5 ) )
307     {
308         /* HTTP over SSL */
309         p_sys->p_creds = vlc_tls_ClientCreate( p_this );
310         if( p_sys->p_creds == NULL )
311             goto error;
312         if( p_sys->url.i_port <= 0 )
313             p_sys->url.i_port = 443;
314     }
315     else
316     {
317         if( p_sys->url.i_port <= 0 )
318             p_sys->url.i_port = 80;
319     }
320
321     /* Determine the HTTP user agent */
322     /* See RFC2616 §2.2 token and comment definition, and §3.8 and
323      * §14.43 user-agent header */
324     p_sys->psz_user_agent = var_InheritString( p_access, "http-user-agent" );
325     if (p_sys->psz_user_agent)
326     {
327         unsigned comment_level = 0;
328         for( char *p = p_sys->psz_user_agent; *p; p++ )
329         {
330             uint8_t c = *p;
331             if (comment_level == 0)
332             {
333                 if( c < 32 || strchr( ")<>@,;:\\\"[]?={}", c ) )
334                     *p = '_'; /* remove potentially harmful characters */
335             }
336             else
337             {
338                 if (c == ')')
339                     comment_level--;
340                 else if( c < 32 && strchr( "\t\r\n", c ) == NULL)
341                     *p = '_'; /* remove potentially harmful characters */
342             }
343             if (c == '(')
344             {
345                 if (comment_level == UINT_MAX)
346                     break;
347                 comment_level++;
348             }
349         }
350         /* truncate evil unclosed comments */
351         if (comment_level > 0)
352         {
353             char *p = strchr(p_sys->psz_user_agent, '(');
354             *p = '\0';
355         }
356     }
357
358     /* HTTP referrer */
359     p_sys->psz_referrer = var_InheritString( p_access, "http-referrer" );
360
361     /* Check proxy */
362     psz = var_InheritString( p_access, "http-proxy" );
363     if( psz == NULL )
364     {
365         char *url;
366
367         if (likely(asprintf(&url, "%s://%s", psz_access,
368                             p_access->psz_location) != -1))
369         {
370             msg_Dbg(p_access, "querying proxy for %s", url);
371             psz = vlc_getProxyUrl(url);
372             free(url);
373         }
374
375         if (psz != NULL)
376             msg_Dbg(p_access, "proxy: %s", psz);
377         else
378             msg_Dbg(p_access, "no proxy");
379     }
380     if( psz != NULL )
381     {
382         p_sys->b_proxy = true;
383         vlc_UrlParse( &p_sys->proxy, psz, 0 );
384         free( psz );
385
386         psz = var_InheritString( p_access, "http-proxy-pwd" );
387         if( psz )
388             p_sys->proxy.psz_password = p_sys->psz_proxy_passbuf = psz;
389
390         if( p_sys->proxy.psz_host == NULL || *p_sys->proxy.psz_host == '\0' )
391         {
392             msg_Warn( p_access, "invalid proxy host" );
393             goto error;
394         }
395         if( p_sys->proxy.i_port <= 0 )
396         {
397             p_sys->proxy.i_port = 80;
398         }
399     }
400
401     msg_Dbg( p_access, "http: server='%s' port=%d file='%s'",
402              p_sys->url.psz_host, p_sys->url.i_port,
403              p_sys->url.psz_path != NULL ? p_sys->url.psz_path : "" );
404     if( p_sys->b_proxy )
405     {
406         msg_Dbg( p_access, "      proxy %s:%d", p_sys->proxy.psz_host,
407                  p_sys->proxy.i_port );
408     }
409     if( p_sys->url.psz_username && *p_sys->url.psz_username )
410     {
411         msg_Dbg( p_access, "      user='%s'", p_sys->url.psz_username );
412     }
413
414     p_sys->b_reconnect = var_InheritBool( p_access, "http-reconnect" );
415     p_sys->b_continuous = var_InheritBool( p_access, "http-continuous" );
416
417 connect:
418     /* Connect */
419     switch( Connect( p_access, 0 ) )
420     {
421         case -1:
422             goto error;
423
424         case -2:
425             /* Retry with http 1.0 */
426             msg_Dbg( p_access, "switching to HTTP version 1.0" );
427             p_sys->i_version = 0;
428             p_sys->b_seekable = false;
429
430             if( !vlc_object_alive (p_access) || Connect( p_access, 0 ) )
431                 goto error;
432
433         case 0:
434             break;
435
436         default:
437             assert(0);
438     }
439
440     if( p_sys->i_code == 401 )
441     {
442         if( p_sys->auth.psz_realm == NULL )
443         {
444             msg_Err( p_access, "authentication failed without realm" );
445             goto error;
446         }
447         char *psz_login, *psz_password;
448         /* FIXME ? */
449         if( p_sys->url.psz_username && p_sys->url.psz_password &&
450             p_sys->auth.psz_nonce && p_sys->auth.i_nonce == 0 )
451         {
452             Disconnect( p_access );
453             goto connect;
454         }
455         msg_Dbg( p_access, "authentication failed for realm %s",
456                  p_sys->auth.psz_realm );
457         dialog_Login( p_access, &psz_login, &psz_password,
458                       _("HTTP authentication"),
459              _("Please enter a valid login name and a password for realm %s."),
460                       p_sys->auth.psz_realm );
461         if( psz_login != NULL && psz_password != NULL )
462         {
463             msg_Dbg( p_access, "retrying with user=%s", psz_login );
464             p_sys->url.psz_username = psz_login;
465             p_sys->url.psz_password = psz_password;
466             Disconnect( p_access );
467             goto connect;
468         }
469         else
470         {
471             free( psz_login );
472             free( psz_password );
473             goto error;
474         }
475     }
476
477     if( ( p_sys->i_code == 301 || p_sys->i_code == 302 ||
478           p_sys->i_code == 303 || p_sys->i_code == 307 ) &&
479         p_sys->psz_location && *p_sys->psz_location )
480     {
481         msg_Dbg( p_access, "redirection to %s", p_sys->psz_location );
482
483         /* Check the number of redirection already done */
484         if( i_redirect == 0 )
485         {
486             msg_Err( p_access, "Too many redirection: break potential infinite"
487                      "loop" );
488             goto error;
489         }
490
491         const char *psz_protocol;
492         if( !strncmp( p_sys->psz_location, "http://", 7 ) )
493             psz_protocol = "http";
494         else if( !strncmp( p_sys->psz_location, "https://", 8 ) )
495             psz_protocol = "https";
496         else
497         {   /* Do not accept redirection outside of HTTP */
498             msg_Err( p_access, "unsupported redirection ignored" );
499             goto error;
500         }
501         free( p_access->psz_location );
502         p_access->psz_location = strdup( p_sys->psz_location
503                                        + strlen( psz_protocol ) + 3 );
504         /* Clean up current Open() run */
505         vlc_UrlClean( &p_sys->url );
506         http_auth_Reset( &p_sys->auth );
507         vlc_UrlClean( &p_sys->proxy );
508         free( p_sys->psz_proxy_passbuf );
509         http_auth_Reset( &p_sys->proxy_auth );
510         free( p_sys->psz_mime );
511         free( p_sys->psz_pragma );
512         free( p_sys->psz_location );
513         free( p_sys->psz_user_agent );
514         free( p_sys->psz_referrer );
515
516         Disconnect( p_access );
517         vlc_tls_Delete( p_sys->p_creds );
518         cookies = p_sys->cookies;
519 #ifdef HAVE_ZLIB_H
520         inflateEnd( &p_sys->inflate.stream );
521 #endif
522         free( p_sys );
523
524         /* Do new Open() run with new data */
525         return OpenWithCookies( p_this, psz_protocol, i_redirect - 1,
526                                 cookies );
527     }
528
529     if( p_sys->b_mms )
530     {
531         msg_Dbg( p_access, "this is actually a live mms server, BAIL" );
532         goto error;
533     }
534
535     if( !strcmp( p_sys->psz_protocol, "ICY" ) || p_sys->b_icecast )
536     {
537         if( p_sys->psz_mime && strcasecmp( p_sys->psz_mime, "application/ogg" ) )
538         {
539             if( !strcasecmp( p_sys->psz_mime, "video/nsv" ) ||
540                 !strcasecmp( p_sys->psz_mime, "video/nsa" ) )
541             {
542                 free( p_access->psz_demux );
543                 p_access->psz_demux = strdup( "nsv" );
544             }
545             else if( !strcasecmp( p_sys->psz_mime, "audio/aac" ) ||
546                      !strcasecmp( p_sys->psz_mime, "audio/aacp" ) )
547             {
548                 free( p_access->psz_demux );
549                 p_access->psz_demux = strdup( "m4a" );
550             }
551             else if( !strcasecmp( p_sys->psz_mime, "audio/mpeg" ) )
552             {
553                 free( p_access->psz_demux );
554                 p_access->psz_demux = strdup( "mp3" );
555             }
556
557             msg_Info( p_access, "Raw-audio server found, %s demuxer selected",
558                       p_access->psz_demux );
559
560 #if 0       /* Doesn't work really well because of the pre-buffering in
561              * shoutcast servers (the buffer content will be sent as fast as
562              * possible). */
563             p_sys->b_pace_control = false;
564 #endif
565         }
566         else if( !p_sys->psz_mime )
567         {
568             free( p_access->psz_demux );
569             /* Shoutcast */
570             p_access->psz_demux = strdup( "mp3" );
571         }
572         /* else probably Ogg Vorbis */
573     }
574     else if( !strcasecmp( psz_access, "unsv" ) &&
575              p_sys->psz_mime &&
576              !strcasecmp( p_sys->psz_mime, "misc/ultravox" ) )
577     {
578         free( p_access->psz_demux );
579         /* Grrrr! detect ultravox server and force NSV demuxer */
580         p_access->psz_demux = strdup( "nsv" );
581     }
582     else if( !strcmp( psz_access, "itpc" ) )
583     {
584         free( p_access->psz_demux );
585         p_access->psz_demux = strdup( "podcast" );
586     }
587
588     if( p_sys->b_reconnect ) msg_Dbg( p_access, "auto re-connect enabled" );
589
590     return VLC_SUCCESS;
591
592 error:
593     vlc_UrlClean( &p_sys->url );
594     vlc_UrlClean( &p_sys->proxy );
595     free( p_sys->psz_proxy_passbuf );
596     free( p_sys->psz_mime );
597     free( p_sys->psz_pragma );
598     free( p_sys->psz_location );
599     free( p_sys->psz_user_agent );
600     free( p_sys->psz_referrer );
601
602     Disconnect( p_access );
603     vlc_tls_Delete( p_sys->p_creds );
604
605     if( p_sys->cookies )
606     {
607         int i;
608         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
609             free(vlc_array_item_at_index( p_sys->cookies, i ));
610         vlc_array_destroy( p_sys->cookies );
611     }
612
613 #ifdef HAVE_ZLIB_H
614     inflateEnd( &p_sys->inflate.stream );
615 #endif
616     free( p_sys );
617     return VLC_EGENERIC;
618 }
619
620 /*****************************************************************************
621  * Close:
622  *****************************************************************************/
623 static void Close( vlc_object_t *p_this )
624 {
625     access_t     *p_access = (access_t*)p_this;
626     access_sys_t *p_sys = p_access->p_sys;
627
628     vlc_UrlClean( &p_sys->url );
629     http_auth_Reset( &p_sys->auth );
630     vlc_UrlClean( &p_sys->proxy );
631     http_auth_Reset( &p_sys->proxy_auth );
632
633     free( p_sys->psz_mime );
634     free( p_sys->psz_pragma );
635     free( p_sys->psz_location );
636
637     free( p_sys->psz_icy_name );
638     free( p_sys->psz_icy_genre );
639     free( p_sys->psz_icy_title );
640
641     free( p_sys->psz_user_agent );
642     free( p_sys->psz_referrer );
643
644     Disconnect( p_access );
645     vlc_tls_Delete( p_sys->p_creds );
646
647     if( p_sys->cookies )
648     {
649         int i;
650         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
651             free(vlc_array_item_at_index( p_sys->cookies, i ));
652         vlc_array_destroy( p_sys->cookies );
653     }
654
655 #ifdef HAVE_ZLIB_H
656     inflateEnd( &p_sys->inflate.stream );
657     free( p_sys->inflate.p_buffer );
658 #endif
659
660     free( p_sys );
661 }
662
663 /* Read data from the socket taking care of chunked transfer if needed */
664 static int ReadData( access_t *p_access, int *pi_read,
665                      uint8_t *p_buffer, size_t i_len )
666 {
667     access_sys_t *p_sys = p_access->p_sys;
668     if( p_sys->b_chunked )
669     {
670         if( p_sys->i_chunk < 0 )
671             return VLC_EGENERIC;
672
673         if( p_sys->i_chunk <= 0 )
674         {
675             char *psz = net_Gets( p_access, p_sys->fd, p_sys->p_vs );
676             /* read the chunk header */
677             if( psz == NULL )
678             {
679                 /* fatal error - end of file */
680                 msg_Dbg( p_access, "failed reading chunk-header line" );
681                 return VLC_EGENERIC;
682             }
683             p_sys->i_chunk = strtoll( psz, NULL, 16 );
684             free( psz );
685
686             if( p_sys->i_chunk <= 0 )   /* eof */
687             {
688                 p_sys->i_chunk = -1;
689                 return VLC_EGENERIC;
690             }
691         }
692
693         if( i_len > p_sys->i_chunk )
694             i_len = p_sys->i_chunk;
695     }
696     *pi_read = net_Read( p_access, p_sys->fd, p_sys->p_vs, p_buffer, i_len, false );
697     if( *pi_read <= 0 )
698         return VLC_SUCCESS;
699
700     if( p_sys->b_chunked )
701     {
702         p_sys->i_chunk -= *pi_read;
703         if( p_sys->i_chunk <= 0 )
704         {
705             /* read the empty line */
706             char *psz = net_Gets( p_access, p_sys->fd, p_sys->p_vs );
707             free( psz );
708         }
709     }
710     return VLC_SUCCESS;
711 }
712
713 /*****************************************************************************
714  * Read: Read up to i_len bytes from the http connection and place in
715  * p_buffer. Return the actual number of bytes read
716  *****************************************************************************/
717 static int ReadICYMeta( access_t *p_access );
718 static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
719 {
720     access_sys_t *p_sys = p_access->p_sys;
721     int i_read;
722
723     if( p_sys->fd == -1 )
724         goto fatal;
725
726     if( p_sys->b_has_size )
727     {
728         /* Remaining bytes in the file */
729         uint64_t remainder = p_sys->size - p_access->info.i_pos;
730         if( remainder < i_len )
731             i_len = remainder;
732
733         /* Remaining bytes in the response */
734         if( p_sys->i_remaining < i_len )
735             i_len = p_sys->i_remaining;
736     }
737     if( i_len == 0 )
738         goto fatal;
739
740     if( p_sys->i_icy_meta > 0 && p_access->info.i_pos - p_sys->i_icy_offset > 0 )
741     {
742         int64_t i_next = p_sys->i_icy_meta -
743                                     (p_access->info.i_pos - p_sys->i_icy_offset ) % p_sys->i_icy_meta;
744
745         if( i_next == p_sys->i_icy_meta )
746         {
747             if( ReadICYMeta( p_access ) )
748                 goto fatal;
749         }
750         if( i_len > i_next )
751             i_len = i_next;
752     }
753
754     if( ReadData( p_access, &i_read, p_buffer, i_len ) )
755         goto fatal;
756
757     if( i_read <= 0 )
758     {
759         /*
760          * I very much doubt that this will work.
761          * If i_read == 0, the connection *IS* dead, so the only
762          * sensible thing to do is Disconnect() and then retry.
763          * Otherwise, I got recv() completely wrong. -- Courmisch
764          */
765         if( p_sys->b_continuous )
766         {
767             Request( p_access, 0 );
768             p_sys->b_continuous = false;
769             i_read = Read( p_access, p_buffer, i_len );
770             p_sys->b_continuous = true;
771         }
772         Disconnect( p_access );
773         if( p_sys->b_reconnect && vlc_object_alive( p_access ) )
774         {
775             msg_Dbg( p_access, "got disconnected, trying to reconnect" );
776             if( Connect( p_access, p_access->info.i_pos ) )
777             {
778                 msg_Dbg( p_access, "reconnection failed" );
779             }
780             else
781             {
782                 p_sys->b_reconnect = false;
783                 i_read = Read( p_access, p_buffer, i_len );
784                 p_sys->b_reconnect = true;
785
786                 return i_read;
787             }
788         }
789
790         if( i_read <= 0 )
791         {
792             if( i_read < 0 )
793                 p_sys->b_error = true;
794             goto fatal;
795         }
796     }
797
798     assert( i_read >= 0 );
799     p_access->info.i_pos += i_read;
800     if( p_sys->b_has_size )
801     {
802         assert( p_access->info.i_pos <= p_sys->size );
803         assert( (unsigned)i_read <= p_sys->i_remaining );
804         p_sys->i_remaining -= i_read;
805     }
806
807     return i_read;
808
809 fatal:
810     p_access->info.b_eof = true;
811     return 0;
812 }
813
814 static int ReadICYMeta( access_t *p_access )
815 {
816     access_sys_t *p_sys = p_access->p_sys;
817
818     uint8_t buffer;
819     char *p, *psz_meta;
820     int i_read;
821
822     /* Read meta data length */
823     if( ReadData( p_access, &i_read, &buffer, 1 ) )
824         return VLC_EGENERIC;
825     if( i_read != 1 )
826         return VLC_EGENERIC;
827     const int i_size = buffer << 4;
828     /* msg_Dbg( p_access, "ICY meta size=%u", i_size); */
829
830     psz_meta = malloc( i_size + 1 );
831     for( i_read = 0; i_read < i_size; )
832     {
833         int i_tmp;
834         if( ReadData( p_access, &i_tmp, (uint8_t *)&psz_meta[i_read], i_size - i_read ) || i_tmp <= 0 )
835         {
836             free( psz_meta );
837             return VLC_EGENERIC;
838         }
839         i_read += i_tmp;
840     }
841     psz_meta[i_read] = '\0'; /* Just in case */
842
843     /* msg_Dbg( p_access, "icy-meta=%s", psz_meta ); */
844
845     /* Now parse the meta */
846     /* Look for StreamTitle= */
847     p = strcasestr( (char *)psz_meta, "StreamTitle=" );
848     if( p )
849     {
850         p += strlen( "StreamTitle=" );
851         if( *p == '\'' || *p == '"' )
852         {
853             char closing[] = { p[0], ';', '\0' };
854             char *psz = strstr( &p[1], closing );
855             if( !psz )
856                 psz = strchr( &p[1], ';' );
857
858             if( psz ) *psz = '\0';
859         }
860         else
861         {
862             char *psz = strchr( &p[1], ';' );
863             if( psz ) *psz = '\0';
864         }
865
866         if( !p_sys->psz_icy_title ||
867             strcmp( p_sys->psz_icy_title, &p[1] ) )
868         {
869             free( p_sys->psz_icy_title );
870             char *psz_tmp = strdup( &p[1] );
871             p_sys->psz_icy_title = EnsureUTF8( psz_tmp );
872             if( !p_sys->psz_icy_title )
873                 free( psz_tmp );
874             //p_access->info.i_update |= INPUT_UPDATE_META; FIXME
875
876             msg_Dbg( p_access, "New Title=%s", p_sys->psz_icy_title );
877         }
878     }
879     free( psz_meta );
880
881     return VLC_SUCCESS;
882 }
883
884 #ifdef HAVE_ZLIB_H
885 static ssize_t ReadCompressed( access_t *p_access, uint8_t *p_buffer,
886                                size_t i_len )
887 {
888     access_sys_t *p_sys = p_access->p_sys;
889
890     if( p_sys->b_compressed )
891     {
892         int i_ret;
893
894         if( !p_sys->inflate.p_buffer )
895             p_sys->inflate.p_buffer = malloc( 256 * 1024 );
896
897         if( p_sys->inflate.stream.avail_in == 0 )
898         {
899             ssize_t i_read = Read( p_access, p_sys->inflate.p_buffer, 256 * 1024 );
900             if( i_read <= 0 ) return i_read;
901             p_sys->inflate.stream.next_in = p_sys->inflate.p_buffer;
902             p_sys->inflate.stream.avail_in = i_read;
903         }
904
905         p_sys->inflate.stream.avail_out = i_len;
906         p_sys->inflate.stream.next_out = p_buffer;
907
908         i_ret = inflate( &p_sys->inflate.stream, Z_SYNC_FLUSH );
909         if ( i_ret != Z_OK && i_ret != Z_STREAM_END )
910             msg_Warn( p_access, "inflate return value: %d, %s", i_ret, p_sys->inflate.stream.msg );
911
912         return i_len - p_sys->inflate.stream.avail_out;
913     }
914     else
915     {
916         return Read( p_access, p_buffer, i_len );
917     }
918 }
919 #endif
920
921 /*****************************************************************************
922  * Seek: close and re-open a connection at the right place
923  *****************************************************************************/
924 static int Seek( access_t *p_access, uint64_t i_pos )
925 {
926     access_sys_t *p_sys = p_access->p_sys;
927
928     msg_Dbg( p_access, "trying to seek to %"PRId64, i_pos );
929     Disconnect( p_access );
930
931     if( p_sys->size && i_pos >= p_sys->size )
932     {
933         msg_Err( p_access, "seek too far" );
934         int retval = Seek( p_access, p_sys->size - 1 );
935         if( retval == VLC_SUCCESS ) {
936             uint8_t p_buffer[2];
937             Read( p_access, p_buffer, 1);
938             p_access->info.b_eof  = false;
939         }
940         return retval;
941     }
942     if( Connect( p_access, i_pos ) )
943     {
944         msg_Err( p_access, "seek failed" );
945         p_access->info.b_eof = true;
946         return VLC_EGENERIC;
947     }
948     return VLC_SUCCESS;
949 }
950
951 /*****************************************************************************
952  * Control:
953  *****************************************************************************/
954 static int Control( access_t *p_access, int i_query, va_list args )
955 {
956     access_sys_t *p_sys = p_access->p_sys;
957     bool       *pb_bool;
958     int64_t    *pi_64;
959     vlc_meta_t *p_meta;
960
961     switch( i_query )
962     {
963         /* */
964         case ACCESS_CAN_SEEK:
965             pb_bool = (bool*)va_arg( args, bool* );
966             *pb_bool = p_sys->b_seekable;
967             break;
968         case ACCESS_CAN_FASTSEEK:
969             pb_bool = (bool*)va_arg( args, bool* );
970             *pb_bool = false;
971             break;
972         case ACCESS_CAN_PAUSE:
973         case ACCESS_CAN_CONTROL_PACE:
974             pb_bool = (bool*)va_arg( args, bool* );
975
976 #if 0       /* Disable for now until we have a clock synchro algo
977              * which works with something else than MPEG over UDP */
978             *pb_bool = p_sys->b_pace_control;
979 #endif
980             *pb_bool = true;
981             break;
982
983         /* */
984         case ACCESS_GET_PTS_DELAY:
985             pi_64 = (int64_t*)va_arg( args, int64_t * );
986             *pi_64 = INT64_C(1000)
987                 * var_InheritInteger( p_access, "network-caching" );
988             break;
989
990         case ACCESS_GET_SIZE:
991             pi_64 = (int64_t*)va_arg( args, int64_t * );
992             *pi_64 = p_sys->size;
993            break;
994
995         /* */
996         case ACCESS_SET_PAUSE_STATE:
997             break;
998
999         case ACCESS_GET_META:
1000             p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
1001
1002             if( p_sys->psz_icy_name )
1003                 vlc_meta_Set( p_meta, vlc_meta_Title, p_sys->psz_icy_name );
1004             if( p_sys->psz_icy_genre )
1005                 vlc_meta_Set( p_meta, vlc_meta_Genre, p_sys->psz_icy_genre );
1006             if( p_sys->psz_icy_title )
1007                 vlc_meta_Set( p_meta, vlc_meta_NowPlaying, p_sys->psz_icy_title );
1008             break;
1009
1010         case ACCESS_GET_CONTENT_TYPE:
1011             *va_arg( args, char ** ) =
1012                 p_sys->psz_mime ? strdup( p_sys->psz_mime ) : NULL;
1013             break;
1014
1015         default:
1016             return VLC_EGENERIC;
1017
1018     }
1019     return VLC_SUCCESS;
1020 }
1021
1022 /*****************************************************************************
1023  * Connect:
1024  *****************************************************************************/
1025 static int Connect( access_t *p_access, uint64_t i_tell )
1026 {
1027     access_sys_t   *p_sys = p_access->p_sys;
1028     vlc_url_t      srv = p_sys->b_proxy ? p_sys->proxy : p_sys->url;
1029
1030     /* Clean info */
1031     free( p_sys->psz_location );
1032     free( p_sys->psz_mime );
1033     free( p_sys->psz_pragma );
1034
1035     free( p_sys->psz_icy_genre );
1036     free( p_sys->psz_icy_name );
1037     free( p_sys->psz_icy_title );
1038
1039
1040     p_sys->psz_location = NULL;
1041     p_sys->psz_mime = NULL;
1042     p_sys->psz_pragma = NULL;
1043     p_sys->b_mms = false;
1044     p_sys->b_chunked = false;
1045     p_sys->i_chunk = 0;
1046     p_sys->i_icy_meta = 0;
1047     p_sys->i_icy_offset = i_tell;
1048     p_sys->psz_icy_name = NULL;
1049     p_sys->psz_icy_genre = NULL;
1050     p_sys->psz_icy_title = NULL;
1051     p_sys->i_remaining = 0;
1052     p_sys->b_persist = false;
1053     p_sys->b_has_size = false;
1054     p_sys->size = 0;
1055     p_access->info.i_pos  = i_tell;
1056     p_access->info.b_eof  = false;
1057
1058     /* Open connection */
1059     assert( p_sys->fd == -1 ); /* No open sockets (leaking fds is BAD) */
1060     p_sys->fd = net_ConnectTCP( p_access, srv.psz_host, srv.i_port );
1061     if( p_sys->fd == -1 )
1062     {
1063         msg_Err( p_access, "cannot connect to %s:%d", srv.psz_host, srv.i_port );
1064         return -1;
1065     }
1066     setsockopt (p_sys->fd, SOL_SOCKET, SO_KEEPALIVE, &(int){ 1 }, sizeof (int));
1067
1068     /* Initialize TLS/SSL session */
1069     if( p_sys->p_creds != NULL )
1070     {
1071         /* CONNECT to establish TLS tunnel through HTTP proxy */
1072         if( p_sys->b_proxy )
1073         {
1074             char *psz;
1075             unsigned i_status = 0;
1076
1077             if( p_sys->i_version == 0 )
1078             {
1079                 /* CONNECT is not in HTTP/1.0 */
1080                 Disconnect( p_access );
1081                 return -1;
1082             }
1083
1084             net_Printf( p_access, p_sys->fd, NULL,
1085                         "CONNECT %s:%d HTTP/1.%d\r\nHost: %s:%d\r\n\r\n",
1086                         p_sys->url.psz_host, p_sys->url.i_port,
1087                         p_sys->i_version,
1088                         p_sys->url.psz_host, p_sys->url.i_port);
1089
1090             psz = net_Gets( p_access, p_sys->fd, NULL );
1091             if( psz == NULL )
1092             {
1093                 msg_Err( p_access, "cannot establish HTTP/TLS tunnel" );
1094                 Disconnect( p_access );
1095                 return -1;
1096             }
1097
1098             sscanf( psz, "HTTP/%*u.%*u %3u", &i_status );
1099             free( psz );
1100
1101             if( ( i_status / 100 ) != 2 )
1102             {
1103                 msg_Err( p_access, "HTTP/TLS tunnel through proxy denied" );
1104                 Disconnect( p_access );
1105                 return -1;
1106             }
1107
1108             do
1109             {
1110                 psz = net_Gets( p_access, p_sys->fd, NULL );
1111                 if( psz == NULL )
1112                 {
1113                     msg_Err( p_access, "HTTP proxy connection failed" );
1114                     Disconnect( p_access );
1115                     return -1;
1116                 }
1117
1118                 if( *psz == '\0' )
1119                     i_status = 0;
1120
1121                 free( psz );
1122
1123                 if( !vlc_object_alive (p_access) || p_sys->b_error )
1124                 {
1125                     Disconnect( p_access );
1126                     return -1;
1127                 }
1128             }
1129             while( i_status );
1130         }
1131
1132         /* TLS/SSL handshake */
1133         p_sys->p_tls = vlc_tls_ClientSessionCreate( p_sys->p_creds, p_sys->fd,
1134                                                 p_sys->url.psz_host, "https" );
1135         if( p_sys->p_tls == NULL )
1136         {
1137             msg_Err( p_access, "cannot establish HTTP/TLS session" );
1138             Disconnect( p_access );
1139             return -1;
1140         }
1141         p_sys->p_vs = &p_sys->p_tls->sock;
1142     }
1143
1144     return Request( p_access, i_tell ) ? -2 : 0;
1145 }
1146
1147
1148 static int Request( access_t *p_access, uint64_t i_tell )
1149 {
1150     access_sys_t   *p_sys = p_access->p_sys;
1151     char           *psz ;
1152     v_socket_t     *pvs = p_sys->p_vs;
1153     p_sys->b_persist = false;
1154
1155     p_sys->i_remaining = 0;
1156
1157     const char *psz_path = p_sys->url.psz_path;
1158     if( !psz_path || !*psz_path )
1159         psz_path = "/";
1160     if( p_sys->b_proxy && pvs == NULL )
1161         net_Printf( p_access, p_sys->fd, NULL,
1162                     "GET http://%s:%d%s HTTP/1.%d\r\n",
1163                     p_sys->url.psz_host, p_sys->url.i_port,
1164                     psz_path, p_sys->i_version );
1165     else
1166         net_Printf( p_access, p_sys->fd, pvs, "GET %s HTTP/1.%d\r\n",
1167                     psz_path, p_sys->i_version );
1168     if( p_sys->url.i_port != (pvs ? 443 : 80) )
1169         net_Printf( p_access, p_sys->fd, pvs, "Host: %s:%d\r\n",
1170                     p_sys->url.psz_host, p_sys->url.i_port );
1171     else
1172         net_Printf( p_access, p_sys->fd, pvs, "Host: %s\r\n",
1173                     p_sys->url.psz_host );
1174     /* User Agent */
1175     net_Printf( p_access, p_sys->fd, pvs, "User-Agent: %s\r\n",
1176                 p_sys->psz_user_agent );
1177     /* Referrer */
1178     if (p_sys->psz_referrer)
1179     {
1180         net_Printf( p_access, p_sys->fd, pvs, "Referer: %s\r\n",
1181                     p_sys->psz_referrer);
1182     }
1183     /* Offset */
1184     if( p_sys->i_version == 1 && ! p_sys->b_continuous )
1185     {
1186         p_sys->b_persist = true;
1187         net_Printf( p_access, p_sys->fd, pvs,
1188                     "Range: bytes=%"PRIu64"-\r\n", i_tell );
1189         net_Printf( p_access, p_sys->fd, pvs, "Connection: close\r\n" );
1190     }
1191
1192     /* Cookies */
1193     if( p_sys->cookies )
1194     {
1195         int i;
1196         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
1197         {
1198             const char * cookie = vlc_array_item_at_index( p_sys->cookies, i );
1199             char * psz_cookie_content = cookie_get_content( cookie );
1200             char * psz_cookie_domain = cookie_get_domain( cookie );
1201
1202             assert( psz_cookie_content );
1203
1204             /* FIXME: This is clearly not conforming to the rfc */
1205             bool is_in_right_domain = (!psz_cookie_domain || strstr( p_sys->url.psz_host, psz_cookie_domain ));
1206
1207             if( is_in_right_domain )
1208             {
1209                 msg_Dbg( p_access, "Sending Cookie %s", psz_cookie_content );
1210                 if( net_Printf( p_access, p_sys->fd, pvs, "Cookie: %s\r\n", psz_cookie_content ) < 0 )
1211                     msg_Err( p_access, "failed to send Cookie" );
1212             }
1213             free( psz_cookie_content );
1214             free( psz_cookie_domain );
1215         }
1216     }
1217
1218     /* Authentication */
1219     if( p_sys->url.psz_username && p_sys->url.psz_password )
1220         AuthReply( p_access, "", &p_sys->url, &p_sys->auth );
1221
1222     /* Proxy Authentication */
1223     if( p_sys->proxy.psz_username && p_sys->proxy.psz_password )
1224         AuthReply( p_access, "Proxy-", &p_sys->proxy, &p_sys->proxy_auth );
1225
1226     /* ICY meta data request */
1227     net_Printf( p_access, p_sys->fd, pvs, "Icy-MetaData: 1\r\n" );
1228
1229
1230     if( net_Printf( p_access, p_sys->fd, pvs, "\r\n" ) < 0 )
1231     {
1232         msg_Err( p_access, "failed to send request" );
1233         Disconnect( p_access );
1234         return VLC_EGENERIC;
1235     }
1236
1237     /* Read Answer */
1238     if( ( psz = net_Gets( p_access, p_sys->fd, pvs ) ) == NULL )
1239     {
1240         msg_Err( p_access, "failed to read answer" );
1241         goto error;
1242     }
1243     if( !strncmp( psz, "HTTP/1.", 7 ) )
1244     {
1245         p_sys->psz_protocol = "HTTP";
1246         p_sys->i_code = atoi( &psz[9] );
1247     }
1248     else if( !strncmp( psz, "ICY", 3 ) )
1249     {
1250         p_sys->psz_protocol = "ICY";
1251         p_sys->i_code = atoi( &psz[4] );
1252         p_sys->b_reconnect = true;
1253     }
1254     else
1255     {
1256         msg_Err( p_access, "invalid HTTP reply '%s'", psz );
1257         free( psz );
1258         goto error;
1259     }
1260     msg_Dbg( p_access, "protocol '%s' answer code %d",
1261              p_sys->psz_protocol, p_sys->i_code );
1262     if( !strcmp( p_sys->psz_protocol, "ICY" ) )
1263     {
1264         p_sys->b_seekable = false;
1265     }
1266     if( p_sys->i_code != 206 && p_sys->i_code != 401 )
1267     {
1268         p_sys->b_seekable = false;
1269     }
1270     /* Authentication error - We'll have to display the dialog */
1271     if( p_sys->i_code == 401 )
1272     {
1273
1274     }
1275     /* Other fatal error */
1276     else if( p_sys->i_code >= 400 )
1277     {
1278         msg_Err( p_access, "error: %s", psz );
1279         free( psz );
1280         goto error;
1281     }
1282     free( psz );
1283
1284     for( ;; )
1285     {
1286         char *psz = net_Gets( p_access, p_sys->fd, pvs );
1287         char *p;
1288         char *p_trailing;
1289
1290         if( psz == NULL )
1291         {
1292             msg_Err( p_access, "failed to read answer" );
1293             goto error;
1294         }
1295
1296         if( !vlc_object_alive (p_access) || p_sys->b_error )
1297         {
1298             free( psz );
1299             goto error;
1300         }
1301
1302         /* msg_Dbg( p_input, "Line=%s", psz ); */
1303         if( *psz == '\0' )
1304         {
1305             free( psz );
1306             break;
1307         }
1308
1309         if( ( p = strchr( psz, ':' ) ) == NULL )
1310         {
1311             msg_Err( p_access, "malformed header line: %s", psz );
1312             free( psz );
1313             goto error;
1314         }
1315         *p++ = '\0';
1316         p += strspn( p, " \t" );
1317
1318         /* trim trailing white space */
1319         p_trailing = p + strlen( p );
1320         if( p_trailing > p )
1321         {
1322             p_trailing--;
1323             while( ( *p_trailing == ' ' || *p_trailing == '\t' ) && p_trailing > p )
1324             {
1325                 *p_trailing = '\0';
1326                 p_trailing--;
1327             }
1328         }
1329
1330         if( !strcasecmp( psz, "Content-Length" ) )
1331         {
1332             uint64_t i_size = i_tell + (p_sys->i_remaining = (uint64_t)atoll( p ));
1333             if(i_size > p_sys->size) {
1334                 p_sys->b_has_size = true;
1335                 p_sys->size = i_size;
1336             }
1337             msg_Dbg( p_access, "this frame size=%"PRIu64, p_sys->i_remaining );
1338         }
1339         else if( !strcasecmp( psz, "Content-Range" ) ) {
1340             uint64_t i_ntell = i_tell;
1341             uint64_t i_nend = (p_sys->size > 0) ? (p_sys->size - 1) : i_tell;
1342             uint64_t i_nsize = p_sys->size;
1343             sscanf(p,"bytes %"SCNu64"-%"SCNu64"/%"SCNu64,&i_ntell,&i_nend,&i_nsize);
1344             if(i_nend > i_ntell ) {
1345                 p_access->info.i_pos = i_ntell;
1346                 p_sys->i_icy_offset  = i_ntell;
1347                 p_sys->i_remaining = i_nend+1-i_ntell;
1348                 uint64_t i_size = (i_nsize > i_nend) ? i_nsize : (i_nend + 1);
1349                 if(i_size > p_sys->size) {
1350                     p_sys->b_has_size = true;
1351                     p_sys->size = i_size;
1352                 }
1353                 msg_Dbg( p_access, "stream size=%"PRIu64",pos=%"PRIu64",remaining=%"PRIu64,
1354                          i_nsize, i_ntell, p_sys->i_remaining);
1355             }
1356         }
1357         else if( !strcasecmp( psz, "Connection" ) ) {
1358             msg_Dbg( p_access, "Connection: %s",p );
1359             int i = -1;
1360             sscanf(p, "close%n",&i);
1361             if( i >= 0 ) {
1362                 p_sys->b_persist = false;
1363             }
1364         }
1365         else if( !strcasecmp( psz, "Location" ) )
1366         {
1367             char * psz_new_loc;
1368
1369             /* This does not follow RFC 2068, but yet if the url is not absolute,
1370              * handle it as everyone does. */
1371             if( p[0] == '/' )
1372             {
1373                 const char *psz_http_ext = p_sys->p_tls ? "s" : "" ;
1374
1375                 if( p_sys->url.i_port == ( p_sys->p_tls ? 443 : 80 ) )
1376                 {
1377                     if( asprintf(&psz_new_loc, "http%s://%s%s", psz_http_ext,
1378                                  p_sys->url.psz_host, p) < 0 )
1379                         goto error;
1380                 }
1381                 else
1382                 {
1383                     if( asprintf(&psz_new_loc, "http%s://%s:%d%s", psz_http_ext,
1384                                  p_sys->url.psz_host, p_sys->url.i_port, p) < 0 )
1385                         goto error;
1386                 }
1387             }
1388             else
1389             {
1390                 psz_new_loc = strdup( p );
1391             }
1392
1393             free( p_sys->psz_location );
1394             p_sys->psz_location = psz_new_loc;
1395         }
1396         else if( !strcasecmp( psz, "Content-Type" ) )
1397         {
1398             free( p_sys->psz_mime );
1399             p_sys->psz_mime = strdup( p );
1400             msg_Dbg( p_access, "Content-Type: %s", p_sys->psz_mime );
1401         }
1402         else if( !strcasecmp( psz, "Content-Encoding" ) )
1403         {
1404             msg_Dbg( p_access, "Content-Encoding: %s", p );
1405             if( !strcasecmp( p, "identity" ) )
1406                 ;
1407 #ifdef HAVE_ZLIB_H
1408             else if( !strcasecmp( p, "gzip" ) || !strcasecmp( p, "deflate" ) )
1409                 p_sys->b_compressed = true;
1410 #endif
1411             else
1412                 msg_Warn( p_access, "Unknown content coding: %s", p );
1413         }
1414         else if( !strcasecmp( psz, "Pragma" ) )
1415         {
1416             if( !strcasecmp( psz, "Pragma: features" ) )
1417                 p_sys->b_mms = true;
1418             free( p_sys->psz_pragma );
1419             p_sys->psz_pragma = strdup( p );
1420             msg_Dbg( p_access, "Pragma: %s", p_sys->psz_pragma );
1421         }
1422         else if( !strcasecmp( psz, "Server" ) )
1423         {
1424             msg_Dbg( p_access, "Server: %s", p );
1425             if( !strncasecmp( p, "Icecast", 7 ) ||
1426                 !strncasecmp( p, "Nanocaster", 10 ) )
1427             {
1428                 /* Remember if this is Icecast
1429                  * we need to force demux in this case without breaking
1430                  *  autodetection */
1431
1432                 /* Let live 365 streams (nanocaster) piggyback on the icecast
1433                  * routine. They look very similar */
1434
1435                 p_sys->b_reconnect = true;
1436                 p_sys->b_pace_control = false;
1437                 p_sys->b_icecast = true;
1438             }
1439         }
1440         else if( !strcasecmp( psz, "Transfer-Encoding" ) )
1441         {
1442             msg_Dbg( p_access, "Transfer-Encoding: %s", p );
1443             if( !strncasecmp( p, "chunked", 7 ) )
1444             {
1445                 p_sys->b_chunked = true;
1446             }
1447         }
1448         else if( !strcasecmp( psz, "Icy-MetaInt" ) )
1449         {
1450             msg_Dbg( p_access, "Icy-MetaInt: %s", p );
1451             p_sys->i_icy_meta = atoi( p );
1452             if( p_sys->i_icy_meta < 0 )
1453                 p_sys->i_icy_meta = 0;
1454             if( p_sys->i_icy_meta > 0 )
1455                 p_sys->b_icecast = true;
1456
1457             msg_Warn( p_access, "ICY metaint=%d", p_sys->i_icy_meta );
1458         }
1459         else if( !strcasecmp( psz, "Icy-Name" ) )
1460         {
1461             free( p_sys->psz_icy_name );
1462             char *psz_tmp = strdup( p );
1463             p_sys->psz_icy_name = EnsureUTF8( psz_tmp );
1464             if( !p_sys->psz_icy_name )
1465                 free( psz_tmp );
1466             msg_Dbg( p_access, "Icy-Name: %s", p_sys->psz_icy_name );
1467
1468             p_sys->b_icecast = true; /* be on the safeside. set it here as well. */
1469             p_sys->b_reconnect = true;
1470             p_sys->b_pace_control = false;
1471         }
1472         else if( !strcasecmp( psz, "Icy-Genre" ) )
1473         {
1474             free( p_sys->psz_icy_genre );
1475             char *psz_tmp = strdup( p );
1476             p_sys->psz_icy_genre = EnsureUTF8( psz_tmp );
1477             if( !p_sys->psz_icy_genre )
1478                 free( psz_tmp );
1479             msg_Dbg( p_access, "Icy-Genre: %s", p_sys->psz_icy_genre );
1480         }
1481         else if( !strncasecmp( psz, "Icy-Notice", 10 ) )
1482         {
1483             msg_Dbg( p_access, "Icy-Notice: %s", p );
1484         }
1485         else if( !strncasecmp( psz, "icy-", 4 ) ||
1486                  !strncasecmp( psz, "ice-", 4 ) ||
1487                  !strncasecmp( psz, "x-audiocast", 11 ) )
1488         {
1489             msg_Dbg( p_access, "Meta-Info: %s: %s", psz, p );
1490         }
1491         else if( !strcasecmp( psz, "Set-Cookie" ) )
1492         {
1493             if( p_sys->cookies )
1494             {
1495                 msg_Dbg( p_access, "Accepting Cookie: %s", p );
1496                 cookie_append( p_sys->cookies, strdup(p) );
1497             }
1498             else
1499                 msg_Dbg( p_access, "We have a Cookie we won't remember: %s", p );
1500         }
1501         else if( !strcasecmp( psz, "www-authenticate" ) )
1502         {
1503             msg_Dbg( p_access, "Authentication header: %s", p );
1504             http_auth_ParseWwwAuthenticateHeader( VLC_OBJECT(p_access),
1505                                                   &p_sys->auth, p );
1506         }
1507         else if( !strcasecmp( psz, "proxy-authenticate" ) )
1508         {
1509             msg_Dbg( p_access, "Proxy authentication header: %s", p );
1510             http_auth_ParseWwwAuthenticateHeader( VLC_OBJECT(p_access),
1511                                                   &p_sys->proxy_auth, p );
1512         }
1513         else if( !strcasecmp( psz, "authentication-info" ) )
1514         {
1515             msg_Dbg( p_access, "Authentication Info header: %s", p );
1516             if( AuthCheckReply( p_access, p, &p_sys->url, &p_sys->auth ) )
1517                 goto error;
1518         }
1519         else if( !strcasecmp( psz, "proxy-authentication-info" ) )
1520         {
1521             msg_Dbg( p_access, "Proxy Authentication Info header: %s", p );
1522             if( AuthCheckReply( p_access, p, &p_sys->proxy, &p_sys->proxy_auth ) )
1523                 goto error;
1524         }
1525         else if( !strcasecmp( psz, "Accept-Ranges" ) )
1526         {
1527             if( !strcasecmp( p, "bytes" ) )
1528                 p_sys->b_seekable = true;
1529         }
1530
1531         free( psz );
1532     }
1533     /* We close the stream for zero length data, unless of course the
1534      * server has already promised to do this for us.
1535      */
1536     if( p_sys->b_has_size && p_sys->i_remaining == 0 && p_sys->b_persist ) {
1537         Disconnect( p_access );
1538     }
1539     return VLC_SUCCESS;
1540
1541 error:
1542     Disconnect( p_access );
1543     return VLC_EGENERIC;
1544 }
1545
1546 /*****************************************************************************
1547  * Disconnect:
1548  *****************************************************************************/
1549 static void Disconnect( access_t *p_access )
1550 {
1551     access_sys_t *p_sys = p_access->p_sys;
1552
1553     if( p_sys->p_tls != NULL)
1554     {
1555         vlc_tls_SessionDelete( p_sys->p_tls );
1556         p_sys->p_tls = NULL;
1557         p_sys->p_vs = NULL;
1558     }
1559     if( p_sys->fd != -1)
1560     {
1561         net_Close(p_sys->fd);
1562         p_sys->fd = -1;
1563     }
1564
1565 }
1566
1567 /*****************************************************************************
1568  * Cookies (FIXME: we may want to rewrite that using a nice structure to hold
1569  * them) (FIXME: only support the "domain=" param)
1570  *****************************************************************************/
1571
1572 /* Get the NAME=VALUE part of the Cookie */
1573 static char * cookie_get_content( const char * cookie )
1574 {
1575     char * ret = strdup( cookie );
1576     if( !ret ) return NULL;
1577     char * str = ret;
1578     /* Look for a ';' */
1579     while( *str && *str != ';' ) str++;
1580     /* Replace it by a end-char */
1581     if( *str == ';' ) *str = 0;
1582     return ret;
1583 }
1584
1585 /* Get the domain where the cookie is stored */
1586 static char * cookie_get_domain( const char * cookie )
1587 {
1588     const char * str = cookie;
1589     static const char domain[] = "domain=";
1590     if( !str )
1591         return NULL;
1592     /* Look for a ';' */
1593     while( *str )
1594     {
1595         if( !strncmp( str, domain, sizeof(domain) - 1 /* minus \0 */ ) )
1596         {
1597             str += sizeof(domain) - 1 /* minus \0 */;
1598             char * ret = strdup( str );
1599             /* Now remove the next ';' if present */
1600             char * ret_iter = ret;
1601             while( *ret_iter && *ret_iter != ';' ) ret_iter++;
1602             if( *ret_iter == ';' )
1603                 *ret_iter = 0;
1604             return ret;
1605         }
1606         /* Go to next ';' field */
1607         while( *str && *str != ';' ) str++;
1608         if( *str == ';' ) str++;
1609         /* skip blank */
1610         while( *str && *str == ' ' ) str++;
1611     }
1612     return NULL;
1613 }
1614
1615 /* Get NAME in the NAME=VALUE field */
1616 static char * cookie_get_name( const char * cookie )
1617 {
1618     char * ret = cookie_get_content( cookie ); /* NAME=VALUE */
1619     if( !ret ) return NULL;
1620     char * str = ret;
1621     while( *str && *str != '=' ) str++;
1622     *str = 0;
1623     return ret;
1624 }
1625
1626 /* Add a cookie in cookies, checking to see how it should be added */
1627 static void cookie_append( vlc_array_t * cookies, char * cookie )
1628 {
1629     int i;
1630
1631     if( !cookie )
1632         return;
1633
1634     char * cookie_name = cookie_get_name( cookie );
1635
1636     /* Don't send invalid cookies */
1637     if( !cookie_name )
1638         return;
1639
1640     char * cookie_domain = cookie_get_domain( cookie );
1641     for( i = 0; i < vlc_array_count( cookies ); i++ )
1642     {
1643         char * current_cookie = vlc_array_item_at_index( cookies, i );
1644         char * current_cookie_name = cookie_get_name( current_cookie );
1645         char * current_cookie_domain = cookie_get_domain( current_cookie );
1646
1647         assert( current_cookie_name );
1648
1649         bool is_domain_matching = (
1650                       ( !cookie_domain && !current_cookie_domain ) ||
1651                       ( cookie_domain && current_cookie_domain &&
1652                         !strcmp( cookie_domain, current_cookie_domain ) ) );
1653
1654         if( is_domain_matching && !strcmp( cookie_name, current_cookie_name )  )
1655         {
1656             /* Remove previous value for this cookie */
1657             free( current_cookie );
1658             vlc_array_remove( cookies, i );
1659
1660             /* Clean */
1661             free( current_cookie_name );
1662             free( current_cookie_domain );
1663             break;
1664         }
1665         free( current_cookie_name );
1666         free( current_cookie_domain );
1667     }
1668     free( cookie_name );
1669     free( cookie_domain );
1670     vlc_array_append( cookies, cookie );
1671 }
1672
1673
1674 /*****************************************************************************
1675  * HTTP authentication
1676  *****************************************************************************/
1677
1678 static void AuthReply( access_t *p_access, const char *psz_prefix,
1679                        vlc_url_t *p_url, http_auth_t *p_auth )
1680 {
1681     access_sys_t *p_sys = p_access->p_sys;
1682     char *psz_value;
1683
1684     psz_value =
1685         http_auth_FormatAuthorizationHeader( VLC_OBJECT(p_access), p_auth,
1686                                              "GET", p_url->psz_path,
1687                                              p_url->psz_username,
1688                                              p_url->psz_password );
1689     if ( psz_value == NULL )
1690         return;
1691
1692     net_Printf( p_access, p_sys->fd, p_sys->p_vs,
1693                 "%sAuthorization: %s\r\n", psz_prefix, psz_value );
1694     free( psz_value );
1695 }
1696
1697 static int AuthCheckReply( access_t *p_access, const char *psz_header,
1698                            vlc_url_t *p_url, http_auth_t *p_auth )
1699 {
1700     return
1701         http_auth_ParseAuthenticationInfoHeader( VLC_OBJECT(p_access), p_auth,
1702                                                  psz_header, "",
1703                                                  p_url->psz_path,
1704                                                  p_url->psz_username,
1705                                                  p_url->psz_password );
1706 }