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

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

midi

开发平台：

Unix_Linux

http.c：源码内容
  1. /*****************************************************************************
  2.  * http.c: HTTP input module
  3.  *****************************************************************************
  4.  * Copyright (C) 2001-2008 the VideoLAN team
  5.  * $Id: da8d80868270a0b863af8b73fb080a1e76851ba4 $
  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
  13.  * it under the terms of the GNU General Public License as published by
  14.  * the Free Software Foundation; either version 2 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 General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU General Public License
  23.  * along with this program; if not, write to the Free Software
  24.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25.  *****************************************************************************/
  27. /*****************************************************************************
  28.  * Preamble
  29.  *****************************************************************************/
  30. #ifdef HAVE_CONFIG_H
  31. # include "config.h"
  32. #endif
  34. #include <vlc_common.h>
  35. #include <vlc_plugin.h>
  38. #include <vlc_access.h>
  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>
  50. #ifdef HAVE_ZLIB_H
  51. #   include <zlib.h>
  52. #endif
  54. #include <assert.h>
  56. #ifdef HAVE_LIBPROXY
  57. #    include <proxy.h>
  58. #endif
  59. /*****************************************************************************
  60.  * Module descriptor
  61.  *****************************************************************************/
  62. static int  Open ( vlc_object_t * );
  63. static void Close( vlc_object_t * );
  65. #define PROXY_TEXT N_("HTTP proxy")
  66. #define PROXY_LONGTEXT N_( 
  67.     "HTTP proxy to be used It must be of the form " 
  68.     "http://[user@]myproxy.mydomain:myport/ ; " 
  69.     "if empty, the http_proxy environment variable will be tried." )
  71. #define PROXY_PASS_TEXT N_("HTTP proxy password")
  72. #define PROXY_PASS_LONGTEXT N_( 
  73.     "If your HTTP proxy requires a password, set it here." )
  75. #define CACHING_TEXT N_("Caching value in ms")
  76. #define CACHING_LONGTEXT N_( 
  77.     "Caching value for HTTP streams. This " 
  78.     "value should be set in milliseconds." )
  80. #define AGENT_TEXT N_("HTTP user agent")
  81. #define AGENT_LONGTEXT N_("User agent that will be " 
  82.     "used for the connection.")
  84. #define RECONNECT_TEXT N_("Auto re-connect")
  85. #define RECONNECT_LONGTEXT N_( 
  86.     "Automatically try to reconnect to the stream in case of a sudden " 
  87.     "disconnect." )
  89. #define CONTINUOUS_TEXT N_("Continuous stream")
  90. #define CONTINUOUS_LONGTEXT N_("Read a file that is " 
  91.     "being constantly updated (for example, a JPG file on a server). " 
  92.     "You should not globally enable this option as it will break all other " 
  93.     "types of HTTP streams." )
  95. #define FORWARD_COOKIES_TEXT N_("Forward Cookies")
  96. #define FORWARD_COOKIES_LONGTEXT N_("Forward Cookies across http redirections ")
  98. vlc_module_begin ()
  99.     set_description( N_("HTTP input") )
  100.     set_capability( "access", 0 )
  101.     set_shortname( N_( "HTTP(S)" ) )
  102.     set_category( CAT_INPUT )
  103.     set_subcategory( SUBCAT_INPUT_ACCESS )
  105.     add_string( "http-proxy", NULL, NULL, PROXY_TEXT, PROXY_LONGTEXT,
  106.                 false )
  107.     add_password( "http-proxy-pwd", NULL, NULL,
  108.                   PROXY_PASS_TEXT, PROXY_PASS_LONGTEXT, false )
  109.     add_integer( "http-caching", 4 * DEFAULT_PTS_DELAY / 1000, NULL,
  110.                  CACHING_TEXT, CACHING_LONGTEXT, true )
  111.         change_safe()
  112.     add_string( "http-user-agent", COPYRIGHT_MESSAGE , NULL, AGENT_TEXT,
  113.                 AGENT_LONGTEXT, true )
  114.         change_safe()
  115.     add_bool( "http-reconnect", 0, NULL, RECONNECT_TEXT,
  116.               RECONNECT_LONGTEXT, true )
  117.     add_bool( "http-continuous", 0, NULL, CONTINUOUS_TEXT,
  118.               CONTINUOUS_LONGTEXT, true )
  119.         change_safe()
  120.     add_bool( "http-forward-cookies", true, NULL, FORWARD_COOKIES_TEXT,
  121.               FORWARD_COOKIES_LONGTEXT, true )
  122.     add_obsolete_string("http-user")
  123.     add_obsolete_string("http-pwd")
  124.     add_shortcut( "http" )
  125.     add_shortcut( "https" )
  126.     add_shortcut( "unsv" )
  127.     add_shortcut( "itpc" ) /* iTunes Podcast */
  128.     add_shortcut( "icyx" )
  129.     set_callbacks( Open, Close )
  130. vlc_module_end ()
  132. /*****************************************************************************
  133.  * Local prototypes
  134.  *****************************************************************************/
  136. /* RFC 2617: Basic and Digest Access Authentication */
  137. typedef struct http_auth_t
  138. {
  139.     char *psz_realm;
  140.     char *psz_domain;
  141.     char *psz_nonce;
  142.     char *psz_opaque;
  143.     char *psz_stale;
  144.     char *psz_algorithm;
  145.     char *psz_qop;
  146.     int i_nonce;
  147.     char *psz_cnonce;
  148.     char *psz_HA1; /* stored H(A1) value if algorithm = "MD5-sess" */
  149. } http_auth_t;
  151. struct access_sys_t
  152. {
  153.     int fd;
  154.     tls_session_t *p_tls;
  155.     v_socket_t    *p_vs;
  157.     /* From uri */
  158.     vlc_url_t url;
  159.     char    *psz_user_agent;
  160.     http_auth_t auth;
  162.     /* Proxy */
  163.     bool b_proxy;
  164.     vlc_url_t  proxy;
  165.     http_auth_t proxy_auth;
  166.     char       *psz_proxy_passbuf;
  168.     /* */
  169.     int        i_code;
  170.     const char *psz_protocol;
  171.     int        i_version;
  173.     char       *psz_mime;
  174.     char       *psz_pragma;
  175.     char       *psz_location;
  176.     bool b_mms;
  177.     bool b_icecast;
  178.     bool b_ssl;
  179. #ifdef HAVE_ZLIB_H
  180.     bool b_compressed;
  181.     struct
  182.     {
  183.         z_stream   stream;
  184.         uint8_t   *p_buffer;
  185.     } inflate;
  186. #endif
  188.     bool b_chunked;
  189.     int64_t    i_chunk;
  191.     int        i_icy_meta;
  192.     int64_t    i_icy_offset;
  193.     char       *psz_icy_name;
  194.     char       *psz_icy_genre;
  195.     char       *psz_icy_title;
  197.     int64_t i_remaining;
  199.     bool b_seekable;
  200.     bool b_reconnect;
  201.     bool b_continuous;
  202.     bool b_pace_control;
  203.     bool b_persist;
  205.     vlc_array_t * cookies;
  206. };
  208. /* */
  209. static int OpenWithCookies( vlc_object_t *p_this, const char *psz_access,
  210.                             vlc_array_t *cookies );
  212. /* */
  213. static ssize_t Read( access_t *, uint8_t *, size_t );
  214. static ssize_t ReadCompressed( access_t *, uint8_t *, size_t );
  215. static int Seek( access_t *, int64_t );
  216. static int Control( access_t *, int, va_list );
  218. /* */
  219. static int Connect( access_t *, int64_t );
  220. static int Request( access_t *p_access, int64_t i_tell );
  221. static void Disconnect( access_t * );
  223. /* Small Cookie utilities. Cookies support is partial. */
  224. static char * cookie_get_content( const char * cookie );
  225. static char * cookie_get_domain( const char * cookie );
  226. static char * cookie_get_name( const char * cookie );
  227. static void cookie_append( vlc_array_t * cookies, char * cookie );
  230. static void AuthParseHeader( access_t *p_access, const char *psz_header,
  231.                              http_auth_t *p_auth );
  232. static void AuthReply( access_t *p_acces, const char *psz_prefix,
  233.                        vlc_url_t *p_url, http_auth_t *p_auth );
  234. static int AuthCheckReply( access_t *p_access, const char *psz_header,
  235.                            vlc_url_t *p_url, http_auth_t *p_auth );
  236. static void AuthReset( http_auth_t *p_auth );
  238. /*****************************************************************************
  239.  * Open:
  240.  *****************************************************************************/
  241. static int Open( vlc_object_t *p_this )
  242. {
  243.     access_t *p_access = (access_t*)p_this;
  244.     return OpenWithCookies( p_this, p_access->psz_access, NULL );
  245. }
  247. /**
  248.  * Open the given url using the given cookies
  249.  * @param p_this: the vlc object
  250.  * @psz_access: the acces to use (http, https, ...) (this value must be used
  251.  *              instead of p_access->psz_access)
  252.  * @cookies: the available cookies
  253.  * @return vlc error codes
  254.  */
  255. static int OpenWithCookies( vlc_object_t *p_this, const char *psz_access,
  256.                             vlc_array_t *cookies )
  257. {
  258.     access_t     *p_access = (access_t*)p_this;
  259.     access_sys_t *p_sys;
  260.     char         *psz, *p;
  261.     /* Only forward an store cookies if the corresponding option is activated */
  262.     bool   b_forward_cookies = var_CreateGetBool( p_access, "http-forward-cookies" );
  263.     vlc_array_t * saved_cookies = b_forward_cookies ? (cookies ? cookies : vlc_array_new()) : NULL;
  265.     /* Set up p_access */
  266.     STANDARD_READ_ACCESS_INIT;
  267. #ifdef HAVE_ZLIB_H
  268.     p_access->pf_read = ReadCompressed;
  269. #endif
  270.     p_sys->fd = -1;
  271.     p_sys->b_proxy = false;
  272.     p_sys->psz_proxy_passbuf = NULL;
  273.     p_sys->i_version = 1;
  274.     p_sys->b_seekable = true;
  275.     p_sys->psz_mime = NULL;
  276.     p_sys->psz_pragma = NULL;
  277.     p_sys->b_mms = false;
  278.     p_sys->b_icecast = false;
  279.     p_sys->psz_location = NULL;
  280.     p_sys->psz_user_agent = NULL;
  281.     p_sys->b_pace_control = true;
  282.     p_sys->b_ssl = false;
  283. #ifdef HAVE_ZLIB_H
  284.     p_sys->b_compressed = false;
  285.     /* 15 is the max windowBits, +32 to enable optional gzip decoding */
  286.     if( inflateInit2( &p_sys->inflate.stream, 32+15 ) != Z_OK )
  287.         msg_Warn( p_access, "Error during zlib initialisation: %s",
  288.                   p_sys->inflate.stream.msg );
  289.     if( zlibCompileFlags() & (1<<17) )
  290.         msg_Warn( p_access, "Your zlib was compiled without gzip support." );
  291.     p_sys->inflate.p_buffer = NULL;
  292. #endif
  293.     p_sys->p_tls = NULL;
  294.     p_sys->p_vs = NULL;
  295.     p_sys->i_icy_meta = 0;
  296.     p_sys->i_icy_offset = 0;
  297.     p_sys->psz_icy_name = NULL;
  298.     p_sys->psz_icy_genre = NULL;
  299.     p_sys->psz_icy_title = NULL;
  300.     p_sys->i_remaining = 0;
  301.     p_sys->b_persist = false;
  302.     p_access->info.i_size = -1;
  303.     p_access->info.i_pos  = 0;
  304.     p_access->info.b_eof  = false;
  306.     p_sys->cookies = saved_cookies;
  308.     /* Parse URI - remove spaces */
  309.     p = psz = strdup( p_access->psz_path );
  310.     while( (p = strchr( p, ' ' )) != NULL )
  311.         *p = '+';
  312.     vlc_UrlParse( &p_sys->url, psz, 0 );
  313.     free( psz );
  315.     if( p_sys->url.psz_host == NULL || *p_sys->url.psz_host == '' )
  316.     {
  317.         msg_Warn( p_access, "invalid host" );
  318.         goto error;
  319.     }
  320.     if( !strncmp( psz_access, "https", 5 ) )
  321.     {
  322.         /* HTTP over SSL */
  323.         p_sys->b_ssl = true;
  324.         if( p_sys->url.i_port <= 0 )
  325.             p_sys->url.i_port = 443;
  326.     }
  327.     else
  328.     {
  329.         if( p_sys->url.i_port <= 0 )
  330.             p_sys->url.i_port = 80;
  331.     }
  333.     /* Do user agent */
  334.     p_sys->psz_user_agent = var_CreateGetString( p_access, "http-user-agent" );
  336.     /* Check proxy */
  337.     psz = var_CreateGetNonEmptyString( p_access, "http-proxy" );
  338.     if( psz )
  339.     {
  340.         p_sys->b_proxy = true;
  341.         vlc_UrlParse( &p_sys->proxy, psz, 0 );
  342.         free( psz );
  343.     }
  344. #ifdef HAVE_LIBPROXY
  345.     else
  346.     {
  347.         pxProxyFactory *pf = px_proxy_factory_new();
  348.         if (pf)
  349.         {
  350.             char *buf;
  351.             int i;
  352.             i=asprintf(&buf, "%s://%s", psz_access, p_access->psz_path);
  353.             if (i >= 0)
  354.             {
  355.                 msg_Dbg(p_access, "asking libproxy about url '%s'", buf);
  356.                 char **proxies = px_proxy_factory_get_proxies(pf, buf);
  357.                 if (proxies[0])
  358.                 {
  359.                     msg_Dbg(p_access, "libproxy suggest to use '%s'", proxies[0]);
  360.                     if(strcmp(proxies[0],"direct://") != 0)
  361.                     {
  362.                         p_sys->b_proxy = true;
  363.                         vlc_UrlParse( &p_sys->proxy, proxies[0], 0);
  364.                     }
  365.                 }
  366.                 for(i=0;proxies[i];i++) free(proxies[i]);
  367.                 free(proxies);
  368.                 free(buf);
  369.             }
  370.             px_proxy_factory_free(pf);
  371.         }
  372.         else
  373.         {
  374.             msg_Err(p_access, "Allocating memory for libproxy failed");
  375.         }
  376.     }
  377. #elif HAVE_GETENV
  378.     else
  379.     {
  380.         psz = getenv( "http_proxy" );
  381.         if( psz )
  382.         {
  383.             p_sys->b_proxy = true;
  384.             vlc_UrlParse( &p_sys->proxy, psz, 0 );
  385.         }
  386.     }
  387. #endif
  388.     if( psz ) /* No, this is NOT a use-after-free error */
  389.     {
  390.         psz = var_CreateGetNonEmptyString( p_access, "http-proxy-pwd" );
  391.         if( psz )
  392.             p_sys->proxy.psz_password = p_sys->psz_proxy_passbuf = psz;
  393.     }
  395.     if( p_sys->b_proxy )
  396.     {
  397.         if( p_sys->proxy.psz_host == NULL || *p_sys->proxy.psz_host == '' )
  398.         {
  399.             msg_Warn( p_access, "invalid proxy host" );
  400.             goto error;
  401.         }
  402.         if( p_sys->proxy.i_port <= 0 )
  403.         {
  404.             p_sys->proxy.i_port = 80;
  405.         }
  406.     }
  408.     msg_Dbg( p_access, "http: server='%s' port=%d file='%s",
  409.              p_sys->url.psz_host, p_sys->url.i_port, p_sys->url.psz_path );
  410.     if( p_sys->b_proxy )
  411.     {
  412.         msg_Dbg( p_access, "      proxy %s:%d", p_sys->proxy.psz_host,
  413.                  p_sys->proxy.i_port );
  414.     }
  415.     if( p_sys->url.psz_username && *p_sys->url.psz_username )
  416.     {
  417.         msg_Dbg( p_access, "      user='%s'", p_sys->url.psz_username );
  418.     }
  420.     p_sys->b_reconnect = var_CreateGetBool( p_access, "http-reconnect" );
  421.     p_sys->b_continuous = var_CreateGetBool( p_access, "http-continuous" );
  423. connect:
  424.     /* Connect */
  425.     switch( Connect( p_access, 0 ) )
  426.     {
  427.         case -1:
  428.             goto error;
  430.         case -2:
  431.             /* Retry with http 1.0 */
  432.             msg_Dbg( p_access, "switching to HTTP version 1.0" );
  433.             p_sys->i_version = 0;
  434.             p_sys->b_seekable = false;
  436.             if( !vlc_object_alive (p_access) || Connect( p_access, 0 ) )
  437.                 goto error;
  439. #ifndef NDEBUG
  440.         case 0:
  441.             break;
  443.         default:
  444.             msg_Err( p_access, "You should not be here" );
  445.             abort();
  446. #endif
  447.     }
  449.     if( p_sys->i_code == 401 )
  450.     {
  451.         char *psz_login, *psz_password;
  452.         /* FIXME ? */
  453.         if( p_sys->url.psz_username && p_sys->url.psz_password &&
  454.             p_sys->auth.psz_nonce && p_sys->auth.i_nonce == 0 )
  455.         {
  456.             Disconnect( p_access );
  457.             goto connect;
  458.         }
  459.         msg_Dbg( p_access, "authentication failed for realm %s",
  460.                  p_sys->auth.psz_realm );
  461.         dialog_Login( p_access, &psz_login, &psz_password,
  462.                       _("HTTP authentication"),
  463.              _("Please enter a valid login name and a password for realm %s."),
  464.                       p_sys->auth.psz_realm );
  465.         if( psz_login != NULL && psz_password != NULL )
  466.         {
  467.             msg_Dbg( p_access, "retrying with user=%s", psz_login );
  468.             p_sys->url.psz_username = psz_login;
  469.             p_sys->url.psz_password = psz_password;
  470.             Disconnect( p_access );
  471.             goto connect;
  472.         }
  473.         else
  474.         {
  475.             free( psz_login );
  476.             free( psz_password );
  477.             goto error;
  478.         }
  479.     }
  481.     if( ( p_sys->i_code == 301 || p_sys->i_code == 302 ||
  482.           p_sys->i_code == 303 || p_sys->i_code == 307 ) &&
  483.         p_sys->psz_location && *p_sys->psz_location )
  484.     {
  485.         msg_Dbg( p_access, "redirection to %s", p_sys->psz_location );
  487.         /* Do not accept redirection outside of HTTP works */
  488.         const char *psz_protocol;
  489.         if( !strncmp( p_sys->psz_location, "http:", 5 ) )
  490.             psz_protocol = "http";
  491.         else if( !strncmp( p_sys->psz_location, "https:", 6 ) )
  492.             psz_protocol = "https";
  493.         else
  494.         {
  495.             msg_Err( p_access, "insecure redirection ignored" );
  496.             goto error;
  497.         }
  498.         free( p_access->psz_path );
  499.         p_access->psz_path = strdup( p_sys->psz_location );
  500.         /* Clean up current Open() run */
  501.         vlc_UrlClean( &p_sys->url );
  502.         AuthReset( &p_sys->auth );
  503.         vlc_UrlClean( &p_sys->proxy );
  504.         free( p_sys->psz_proxy_passbuf );
  505.         AuthReset( &p_sys->proxy_auth );
  506.         free( p_sys->psz_mime );
  507.         free( p_sys->psz_pragma );
  508.         free( p_sys->psz_location );
  509.         free( p_sys->psz_user_agent );
  511.         Disconnect( p_access );
  512.         cookies = p_sys->cookies;
  513. #ifdef HAVE_ZLIB_H
  514.         inflateEnd( &p_sys->inflate.stream );
  515. #endif
  516.         free( p_sys );
  518.         /* Do new Open() run with new data */
  519.         return OpenWithCookies( p_this, psz_protocol, cookies );
  520.     }
  522.     if( p_sys->b_mms )
  523.     {
  524.         msg_Dbg( p_access, "this is actually a live mms server, BAIL" );
  525.         goto error;
  526.     }
  528.     if( !strcmp( p_sys->psz_protocol, "ICY" ) || p_sys->b_icecast )
  529.     {
  530.         if( p_sys->psz_mime && strcasecmp( p_sys->psz_mime, "application/ogg" ) )
  531.         {
  532.             if( !strcasecmp( p_sys->psz_mime, "video/nsv" ) ||
  533.                 !strcasecmp( p_sys->psz_mime, "video/nsa" ) )
  534.             {
  535.                 free( p_access->psz_demux );
  536.                 p_access->psz_demux = strdup( "nsv" );
  537.             }
  538.             else if( !strcasecmp( p_sys->psz_mime, "audio/aac" ) ||
  539.                      !strcasecmp( p_sys->psz_mime, "audio/aacp" ) )
  540.             {
  541.                 free( p_access->psz_demux );
  542.                 p_access->psz_demux = strdup( "m4a" );
  543.             }
  544.             else if( !strcasecmp( p_sys->psz_mime, "audio/mpeg" ) )
  545.             {
  546.                 free( p_access->psz_demux );
  547.                 p_access->psz_demux = strdup( "mp3" );
  548.             }
  550.             msg_Info( p_access, "Raw-audio server found, %s demuxer selected",
  551.                       p_access->psz_demux );
  553. #if 0       /* Doesn't work really well because of the pre-buffering in
  554.              * shoutcast servers (the buffer content will be sent as fast as
  555.              * possible). */
  556.             p_sys->b_pace_control = false;
  557. #endif
  558.         }
  559.         else if( !p_sys->psz_mime )
  560.         {
  561.             free( p_access->psz_demux );
  562.             /* Shoutcast */
  563.             p_access->psz_demux = strdup( "mp3" );
  564.         }
  565.         /* else probably Ogg Vorbis */
  566.     }
  567.     else if( !strcasecmp( psz_access, "unsv" ) &&
  568.              p_sys->psz_mime &&
  569.              !strcasecmp( p_sys->psz_mime, "misc/ultravox" ) )
  570.     {
  571.         free( p_access->psz_demux );
  572.         /* Grrrr! detect ultravox server and force NSV demuxer */
  573.         p_access->psz_demux = strdup( "nsv" );
  574.     }
  575.     else if( !strcmp( psz_access, "itpc" ) )
  576.     {
  577.         free( p_access->psz_demux );
  578.         p_access->psz_demux = strdup( "podcast" );
  579.     }
  580.     else if( p_sys->psz_mime &&
  581.              !strncasecmp( p_sys->psz_mime, "application/xspf+xml", 20 ) &&
  582.              ( memchr( " ;t", p_sys->psz_mime[20], 4 ) != NULL ) )
  583.     {
  584.         free( p_access->psz_demux );
  585.         p_access->psz_demux = strdup( "xspf-open" );
  586.     }
  588.     if( p_sys->b_reconnect ) msg_Dbg( p_access, "auto re-connect enabled" );
  590.     /* PTS delay */
  591.     var_Create( p_access, "http-caching", VLC_VAR_INTEGER |VLC_VAR_DOINHERIT );
  593.     return VLC_SUCCESS;
  595. error:
  596.     vlc_UrlClean( &p_sys->url );
  597.     vlc_UrlClean( &p_sys->proxy );
  598.     free( p_sys->psz_proxy_passbuf );
  599.     free( p_sys->psz_mime );
  600.     free( p_sys->psz_pragma );
  601.     free( p_sys->psz_location );
  602.     free( p_sys->psz_user_agent );
  604.     Disconnect( p_access );
  606.     if( p_sys->cookies )
  607.     {
  608.         int i;
  609.         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
  610.             free(vlc_array_item_at_index( p_sys->cookies, i ));
  611.         vlc_array_destroy( p_sys->cookies );
  612.     }
  614. #ifdef HAVE_ZLIB_H
  615.     inflateEnd( &p_sys->inflate.stream );
  616. #endif
  617.     free( p_sys );
  618.     return VLC_EGENERIC;
  619. }
  621. /*****************************************************************************
  622.  * Close:
  623.  *****************************************************************************/
  624. static void Close( vlc_object_t *p_this )
  625. {
  626.     access_t     *p_access = (access_t*)p_this;
  627.     access_sys_t *p_sys = p_access->p_sys;
  629.     vlc_UrlClean( &p_sys->url );
  630.     AuthReset( &p_sys->auth );
  631.     vlc_UrlClean( &p_sys->proxy );
  632.     AuthReset( &p_sys->proxy_auth );
  634.     free( p_sys->psz_mime );
  635.     free( p_sys->psz_pragma );
  636.     free( p_sys->psz_location );
  638.     free( p_sys->psz_icy_name );
  639.     free( p_sys->psz_icy_genre );
  640.     free( p_sys->psz_icy_title );
  642.     free( p_sys->psz_user_agent );
  644.     Disconnect( p_access );
  646.     if( p_sys->cookies )
  647.     {
  648.         int i;
  649.         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
  650.             free(vlc_array_item_at_index( p_sys->cookies, i ));
  651.         vlc_array_destroy( p_sys->cookies );
  652.     }
  654. #ifdef HAVE_ZLIB_H
  655.     inflateEnd( &p_sys->inflate.stream );
  656.     free( p_sys->inflate.p_buffer );
  657. #endif
  659.     free( p_sys );
  660. }
  662. /*****************************************************************************
  663.  * Read: Read up to i_len bytes from the http connection and place in
  664.  * p_buffer. Return the actual number of bytes read
  665.  *****************************************************************************/
  666. static int ReadICYMeta( access_t *p_access );
  667. static ssize_t Read( access_t *p_access, uint8_t *p_buffer, size_t i_len )
  668. {
  669.     access_sys_t *p_sys = p_access->p_sys;
  670.     int i_read;
  672.     if( p_sys->fd == -1 )
  673.     {
  674.         p_access->info.b_eof = true;
  675.         return 0;
  676.     }
  678.     if( p_access->info.i_size >= 0 &&
  679.         i_len + p_access->info.i_pos > p_access->info.i_size )
  680.     {
  681.         if( ( i_len = p_access->info.i_size - p_access->info.i_pos ) == 0 )
  682.         {
  683.             p_access->info.b_eof = true;
  684.             return 0;
  685.         }
  686.     }
  688.     if( p_sys->b_chunked )
  689.     {
  690.         if( p_sys->i_chunk < 0 )
  691.         {
  692.             p_access->info.b_eof = true;
  693.             return 0;
  694.         }
  696.         if( p_sys->i_chunk <= 0 )
  697.         {
  698.             char *psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, p_sys->p_vs );
  699.             /* read the chunk header */
  700.             if( psz == NULL )
  701.             {
  702.                 /* fatal error - end of file */
  703.                 msg_Dbg( p_access, "failed reading chunk-header line" );
  704.                 return 0;
  705.             }
  706.             p_sys->i_chunk = strtoll( psz, NULL, 16 );
  707.             free( psz );
  709.             if( p_sys->i_chunk <= 0 )   /* eof */
  710.             {
  711.                 p_sys->i_chunk = -1;
  712.                 p_access->info.b_eof = true;
  713.                 return 0;
  714.             }
  715.         }
  717.         if( i_len > p_sys->i_chunk )
  718.         {
  719.             i_len = p_sys->i_chunk;
  720.         }
  721.     }
  722.     else if( p_access->info.i_size != -1 && (int64_t)i_len > p_sys->i_remaining) {
  723.         /* Only ask for the remaining length */
  724.         i_len = (size_t)p_sys->i_remaining;
  725.         if(i_len == 0) {
  726.             p_access->info.b_eof = true;
  727.             return 0;
  728.         }
  729.     }
  732.     if( p_sys->i_icy_meta > 0 && p_access->info.i_pos-p_sys->i_icy_offset > 0 )
  733.     {
  734.         int64_t i_next = p_sys->i_icy_meta -
  735.                                     (p_access->info.i_pos - p_sys->i_icy_offset ) % p_sys->i_icy_meta;
  737.         if( i_next == p_sys->i_icy_meta )
  738.         {
  739.             if( ReadICYMeta( p_access ) )
  740.             {
  741.                 p_access->info.b_eof = true;
  742.                 return -1;
  743.             }
  744.         }
  745.         if( i_len > i_next )
  746.             i_len = i_next;
  747.     }
  749.     i_read = net_Read( p_access, p_sys->fd, p_sys->p_vs, p_buffer, i_len, false );
  751.     if( i_read > 0 )
  752.     {
  753.         p_access->info.i_pos += i_read;
  755.         if( p_sys->b_chunked )
  756.         {
  757.             p_sys->i_chunk -= i_read;
  758.             if( p_sys->i_chunk <= 0 )
  759.             {
  760.                 /* read the empty line */
  761.                 char *psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, p_sys->p_vs );
  762.                 free( psz );
  763.             }
  764.         }
  765.     }
  766.     else if( i_read <= 0 )
  767.     {
  768.         /*
  769.          * I very much doubt that this will work.
  770.          * If i_read == 0, the connection *IS* dead, so the only
  771.          * sensible thing to do is Disconnect() and then retry.
  772.          * Otherwise, I got recv() completely wrong. -- Courmisch
  773.          */
  774.         if( p_sys->b_continuous )
  775.         {
  776.             Request( p_access, 0 );
  777.             p_sys->b_continuous = false;
  778.             i_read = Read( p_access, p_buffer, i_len );
  779.             p_sys->b_continuous = true;
  780.         }
  781.         Disconnect( p_access );
  782.         if( p_sys->b_reconnect )
  783.         {
  784.             msg_Dbg( p_access, "got disconnected, trying to reconnect" );
  785.             if( Connect( p_access, p_access->info.i_pos ) )
  786.             {
  787.                 msg_Dbg( p_access, "reconnection failed" );
  788.             }
  789.             else
  790.             {
  791.                 p_sys->b_reconnect = false;
  792.                 i_read = Read( p_access, p_buffer, i_len );
  793.                 p_sys->b_reconnect = true;
  794.             }
  795.         }
  797.         if( i_read == 0 )
  798.             p_access->info.b_eof = true;
  799.         else if( i_read < 0 )
  800.             p_access->b_error = true;
  801.     }
  803.     if( p_access->info.i_size != -1 )
  804.     {
  805.         p_sys->i_remaining -= i_read;
  806.     }
  808.     return i_read;
  809. }
  811. static int ReadICYMeta( access_t *p_access )
  812. {
  813.     access_sys_t *p_sys = p_access->p_sys;
  815.     uint8_t buffer;
  816.     char *p, *psz_meta;
  817.     int i_read;
  819.     /* Read meta data length */
  820.     i_read = net_Read( p_access, p_sys->fd, p_sys->p_vs, &buffer, 1,
  821.                        true );
  822.     if( i_read <= 0 )
  823.         return VLC_EGENERIC;
  824.     if( buffer == 0 )
  825.         return VLC_SUCCESS;
  827.     i_read = buffer << 4;
  828.     /* msg_Dbg( p_access, "ICY meta size=%u", i_read); */
  830.     psz_meta = malloc( i_read + 1 );
  831.     if( net_Read( p_access, p_sys->fd, p_sys->p_vs,
  832.                   (uint8_t *)psz_meta, i_read, true ) != i_read )
  833.     {
  834.         free( psz_meta );
  835.         return VLC_EGENERIC;
  836.     }
  838.     psz_meta[i_read] = ''; /* Just in case */
  840.     /* msg_Dbg( p_access, "icy-meta=%s", psz_meta ); */
  842.     /* Now parse the meta */
  843.     /* Look for StreamTitle= */
  844.     p = strcasestr( (char *)psz_meta, "StreamTitle=" );
  845.     if( p )
  846.     {
  847.         p += strlen( "StreamTitle=" );
  848.         if( *p == ''' || *p == '"' )
  849.         {
  850.             char closing[] = { p[0], ';', '' };
  851.             char *psz = strstr( &p[1], closing );
  852.             if( !psz )
  853.                 psz = strchr( &p[1], ';' );
  855.             if( psz ) *psz = '';
  856.         }
  857.         else
  858.         {
  859.             char *psz = strchr( &p[1], ';' );
  860.             if( psz ) *psz = '';
  861.         }
  863.         if( !p_sys->psz_icy_title ||
  864.             strcmp( p_sys->psz_icy_title, &p[1] ) )
  865.         {
  866.             free( p_sys->psz_icy_title );
  867.             char *psz_tmp = strdup( &p[1] );
  868.             p_sys->psz_icy_title = EnsureUTF8( psz_tmp );
  869.             if( !p_sys->psz_icy_title )
  870.                 free( psz_tmp );
  871.             p_access->info.i_update |= INPUT_UPDATE_META;
  873.             msg_Dbg( p_access, "New Title=%s", p_sys->psz_icy_title );
  874.         }
  875.     }
  876.     free( psz_meta );
  878.     return VLC_SUCCESS;
  879. }
  881. #ifdef HAVE_ZLIB_H
  882. static ssize_t ReadCompressed( access_t *p_access, uint8_t *p_buffer,
  883.                                size_t i_len )
  884. {
  885.     access_sys_t *p_sys = p_access->p_sys;
  887.     if( p_sys->b_compressed )
  888.     {
  889.         int i_ret;
  891.         if( !p_sys->inflate.p_buffer )
  892.             p_sys->inflate.p_buffer = malloc( 256 * 1024 );
  894.         if( p_sys->inflate.stream.avail_in == 0 )
  895.         {
  896.             ssize_t i_read = Read( p_access, p_sys->inflate.p_buffer + p_sys->inflate.stream.avail_in, 256 * 1024 );
  897.             if( i_read <= 0 ) return i_read;
  898.             p_sys->inflate.stream.next_in = p_sys->inflate.p_buffer;
  899.             p_sys->inflate.stream.avail_in = i_read;
  900.         }
  902.         p_sys->inflate.stream.avail_out = i_len;
  903.         p_sys->inflate.stream.next_out = p_buffer;
  905.         i_ret = inflate( &p_sys->inflate.stream, Z_SYNC_FLUSH );
  906.         msg_Warn( p_access, "inflate return value: %d, %s", i_ret, p_sys->inflate.stream.msg );
  908.         return i_len - p_sys->inflate.stream.avail_out;
  909.     }
  910.     else
  911.     {
  912.         return Read( p_access, p_buffer, i_len );
  913.     }
  914. }
  915. #endif
  917. /*****************************************************************************
  918.  * Seek: close and re-open a connection at the right place
  919.  *****************************************************************************/
  920. static int Seek( access_t *p_access, int64_t i_pos )
  921. {
  922.     msg_Dbg( p_access, "trying to seek to %"PRId64, i_pos );
  924.     Disconnect( p_access );
  926.     if( p_access->info.i_size
  927.      && (uint64_t)i_pos >= (uint64_t)p_access->info.i_size ) {
  928.         msg_Err( p_access, "seek to far" );
  929.         int retval = Seek( p_access, p_access->info.i_size - 1 );
  930.         if( retval == VLC_SUCCESS ) {
  931.             uint8_t p_buffer[2];
  932.             Read( p_access, p_buffer, 1);
  933.             p_access->info.b_eof  = false;
  934.         }
  935.         return retval;
  936.     }
  937.     if( Connect( p_access, i_pos ) )
  938.     {
  939.         msg_Err( p_access, "seek failed" );
  940.         p_access->info.b_eof = true;
  941.         return VLC_EGENERIC;
  942.     }
  943.     return VLC_SUCCESS;
  944. }
  946. /*****************************************************************************
  947.  * Control:
  948.  *****************************************************************************/
  949. static int Control( access_t *p_access, int i_query, va_list args )
  950. {
  951.     access_sys_t *p_sys = p_access->p_sys;
  952.     bool       *pb_bool;
  953.     int64_t    *pi_64;
  954.     vlc_meta_t *p_meta;
  956.     switch( i_query )
  957.     {
  958.         /* */
  959.         case ACCESS_CAN_SEEK:
  960.             pb_bool = (bool*)va_arg( args, bool* );
  961.             *pb_bool = p_sys->b_seekable;
  962.             break;
  963.         case ACCESS_CAN_FASTSEEK:
  964.             pb_bool = (bool*)va_arg( args, bool* );
  965.             *pb_bool = false;
  966.             break;
  967.         case ACCESS_CAN_PAUSE:
  968.         case ACCESS_CAN_CONTROL_PACE:
  969.             pb_bool = (bool*)va_arg( args, bool* );
  971. #if 0       /* Disable for now until we have a clock synchro algo
  972.              * which works with something else than MPEG over UDP */
  973.             *pb_bool = p_sys->b_pace_control;
  974. #endif
  975.             *pb_bool = true;
  976.             break;
  978.         /* */
  979.         case ACCESS_GET_PTS_DELAY:
  980.             pi_64 = (int64_t*)va_arg( args, int64_t * );
  981.             *pi_64 = (int64_t)var_GetInteger( p_access, "http-caching" ) * 1000;
  982.             break;
  984.         /* */
  985.         case ACCESS_SET_PAUSE_STATE:
  986.             break;
  988.         case ACCESS_GET_META:
  989.             p_meta = (vlc_meta_t*)va_arg( args, vlc_meta_t* );
  991.             if( p_sys->psz_icy_name )
  992.                 vlc_meta_Set( p_meta, vlc_meta_Title, p_sys->psz_icy_name );
  993.             if( p_sys->psz_icy_genre )
  994.                 vlc_meta_Set( p_meta, vlc_meta_Genre, p_sys->psz_icy_genre );
  995.             if( p_sys->psz_icy_title )
  996.                 vlc_meta_Set( p_meta, vlc_meta_NowPlaying, p_sys->psz_icy_title );
  997.             break;
  999.         case ACCESS_GET_CONTENT_TYPE:
  1000.             *va_arg( args, char ** ) =
  1001.                 p_sys->psz_mime ? strdup( p_sys->psz_mime ) : NULL;
  1002.             break;
  1004.         case ACCESS_GET_TITLE_INFO:
  1005.         case ACCESS_SET_TITLE:
  1006.         case ACCESS_SET_SEEKPOINT:
  1007.         case ACCESS_SET_PRIVATE_ID_STATE:
  1008.             return VLC_EGENERIC;
  1010.         default:
  1011.             msg_Warn( p_access, "unimplemented query in control" );
  1012.             return VLC_EGENERIC;
  1014.     }
  1015.     return VLC_SUCCESS;
  1016. }
  1018. /*****************************************************************************
  1019.  * Connect:
  1020.  *****************************************************************************/
  1021. static int Connect( access_t *p_access, int64_t i_tell )
  1022. {
  1023.     access_sys_t   *p_sys = p_access->p_sys;
  1024.     vlc_url_t      srv = p_sys->b_proxy ? p_sys->proxy : p_sys->url;
  1026.     /* Clean info */
  1027.     free( p_sys->psz_location );
  1028.     free( p_sys->psz_mime );
  1029.     free( p_sys->psz_pragma );
  1031.     free( p_sys->psz_icy_genre );
  1032.     free( p_sys->psz_icy_name );
  1033.     free( p_sys->psz_icy_title );
  1036.     p_sys->psz_location = NULL;
  1037.     p_sys->psz_mime = NULL;
  1038.     p_sys->psz_pragma = NULL;
  1039.     p_sys->b_mms = false;
  1040.     p_sys->b_chunked = false;
  1041.     p_sys->i_chunk = 0;
  1042.     p_sys->i_icy_meta = 0;
  1043.     p_sys->i_icy_offset = i_tell;
  1044.     p_sys->psz_icy_name = NULL;
  1045.     p_sys->psz_icy_genre = NULL;
  1046.     p_sys->psz_icy_title = NULL;
  1047.     p_sys->i_remaining = 0;
  1048.     p_sys->b_persist = false;
  1050.     p_access->info.i_size = -1;
  1051.     p_access->info.i_pos  = i_tell;
  1052.     p_access->info.b_eof  = false;
  1054.     /* Open connection */
  1055.     assert( p_sys->fd == -1 ); /* No open sockets (leaking fds is BAD) */
  1056.     p_sys->fd = net_ConnectTCP( p_access, srv.psz_host, srv.i_port );
  1057.     if( p_sys->fd == -1 )
  1058.     {
  1059.         msg_Err( p_access, "cannot connect to %s:%d", srv.psz_host, srv.i_port );
  1060.         return -1;
  1061.     }
  1062.     setsockopt (p_sys->fd, SOL_SOCKET, SO_KEEPALIVE, &(int){ 1 }, sizeof (int));
  1064.     /* Initialize TLS/SSL session */
  1065.     if( p_sys->b_ssl == true )
  1066.     {
  1067.         /* CONNECT to establish TLS tunnel through HTTP proxy */
  1068.         if( p_sys->b_proxy )
  1069.         {
  1070.             char *psz;
  1071.             unsigned i_status = 0;
  1073.             if( p_sys->i_version == 0 )
  1074.             {
  1075.                 /* CONNECT is not in HTTP/1.0 */
  1076.                 Disconnect( p_access );
  1077.                 return -1;
  1078.             }
  1080.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  1081.                         "CONNECT %s:%d HTTP/1.%drnHost: %s:%drnrn",
  1082.                         p_sys->url.psz_host, p_sys->url.i_port,
  1083.                         p_sys->i_version,
  1084.                         p_sys->url.psz_host, p_sys->url.i_port);
  1086.             psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, NULL );
  1087.             if( psz == NULL )
  1088.             {
  1089.                 msg_Err( p_access, "cannot establish HTTP/TLS tunnel" );
  1090.                 Disconnect( p_access );
  1091.                 return -1;
  1092.             }
  1094.             sscanf( psz, "HTTP/%*u.%*u %3u", &i_status );
  1095.             free( psz );
  1097.             if( ( i_status / 100 ) != 2 )
  1098.             {
  1099.                 msg_Err( p_access, "HTTP/TLS tunnel through proxy denied" );
  1100.                 Disconnect( p_access );
  1101.                 return -1;
  1102.             }
  1104.             do
  1105.             {
  1106.                 psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, NULL );
  1107.                 if( psz == NULL )
  1108.                 {
  1109.                     msg_Err( p_access, "HTTP proxy connection failed" );
  1110.                     Disconnect( p_access );
  1111.                     return -1;
  1112.                 }
  1114.                 if( *psz == '' )
  1115.                     i_status = 0;
  1117.                 free( psz );
  1119.                 if( !vlc_object_alive (p_access) || p_access->b_error )
  1120.                 {
  1121.                     Disconnect( p_access );
  1122.                     return -1;
  1123.                 }
  1124.             }
  1125.             while( i_status );
  1126.         }
  1128.         /* TLS/SSL handshake */
  1129.         p_sys->p_tls = tls_ClientCreate( VLC_OBJECT(p_access), p_sys->fd,
  1130.                                          p_sys->url.psz_host );
  1131.         if( p_sys->p_tls == NULL )
  1132.         {
  1133.             msg_Err( p_access, "cannot establish HTTP/TLS session" );
  1134.             Disconnect( p_access );
  1135.             return -1;
  1136.         }
  1137.         p_sys->p_vs = &p_sys->p_tls->sock;
  1138.     }
  1140.     return Request( p_access, i_tell ) ? -2 : 0;
  1141. }
  1144. static int Request( access_t *p_access, int64_t i_tell )
  1145. {
  1146.     access_sys_t   *p_sys = p_access->p_sys;
  1147.     char           *psz ;
  1148.     v_socket_t     *pvs = p_sys->p_vs;
  1149.     p_sys->b_persist = false;
  1151.     p_sys->i_remaining = 0;
  1152.     if( p_sys->b_proxy )
  1153.     {
  1154.         if( p_sys->url.psz_path )
  1155.         {
  1156.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  1157.                         "GET http://%s:%d%s HTTP/1.%drn",
  1158.                         p_sys->url.psz_host, p_sys->url.i_port,
  1159.                         p_sys->url.psz_path, p_sys->i_version );
  1160.         }
  1161.         else
  1162.         {
  1163.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, NULL,
  1164.                         "GET http://%s:%d/ HTTP/1.%drn",
  1165.                         p_sys->url.psz_host, p_sys->url.i_port,
  1166.                         p_sys->i_version );
  1167.         }
  1168.     }
  1169.     else
  1170.     {
  1171.         const char *psz_path = p_sys->url.psz_path;
  1172.         if( !psz_path || !*psz_path )
  1173.         {
  1174.             psz_path = "/";
  1175.         }
  1176.         if( p_sys->url.i_port != (pvs ? 443 : 80) )
  1177.         {
  1178.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
  1179.                         "GET %s HTTP/1.%drnHost: %s:%drn",
  1180.                         psz_path, p_sys->i_version, p_sys->url.psz_host,
  1181.                         p_sys->url.i_port );
  1182.         }
  1183.         else
  1184.         {
  1185.             net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
  1186.                         "GET %s HTTP/1.%drnHost: %srn",
  1187.                         psz_path, p_sys->i_version, p_sys->url.psz_host );
  1188.         }
  1189.     }
  1190.     /* User Agent */
  1191.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs, "User-Agent: %srn",
  1192.                 p_sys->psz_user_agent );
  1193.     /* Offset */
  1194.     if( p_sys->i_version == 1 && ! p_sys->b_continuous )
  1195.     {
  1196.         p_sys->b_persist = true;
  1197.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
  1198.                     "Range: bytes=%"PRIu64"-rn", i_tell );
  1199.     }
  1201.     /* Cookies */
  1202.     if( p_sys->cookies )
  1203.     {
  1204.         int i;
  1205.         for( i = 0; i < vlc_array_count( p_sys->cookies ); i++ )
  1206.         {
  1207.             const char * cookie = vlc_array_item_at_index( p_sys->cookies, i );
  1208.             char * psz_cookie_content = cookie_get_content( cookie );
  1209.             char * psz_cookie_domain = cookie_get_domain( cookie );
  1211.             assert( psz_cookie_content );
  1213.             /* FIXME: This is clearly not conforming to the rfc */
  1214.             bool is_in_right_domain = (!psz_cookie_domain || strstr( p_sys->url.psz_host, psz_cookie_domain ));
  1216.             if( is_in_right_domain )
  1217.             {
  1218.                 msg_Dbg( p_access, "Sending Cookie %s", psz_cookie_content );
  1219.                 if( net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs, "Cookie: %srn", psz_cookie_content ) < 0 )
  1220.                     msg_Err( p_access, "failed to send Cookie" );
  1221.             }
  1222.             free( psz_cookie_content );
  1223.             free( psz_cookie_domain );
  1224.         }
  1225.     }
  1227.     /* Authentication */
  1228.     if( p_sys->url.psz_username || p_sys->url.psz_password )
  1229.         AuthReply( p_access, "", &p_sys->url, &p_sys->auth );
  1231.     /* Proxy Authentication */
  1232.     if( p_sys->proxy.psz_username || p_sys->proxy.psz_password )
  1233.         AuthReply( p_access, "Proxy-", &p_sys->proxy, &p_sys->proxy_auth );
  1235.     /* ICY meta data request */
  1236.     net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs, "Icy-MetaData: 1rn" );
  1239.     if( net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs, "rn" ) < 0 )
  1240.     {
  1241.         msg_Err( p_access, "failed to send request" );
  1242.         Disconnect( p_access );
  1243.         return VLC_EGENERIC;
  1244.     }
  1246.     /* Read Answer */
  1247.     if( ( psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, pvs ) ) == NULL )
  1248.     {
  1249.         msg_Err( p_access, "failed to read answer" );
  1250.         goto error;
  1251.     }
  1252.     if( !strncmp( psz, "HTTP/1.", 7 ) )
  1253.     {
  1254.         p_sys->psz_protocol = "HTTP";
  1255.         p_sys->i_code = atoi( &psz[9] );
  1256.     }
  1257.     else if( !strncmp( psz, "ICY", 3 ) )
  1258.     {
  1259.         p_sys->psz_protocol = "ICY";
  1260.         p_sys->i_code = atoi( &psz[4] );
  1261.         p_sys->b_reconnect = true;
  1262.     }
  1263.     else
  1264.     {
  1265.         msg_Err( p_access, "invalid HTTP reply '%s'", psz );
  1266.         free( psz );
  1267.         goto error;
  1268.     }
  1269.     msg_Dbg( p_access, "protocol '%s' answer code %d",
  1270.              p_sys->psz_protocol, p_sys->i_code );
  1271.     if( !strcmp( p_sys->psz_protocol, "ICY" ) )
  1272.     {
  1273.         p_sys->b_seekable = false;
  1274.     }
  1275.     if( p_sys->i_code != 206 && p_sys->i_code != 401 )
  1276.     {
  1277.         p_sys->b_seekable = false;
  1278.     }
  1279.     /* Authentication error - We'll have to display the dialog */
  1280.     if( p_sys->i_code == 401 )
  1281.     {
  1283.     }
  1284.     /* Other fatal error */
  1285.     else if( p_sys->i_code >= 400 )
  1286.     {
  1287.         msg_Err( p_access, "error: %s", psz );
  1288.         free( psz );
  1289.         goto error;
  1290.     }
  1291.     free( psz );
  1293.     for( ;; )
  1294.     {
  1295.         char *psz = net_Gets( VLC_OBJECT(p_access), p_sys->fd, pvs );
  1296.         char *p;
  1298.         if( psz == NULL )
  1299.         {
  1300.             msg_Err( p_access, "failed to read answer" );
  1301.             goto error;
  1302.         }
  1304.         if( !vlc_object_alive (p_access) || p_access->b_error )
  1305.         {
  1306.             free( psz );
  1307.             goto error;
  1308.         }
  1310.         /* msg_Dbg( p_input, "Line=%s", psz ); */
  1311.         if( *psz == '' )
  1312.         {
  1313.             free( psz );
  1314.             break;
  1315.         }
  1317.         if( ( p = strchr( psz, ':' ) ) == NULL )
  1318.         {
  1319.             msg_Err( p_access, "malformed header line: %s", psz );
  1320.             free( psz );
  1321.             goto error;
  1322.         }
  1323.         *p++ = '';
  1324.         while( *p == ' ' ) p++;
  1326.         if( !strcasecmp( psz, "Content-Length" ) )
  1327.         {
  1328.             int64_t i_size = i_tell + (p_sys->i_remaining = atoll( p ));
  1329.             if(i_size > p_access->info.i_size) {
  1330.                 p_access->info.i_size = i_size;
  1331.             }
  1332.             msg_Dbg( p_access, "this frame size=%"PRId64, p_sys->i_remaining );
  1333.         }
  1334.         else if( !strcasecmp( psz, "Content-Range" ) ) {
  1335.             int64_t i_ntell = i_tell;
  1336.             int64_t i_nend = (p_access->info.i_size > 0)?(p_access->info.i_size - 1):i_tell;
  1337.             int64_t i_nsize = p_access->info.i_size;
  1338.             sscanf(p,"bytes %"PRId64"-%"PRId64"/%"PRId64,&i_ntell,&i_nend,&i_nsize);
  1339.             if(i_nend > i_ntell ) {
  1340.                 p_access->info.i_pos = i_ntell;
  1341.                 p_sys->i_remaining = i_nend+1-i_ntell;
  1342.                 int64_t i_size = (i_nsize > i_nend) ? i_nsize : (i_nend + 1);
  1343.                 if(i_size > p_access->info.i_size) {
  1344.                     p_access->info.i_size = i_size;
  1345.                 }
  1346.                 msg_Dbg( p_access, "stream size=%"PRId64",pos=%"PRId64",remaining=%"PRId64,i_nsize,i_ntell,p_sys->i_remaining);
  1347.             }
  1348.         }
  1349.         else if( !strcasecmp( psz, "Connection" ) ) {
  1350.             msg_Dbg( p_access, "Connection: %s",p );
  1351.             int i = -1;
  1352.             sscanf(p, "close%n",&i);
  1353.             if( i >= 0 ) {
  1354.                 p_sys->b_persist = false;
  1355.             }
  1356.         }
  1357.         else if( !strcasecmp( psz, "Location" ) )
  1358.         {
  1359.             char * psz_new_loc;
  1361.             /* This does not follow RFC 2068, but yet if the url is not absolute,
  1362.              * handle it as everyone does. */
  1363.             if( p[0] == '/' )
  1364.             {
  1365.                 const char *psz_http_ext = p_sys->b_ssl ? "s" : "" ;
  1367.                 if( p_sys->url.i_port == ( p_sys->b_ssl ? 443 : 80 ) )
  1368.                 {
  1369.                     if( asprintf(&psz_new_loc, "http%s://%s%s", psz_http_ext,
  1370.                                  p_sys->url.psz_host, p) < 0 )
  1371.                         goto error;
  1372.                 }
  1373.                 else
  1374.                 {
  1375.                     if( asprintf(&psz_new_loc, "http%s://%s:%d%s", psz_http_ext,
  1376.                                  p_sys->url.psz_host, p_sys->url.i_port, p) < 0 )
  1377.                         goto error;
  1378.                 }
  1379.             }
  1380.             else
  1381.             {
  1382.                 psz_new_loc = strdup( p );
  1383.             }
  1385.             free( p_sys->psz_location );
  1386.             p_sys->psz_location = psz_new_loc;
  1387.         }
  1388.         else if( !strcasecmp( psz, "Content-Type" ) )
  1389.         {
  1390.             free( p_sys->psz_mime );
  1391.             p_sys->psz_mime = strdup( p );
  1392.             msg_Dbg( p_access, "Content-Type: %s", p_sys->psz_mime );
  1393.         }
  1394.         else if( !strcasecmp( psz, "Content-Encoding" ) )
  1395.         {
  1396.             msg_Dbg( p_access, "Content-Encoding: %s", p );
  1397.             if( !strcasecmp( p, "identity" ) )
  1398.                 ;
  1399. #ifdef HAVE_ZLIB_H
  1400.             else if( !strcasecmp( p, "gzip" ) || !strcasecmp( p, "deflate" ) )
  1401.                 p_sys->b_compressed = true;
  1402. #endif
  1403.             else
  1404.                 msg_Warn( p_access, "Unknown content coding: %s", p );
  1405.         }
  1406.         else if( !strcasecmp( psz, "Pragma" ) )
  1407.         {
  1408.             if( !strcasecmp( psz, "Pragma: features" ) )
  1409.                 p_sys->b_mms = true;
  1410.             free( p_sys->psz_pragma );
  1411.             p_sys->psz_pragma = strdup( p );
  1412.             msg_Dbg( p_access, "Pragma: %s", p_sys->psz_pragma );
  1413.         }
  1414.         else if( !strcasecmp( psz, "Server" ) )
  1415.         {
  1416.             msg_Dbg( p_access, "Server: %s", p );
  1417.             if( !strncasecmp( p, "Icecast", 7 ) ||
  1418.                 !strncasecmp( p, "Nanocaster", 10 ) )
  1419.             {
  1420.                 /* Remember if this is Icecast
  1421.                  * we need to force demux in this case without breaking
  1422.                  *  autodetection */
  1424.                 /* Let live 365 streams (nanocaster) piggyback on the icecast
  1425.                  * routine. They look very similar */
  1427.                 p_sys->b_reconnect = true;
  1428.                 p_sys->b_pace_control = false;
  1429.                 p_sys->b_icecast = true;
  1430.             }
  1431.         }
  1432.         else if( !strcasecmp( psz, "Transfer-Encoding" ) )
  1433.         {
  1434.             msg_Dbg( p_access, "Transfer-Encoding: %s", p );
  1435.             if( !strncasecmp( p, "chunked", 7 ) )
  1436.             {
  1437.                 p_sys->b_chunked = true;
  1438.             }
  1439.         }
  1440.         else if( !strcasecmp( psz, "Icy-MetaInt" ) )
  1441.         {
  1442.             msg_Dbg( p_access, "Icy-MetaInt: %s", p );
  1443.             p_sys->i_icy_meta = atoi( p );
  1444.             if( p_sys->i_icy_meta < 0 )
  1445.                 p_sys->i_icy_meta = 0;
  1446.             if( p_sys->i_icy_meta > 0 )
  1447.                 p_sys->b_icecast = true;
  1449.             msg_Warn( p_access, "ICY metaint=%d", p_sys->i_icy_meta );
  1450.         }
  1451.         else if( !strcasecmp( psz, "Icy-Name" ) )
  1452.         {
  1453.             free( p_sys->psz_icy_name );
  1454.             char *psz_tmp = strdup( p );
  1455.             p_sys->psz_icy_name = EnsureUTF8( psz_tmp );
  1456.             if( !p_sys->psz_icy_name )
  1457.                 free( psz_tmp );
  1458.             msg_Dbg( p_access, "Icy-Name: %s", p_sys->psz_icy_name );
  1460.             p_sys->b_icecast = true; /* be on the safeside. set it here as well. */
  1461.             p_sys->b_reconnect = true;
  1462.             p_sys->b_pace_control = false;
  1463.         }
  1464.         else if( !strcasecmp( psz, "Icy-Genre" ) )
  1465.         {
  1466.             free( p_sys->psz_icy_genre );
  1467.             char *psz_tmp = strdup( p );
  1468.             p_sys->psz_icy_genre = EnsureUTF8( psz_tmp );
  1469.             if( !p_sys->psz_icy_genre )
  1470.                 free( psz_tmp );
  1471.             msg_Dbg( p_access, "Icy-Genre: %s", p_sys->psz_icy_genre );
  1472.         }
  1473.         else if( !strncasecmp( psz, "Icy-Notice", 10 ) )
  1474.         {
  1475.             msg_Dbg( p_access, "Icy-Notice: %s", p );
  1476.         }
  1477.         else if( !strncasecmp( psz, "icy-", 4 ) ||
  1478.                  !strncasecmp( psz, "ice-", 4 ) ||
  1479.                  !strncasecmp( psz, "x-audiocast", 11 ) )
  1480.         {
  1481.             msg_Dbg( p_access, "Meta-Info: %s: %s", psz, p );
  1482.         }
  1483.         else if( !strcasecmp( psz, "Set-Cookie" ) )
  1484.         {
  1485.             if( p_sys->cookies )
  1486.             {
  1487.                 msg_Dbg( p_access, "Accepting Cookie: %s", p );
  1488.                 cookie_append( p_sys->cookies, strdup(p) );
  1489.             }
  1490.             else
  1491.                 msg_Dbg( p_access, "We have a Cookie we won't remember: %s", p );
  1492.         }
  1493.         else if( !strcasecmp( psz, "www-authenticate" ) )
  1494.         {
  1495.             msg_Dbg( p_access, "Authentication header: %s", p );
  1496.             AuthParseHeader( p_access, p, &p_sys->auth );
  1497.         }
  1498.         else if( !strcasecmp( psz, "proxy-authenticate" ) )
  1499.         {
  1500.             msg_Dbg( p_access, "Proxy authentication header: %s", p );
  1501.             AuthParseHeader( p_access, p, &p_sys->proxy_auth );
  1502.         }
  1503.         else if( !strcasecmp( psz, "authentication-info" ) )
  1504.         {
  1505.             msg_Dbg( p_access, "Authentication Info header: %s", p );
  1506.             if( AuthCheckReply( p_access, p, &p_sys->url, &p_sys->auth ) )
  1507.                 goto error;
  1508.         }
  1509.         else if( !strcasecmp( psz, "proxy-authentication-info" ) )
  1510.         {
  1511.             msg_Dbg( p_access, "Proxy Authentication Info header: %s", p );
  1512.             if( AuthCheckReply( p_access, p, &p_sys->proxy, &p_sys->proxy_auth ) )
  1513.                 goto error;
  1514.         }
  1516.         free( psz );
  1517.     }
  1518.     /* We close the stream for zero length data, unless of course the
  1519.      * server has already promised to do this for us.
  1520.      */
  1521.     if( p_access->info.i_size != -1 && p_sys->i_remaining == 0 && p_sys->b_persist ) {
  1522.         Disconnect( p_access );
  1523.     }
  1524.     return VLC_SUCCESS;
  1526. error:
  1527.     Disconnect( p_access );
  1528.     return VLC_EGENERIC;
  1529. }
  1531. /*****************************************************************************
  1532.  * Disconnect:
  1533.  *****************************************************************************/
  1534. static void Disconnect( access_t *p_access )
  1535. {
  1536.     access_sys_t *p_sys = p_access->p_sys;
  1538.     if( p_sys->p_tls != NULL)
  1539.     {
  1540.         tls_ClientDelete( p_sys->p_tls );
  1541.         p_sys->p_tls = NULL;
  1542.         p_sys->p_vs = NULL;
  1543.     }
  1544.     if( p_sys->fd != -1)
  1545.     {
  1546.         net_Close(p_sys->fd);
  1547.         p_sys->fd = -1;
  1548.     }
  1550. }
  1552. /*****************************************************************************
  1553.  * Cookies (FIXME: we may want to rewrite that using a nice structure to hold
  1554.  * them) (FIXME: only support the "domain=" param)
  1555.  *****************************************************************************/
  1557. /* Get the NAME=VALUE part of the Cookie */
  1558. static char * cookie_get_content( const char * cookie )
  1559. {
  1560.     char * ret = strdup( cookie );
  1561.     if( !ret ) return NULL;
  1562.     char * str = ret;
  1563.     /* Look for a ';' */
  1564.     while( *str && *str != ';' ) str++;
  1565.     /* Replace it by a end-char */
  1566.     if( *str == ';' ) *str = 0;
  1567.     return ret;
  1568. }
  1570. /* Get the domain where the cookie is stored */
  1571. static char * cookie_get_domain( const char * cookie )
  1572. {
  1573.     const char * str = cookie;
  1574.     static const char domain[] = "domain=";
  1575.     if( !str )
  1576.         return NULL;
  1577.     /* Look for a ';' */
  1578.     while( *str )
  1579.     {
  1580.         if( !strncmp( str, domain, sizeof(domain) - 1 /* minus  */ ) )
  1581.         {
  1582.             str += sizeof(domain) - 1 /* minus  */;
  1583.             char * ret = strdup( str );
  1584.             /* Now remove the next ';' if present */
  1585.             char * ret_iter = ret;
  1586.             while( *ret_iter && *ret_iter != ';' ) ret_iter++;
  1587.             if( *ret_iter == ';' )
  1588.                 *ret_iter = 0;
  1589.             return ret;
  1590.         }
  1591.         /* Go to next ';' field */
  1592.         while( *str && *str != ';' ) str++;
  1593.         if( *str == ';' ) str++;
  1594.         /* skip blank */
  1595.         while( *str && *str == ' ' ) str++;
  1596.     }
  1597.     return NULL;
  1598. }
  1600. /* Get NAME in the NAME=VALUE field */
  1601. static char * cookie_get_name( const char * cookie )
  1602. {
  1603.     char * ret = cookie_get_content( cookie ); /* NAME=VALUE */
  1604.     if( !ret ) return NULL;
  1605.     char * str = ret;
  1606.     while( *str && *str != '=' ) str++;
  1607.     *str = 0;
  1608.     return ret;
  1609. }
  1611. /* Add a cookie in cookies, checking to see how it should be added */
  1612. static void cookie_append( vlc_array_t * cookies, char * cookie )
  1613. {
  1614.     int i;
  1616.     if( !cookie )
  1617.         return;
  1619.     char * cookie_name = cookie_get_name( cookie );
  1621.     /* Don't send invalid cookies */
  1622.     if( !cookie_name )
  1623.         return;
  1625.     char * cookie_domain = cookie_get_domain( cookie );
  1626.     for( i = 0; i < vlc_array_count( cookies ); i++ )
  1627.     {
  1628.         char * current_cookie = vlc_array_item_at_index( cookies, i );
  1629.         char * current_cookie_name = cookie_get_name( current_cookie );
  1630.         char * current_cookie_domain = cookie_get_domain( current_cookie );
  1632.         assert( current_cookie_name );
  1634.         bool is_domain_matching = ( cookie_domain && current_cookie_domain &&
  1635.                                          !strcmp( cookie_domain, current_cookie_domain ) );
  1637.         if( is_domain_matching && !strcmp( cookie_name, current_cookie_name )  )
  1638.         {
  1639.             /* Remove previous value for this cookie */
  1640.             free( current_cookie );
  1641.             vlc_array_remove( cookies, i );
  1643.             /* Clean */
  1644.             free( current_cookie_name );
  1645.             free( current_cookie_domain );
  1646.             break;
  1647.         }
  1648.         free( current_cookie_name );
  1649.         free( current_cookie_domain );
  1650.     }
  1651.     free( cookie_name );
  1652.     free( cookie_domain );
  1653.     vlc_array_append( cookies, cookie );
  1654. }
  1656. /*****************************************************************************
  1657.  * "RFC 2617: Basic and Digest Access Authentication" header parsing
  1658.  *****************************************************************************/
  1659. static char *AuthGetParam( const char *psz_header, const char *psz_param )
  1660. {
  1661.     char psz_what[strlen(psz_param)+3];
  1662.     sprintf( psz_what, "%s="", psz_param );
  1663.     psz_header = strstr( psz_header, psz_what );
  1664.     if( psz_header )
  1665.     {
  1666.         const char *psz_end;
  1667.         psz_header += strlen( psz_what );
  1668.         psz_end = strchr( psz_header, '"' );
  1669.         if( !psz_end ) /* Invalid since we should have a closing quote */
  1670.             return strdup( psz_header );
  1671.         return strndup( psz_header, psz_end - psz_header );
  1672.     }
  1673.     else
  1674.     {
  1675.         return NULL;
  1676.     }
  1677. }
  1679. static char *AuthGetParamNoQuotes( const char *psz_header, const char *psz_param )
  1680. {
  1681.     char psz_what[strlen(psz_param)+2];
  1682.     sprintf( psz_what, "%s=", psz_param );
  1683.     psz_header = strstr( psz_header, psz_what );
  1684.     if( psz_header )
  1685.     {
  1686.         const char *psz_end;
  1687.         psz_header += strlen( psz_what );
  1688.         psz_end = strchr( psz_header, ',' );
  1689.         /* XXX: Do we need to filter out trailing space between the value and
  1690.          * the comma/end of line? */
  1691.         if( !psz_end ) /* Can be valid if this is the last parameter */
  1692.             return strdup( psz_header );
  1693.         return strndup( psz_header, psz_end - psz_header );
  1694.     }
  1695.     else
  1696.     {
  1697.         return NULL;
  1698.     }
  1699. }
  1701. static void AuthParseHeader( access_t *p_access, const char *psz_header,
  1702.                              http_auth_t *p_auth )
  1703. {
  1704.     /* FIXME: multiple auth methods can be listed (comma seperated) */
  1706.     /* 2 Basic Authentication Scheme */
  1707.     if( !strncasecmp( psz_header, "Basic ", strlen( "Basic " ) ) )
  1708.     {
  1709.         msg_Dbg( p_access, "Using Basic Authentication" );
  1710.         psz_header += strlen( "Basic " );
  1711.         p_auth->psz_realm = AuthGetParam( psz_header, "realm" );
  1712.         if( !p_auth->psz_realm )
  1713.             msg_Warn( p_access, "Basic Authentication: "
  1714.                       "Mandatory 'realm' parameter is missing" );
  1715.     }
  1716.     /* 3 Digest Access Authentication Scheme */
  1717.     else if( !strncasecmp( psz_header, "Digest ", strlen( "Digest " ) ) )
  1718.     {
  1719.         msg_Dbg( p_access, "Using Digest Access Authentication" );
  1720.         if( p_auth->psz_nonce ) return; /* FIXME */
  1721.         psz_header += strlen( "Digest " );
  1722.         p_auth->psz_realm = AuthGetParam( psz_header, "realm" );
  1723.         p_auth->psz_domain = AuthGetParam( psz_header, "domain" );
  1724.         p_auth->psz_nonce = AuthGetParam( psz_header, "nonce" );
  1725.         p_auth->psz_opaque = AuthGetParam( psz_header, "opaque" );
  1726.         p_auth->psz_stale = AuthGetParamNoQuotes( psz_header, "stale" );
  1727.         p_auth->psz_algorithm = AuthGetParamNoQuotes( psz_header, "algorithm" );
  1728.         p_auth->psz_qop = AuthGetParam( psz_header, "qop" );
  1729.         p_auth->i_nonce = 0;
  1730.         /* printf("realm: |%s|ndomain: |%s|nnonce: |%s|nopaque: |%s|n"
  1731.                   "stale: |%s|nalgorithm: |%s|nqop: |%s|n",
  1732.                   p_auth->psz_realm,p_auth->psz_domain,p_auth->psz_nonce,
  1733.                   p_auth->psz_opaque,p_auth->psz_stale,p_auth->psz_algorithm,
  1734.                   p_auth->psz_qop); */
  1735.         if( !p_auth->psz_realm )
  1736.             msg_Warn( p_access, "Digest Access Authentication: "
  1737.                       "Mandatory 'realm' parameter is missing" );
  1738.         if( !p_auth->psz_nonce )
  1739.             msg_Warn( p_access, "Digest Access Authentication: "
  1740.                       "Mandatory 'nonce' parameter is missing" );
  1741.         if( p_auth->psz_qop ) /* FIXME: parse the qop list */
  1742.         {
  1743.             char *psz_tmp = strchr( p_auth->psz_qop, ',' );
  1744.             if( psz_tmp ) *psz_tmp = '';
  1745.         }
  1746.     }
  1747.     else
  1748.     {
  1749.         const char *psz_end = strchr( psz_header, ' ' );
  1750.         if( psz_end )
  1751.             msg_Warn( p_access, "Unknown authentication scheme: '%*s'",
  1752.                       (int)(psz_end - psz_header), psz_header );
  1753.         else
  1754.             msg_Warn( p_access, "Unknown authentication scheme: '%s'",
  1755.                       psz_header );
  1756.     }
  1757. }
  1759. static char *AuthDigest( access_t *p_access, vlc_url_t *p_url,
  1760.                          http_auth_t *p_auth, const char *psz_method )
  1761. {
  1762.     (void)p_access;
  1763.     const char *psz_username = p_url->psz_username ? p_url->psz_username : "";
  1764.     const char *psz_password = p_url->psz_password ? p_url->psz_password : "";
  1766.     char *psz_HA1 = NULL;
  1767.     char *psz_HA2 = NULL;
  1768.     char *psz_response = NULL;
  1769.     struct md5_s md5;
  1771.     /* H(A1) */
  1772.     if( p_auth->psz_HA1 )
  1773.     {
  1774.         psz_HA1 = strdup( p_auth->psz_HA1 );
  1775.         if( !psz_HA1 ) goto error;
  1776.     }
  1777.     else
  1778.     {
  1779.         InitMD5( &md5 );
  1780.         AddMD5( &md5, psz_username, strlen( psz_username ) );
  1781.         AddMD5( &md5, ":", 1 );
  1782.         AddMD5( &md5, p_auth->psz_realm, strlen( p_auth->psz_realm ) );
  1783.         AddMD5( &md5, ":", 1 );
  1784.         AddMD5( &md5, psz_password, strlen( psz_password ) );
  1785.         EndMD5( &md5 );
  1787.         psz_HA1 = psz_md5_hash( &md5 );
  1788.         if( !psz_HA1 ) goto error;
  1790.         if( p_auth->psz_algorithm
  1791.             && !strcmp( p_auth->psz_algorithm, "MD5-sess" ) )
  1792.         {
  1793.             InitMD5( &md5 );
  1794.             AddMD5( &md5, psz_HA1, 32 );
  1795.             free( psz_HA1 );
  1796.             AddMD5( &md5, ":", 1 );
  1797.             AddMD5( &md5, p_auth->psz_nonce, strlen( p_auth->psz_nonce ) );
  1798.             AddMD5( &md5, ":", 1 );
  1799.             AddMD5( &md5, p_auth->psz_cnonce, strlen( p_auth->psz_cnonce ) );
  1800.             EndMD5( &md5 );
  1802.             psz_HA1 = psz_md5_hash( &md5 );
  1803.             if( !psz_HA1 ) goto error;
  1804.             p_auth->psz_HA1 = strdup( psz_HA1 );
  1805.             if( !p_auth->psz_HA1 ) goto error;
  1806.         }
  1807.     }
  1809.     /* H(A2) */
  1810.     InitMD5( &md5 );
  1811.     if( *psz_method )
  1812.         AddMD5( &md5, psz_method, strlen( psz_method ) );
  1813.     AddMD5( &md5, ":", 1 );
  1814.     if( p_url->psz_path )
  1815.         AddMD5( &md5, p_url->psz_path, strlen( p_url->psz_path ) );
  1816.     else
  1817.         AddMD5( &md5, "/", 1 );
  1818.     if( p_auth->psz_qop && !strcmp( p_auth->psz_qop, "auth-int" ) )
  1819.     {
  1820.         char *psz_ent;
  1821.         struct md5_s ent;
  1822.         InitMD5( &ent );
  1823.         AddMD5( &ent, "", 0 ); /* XXX: entity-body. should be ok for GET */
  1824.         EndMD5( &ent );
  1825.         psz_ent = psz_md5_hash( &ent );
  1826.         if( !psz_ent ) goto error;
  1827.         AddMD5( &md5, ":", 1 );
  1828.         AddMD5( &md5, psz_ent, 32 );
  1829.         free( psz_ent );
  1830.     }
  1831.     EndMD5( &md5 );
  1832.     psz_HA2 = psz_md5_hash( &md5 );
  1833.     if( !psz_HA2 ) goto error;
  1835.     /* Request digest */
  1836.     InitMD5( &md5 );
  1837.     AddMD5( &md5, psz_HA1, 32 );
  1838.     AddMD5( &md5, ":", 1 );
  1839.     AddMD5( &md5, p_auth->psz_nonce, strlen( p_auth->psz_nonce ) );
  1840.     AddMD5( &md5, ":", 1 );
  1841.     if( p_auth->psz_qop
  1842.         && ( !strcmp( p_auth->psz_qop, "auth" )
  1843.              || !strcmp( p_auth->psz_qop, "auth-int" ) ) )
  1844.     {
  1845.         char psz_inonce[9];
  1846.         snprintf( psz_inonce, 9, "%08x", p_auth->i_nonce );
  1847.         AddMD5( &md5, psz_inonce, 8 );
  1848.         AddMD5( &md5, ":", 1 );
  1849.         AddMD5( &md5, p_auth->psz_cnonce, strlen( p_auth->psz_cnonce ) );
  1850.         AddMD5( &md5, ":", 1 );
  1851.         AddMD5( &md5, p_auth->psz_qop, strlen( p_auth->psz_qop ) );
  1852.         AddMD5( &md5, ":", 1 );
  1853.     }
  1854.     AddMD5( &md5, psz_HA2, 32 );
  1855.     EndMD5( &md5 );
  1856.     psz_response = psz_md5_hash( &md5 );
  1858.     error:
  1859.         free( psz_HA1 );
  1860.         free( psz_HA2 );
  1861.         return psz_response;
  1862. }
  1865. static void AuthReply( access_t *p_access, const char *psz_prefix,
  1866.                        vlc_url_t *p_url, http_auth_t *p_auth )
  1867. {
  1868.     access_sys_t *p_sys = p_access->p_sys;
  1869.     v_socket_t     *pvs = p_sys->p_vs;
  1871.     const char *psz_username = p_url->psz_username ? p_url->psz_username : "";
  1872.     const char *psz_password = p_url->psz_password ? p_url->psz_password : "";
  1874.     if( p_auth->psz_nonce )
  1875.     {
  1876.         /* Digest Access Authentication */
  1877.         char *psz_response;
  1879.         if(    p_auth->psz_algorithm
  1880.             && strcmp( p_auth->psz_algorithm, "MD5" )
  1881.             && strcmp( p_auth->psz_algorithm, "MD5-sess" ) )
  1882.         {
  1883.             msg_Err( p_access, "Digest Access Authentication: "
  1884.                      "Unknown algorithm '%s'", p_auth->psz_algorithm );
  1885.             return;
  1886.         }
  1888.         if( p_auth->psz_qop || !p_auth->psz_cnonce )
  1889.         {
  1890.             /* FIXME: needs to be really random to prevent man in the middle
  1891.              * attacks */
  1892.             free( p_auth->psz_cnonce );
  1893.             p_auth->psz_cnonce = strdup( "Some random string FIXME" );
  1894.         }
  1895.         p_auth->i_nonce ++;
  1897.         psz_response = AuthDigest( p_access, p_url, p_auth, "GET" );
  1898.         if( !psz_response ) return;
  1900.         net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
  1901.                     "%sAuthorization: Digest "
  1902.                     /* Mandatory parameters */
  1903.                     "username="%s", "
  1904.                     "realm="%s", "
  1905.                     "nonce="%s", "
  1906.                     "uri="%s", "
  1907.                     "response="%s", "
  1908.                     /* Optional parameters */
  1909.                     "%s%s%s" /* algorithm */
  1910.                     "%s%s%s" /* cnonce */
  1911.                     "%s%s%s" /* opaque */
  1912.                     "%s%s%s" /* message qop */
  1913.                     "%s%08x%s" /* nonce count */
  1914.                     "rn",
  1915.                     /* Mandatory parameters */
  1916.                     psz_prefix,
  1917.                     psz_username,
  1918.                     p_auth->psz_realm,
  1919.                     p_auth->psz_nonce,
  1920.                     p_url->psz_path ? p_url->psz_path : "/",
  1921.                     psz_response,
  1922.                     /* Optional parameters */
  1923.                     p_auth->psz_algorithm ? "algorithm="" : "",
  1924.                     p_auth->psz_algorithm ? p_auth->psz_algorithm : "",
  1925.                     p_auth->psz_algorithm ? "", " : "",
  1926.                     p_auth->psz_cnonce ? "cnonce="" : "",
  1927.                     p_auth->psz_cnonce ? p_auth->psz_cnonce : "",
  1928.                     p_auth->psz_cnonce ? "", " : "",
  1929.                     p_auth->psz_opaque ? "opaque="" : "",
  1930.                     p_auth->psz_opaque ? p_auth->psz_opaque : "",
  1931.                     p_auth->psz_opaque ? "", " : "",
  1932.                     p_auth->psz_qop ? "qop="" : "",
  1933.                     p_auth->psz_qop ? p_auth->psz_qop : "",
  1934.                     p_auth->psz_qop ? "", " : "",
  1935.                     p_auth->i_nonce ? "nc="" : "uglyhack="", /* Will be parsed as an unhandled extension */
  1936.                     p_auth->i_nonce,
  1937.                     p_auth->i_nonce ? """ : """
  1938.                   );
  1940.         free( psz_response );
  1941.     }
  1942.     else
  1943.     {
  1944.         /* Basic Access Authentication */
  1945.         char buf[strlen( psz_username ) + strlen( psz_password ) + 2];
  1946.         char *b64;
  1948.         snprintf( buf, sizeof( buf ), "%s:%s", psz_username, psz_password );
  1949.         b64 = vlc_b64_encode( buf );
  1951.         if( b64 != NULL )
  1952.         {
  1953.              net_Printf( VLC_OBJECT(p_access), p_sys->fd, pvs,
  1954.                          "%sAuthorization: Basic %srn", psz_prefix, b64 );
  1955.              free( b64 );
  1956.         }
  1957.     }
  1958. }
  1960. static int AuthCheckReply( access_t *p_access, const char *psz_header,
  1961.                            vlc_url_t *p_url, http_auth_t *p_auth )
  1962. {
  1963.     int i_ret = VLC_EGENERIC;
  1964.     char *psz_nextnonce = AuthGetParam( psz_header, "nextnonce" );
  1965.     char *psz_qop = AuthGetParamNoQuotes( psz_header, "qop" );
  1966.     char *psz_rspauth = AuthGetParam( psz_header, "rspauth" );
  1967.     char *psz_cnonce = AuthGetParam( psz_header, "cnonce" );
  1968.     char *psz_nc = AuthGetParamNoQuotes( psz_header, "nc" );
  1970.     if( psz_cnonce )
  1971.     {
  1972.         char *psz_digest;
  1974.         if( strcmp( psz_cnonce, p_auth->psz_cnonce ) )
  1975.         {
  1976.             msg_Err( p_access, "HTTP Digest Access Authentication: server replied with a different client nonce value." );
  1977.             goto error;
  1978.         }
  1980.         if( psz_nc )
  1981.         {
  1982.             int i_nonce;
  1983.             i_nonce = strtol( psz_nc, NULL, 16 );
  1984.             if( i_nonce != p_auth->i_nonce )
  1985.             {
  1986.                 msg_Err( p_access, "HTTP Digest Access Authentication: server replied with a different nonce count value." );
  1987.                 goto error;
  1988.             }
  1989.         }
  1991.         if( psz_qop && p_auth->psz_qop && strcmp( psz_qop, p_auth->psz_qop ) )
  1992.             msg_Warn( p_access, "HTTP Digest Access Authentication: server replied using a different 'quality of protection' option" );
  1994.         /* All the clear text values match, let's now check the response
  1995.          * digest */
  1996.         psz_digest = AuthDigest( p_access, p_url, p_auth, "" );
  1997.         if( strcmp( psz_digest, psz_rspauth ) )
  1998.         {
  1999.             msg_Err( p_access, "HTTP Digest Access Authentication: server replied with an invalid response digest (expected value: %s).", psz_digest );
  2000.             free( psz_digest );
  2001.             goto error;
  2002.         }
  2003.         free( psz_digest );
  2004.     }
  2006.     if( psz_nextnonce )
  2007.     {
  2008.         free( p_auth->psz_nonce );
  2009.         p_auth->psz_nonce = psz_nextnonce;
  2010.         psz_nextnonce = NULL;
  2011.     }
  2013.     i_ret = VLC_SUCCESS;
  2014.     error:
  2015.         free( psz_nextnonce );
  2016.         free( psz_qop );
  2017.         free( psz_rspauth );
  2018.         free( psz_cnonce );
  2019.         free( psz_nc );
  2021.     return i_ret;
  2022. }
  2024. static void AuthReset( http_auth_t *p_auth )
  2025. {
  2026.     FREENULL( p_auth->psz_realm );
  2027.     FREENULL( p_auth->psz_domain );
  2028.     FREENULL( p_auth->psz_nonce );
  2029.     FREENULL( p_auth->psz_opaque );
  2030.     FREENULL( p_auth->psz_stale );
  2031.     FREENULL( p_auth->psz_algorithm );
  2032.     FREENULL( p_auth->psz_qop );
  2033.     p_auth->i_nonce = 0;
  2034.     FREENULL( p_auth->psz_cnonce );
  2035.     FREENULL( p_auth->psz_HA1 );
  2036. }