code.vuplus.com Git - vuplus_xbmc/blob - xbmc/filesystem/CurlFile.cpp

   1 /*
   2  *      Copyright (C) 2005-2013 Team XBMC
   3  *      http://xbmc.org
   4  *
   5  *  This Program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2, or (at your option)
   8  *  any later version.
   9  *
  10  *  This Program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with XBMC; see the file COPYING.  If not, see
  17  *  <http://www.gnu.org/licenses/>.
  18  *
  19  */
  20
  21 #include "CurlFile.h"
  22 #include "utils/URIUtils.h"
  23 #include "Util.h"
  24 #include "URL.h"
  25 #include "settings/AdvancedSettings.h"
  26 #include "settings/Settings.h"
  27 #include "File.h"
  28
  29 #include <vector>
  30 #include <climits>
  31
  32 #ifdef TARGET_POSIX
  33 #include <errno.h>
  34 #include <inttypes.h>
  35 #include "../linux/XFileUtils.h"
  36 #include "../linux/XTimeUtils.h"
  37 #include "../linux/ConvUtils.h"
  38 #endif
  39
  40 #include "DllLibCurl.h"
  41 #include "ShoutcastFile.h"
  42 #include "SpecialProtocol.h"
  43 #include "utils/CharsetConverter.h"
  44 #include "utils/log.h"
  45 #include "utils/StringUtils.h"
  46
  47 using namespace XFILE;
  48 using namespace XCURL;
  49
  50 #define XMIN(a,b) ((a)<(b)?(a):(b))
  51 #define FITS_INT(a) (((a) <= INT_MAX) && ((a) >= INT_MIN))
  52
  53 #define dllselect select
  54
  55
  56 curl_proxytype proxyType2CUrlProxyType[] = {
  57   CURLPROXY_HTTP,
  58   CURLPROXY_SOCKS4,
  59   CURLPROXY_SOCKS4A,
  60   CURLPROXY_SOCKS5,
  61   CURLPROXY_SOCKS5_HOSTNAME,
  62 };
  63
  64 // curl calls this routine to debug
  65 extern "C" int debug_callback(CURL_HANDLE *handle, curl_infotype info, char *output, size_t size, void *data)
  66 {
  67   if (info == CURLINFO_DATA_IN || info == CURLINFO_DATA_OUT)
  68     return 0;
  69
  70   if ((g_advancedSettings.m_extraLogLevels & LOGCURL) == 0)
  71     return 0;
  72
  73   CStdString strLine;
  74   strLine.append(output, size);
  75   std::vector<std::string> vecLines;
  76   StringUtils::Tokenize(strLine, vecLines, "\r\n");
  77   std::vector<std::string>::const_iterator it = vecLines.begin();
  78
  79   char *infotype;
  80   switch(info)
  81   {
  82     case CURLINFO_TEXT         : infotype = (char *) "TEXT: "; break;
  83     case CURLINFO_HEADER_IN    : infotype = (char *) "HEADER_IN: "; break;
  84     case CURLINFO_HEADER_OUT   : infotype = (char *) "HEADER_OUT: "; break;
  85     case CURLINFO_SSL_DATA_IN  : infotype = (char *) "SSL_DATA_IN: "; break;
  86     case CURLINFO_SSL_DATA_OUT : infotype = (char *) "SSL_DATA_OUT: "; break;
  87     case CURLINFO_END          : infotype = (char *) "END: "; break;
  88     default                    : infotype = (char *) ""; break;
  89   }
  90
  91   while (it != vecLines.end())
  92   {
  93     CLog::Log(LOGDEBUG, "Curl::Debug - %s%s", infotype, (*it).c_str());
  94     it++;
  95   }
  96   return 0;
  97 }
  98
  99 /* curl calls this routine to get more data */
 100 extern "C" size_t write_callback(char *buffer,
 101                size_t size,
 102                size_t nitems,
 103                void *userp)
 104 {
 105   if(userp == NULL) return 0;
 106
 107   CCurlFile::CReadState *state = (CCurlFile::CReadState *)userp;
 108   return state->WriteCallback(buffer, size, nitems);
 109 }
 110
 111 extern "C" size_t read_callback(char *buffer,
 112                size_t size,
 113                size_t nitems,
 114                void *userp)
 115 {
 116   if(userp == NULL) return 0;
 117
 118   CCurlFile::CReadState *state = (CCurlFile::CReadState *)userp;
 119   return state->ReadCallback(buffer, size, nitems);
 120 }
 121
 122 extern "C" size_t header_callback(void *ptr, size_t size, size_t nmemb, void *stream)
 123 {
 124   CCurlFile::CReadState *state = (CCurlFile::CReadState *)stream;
 125   return state->HeaderCallback(ptr, size, nmemb);
 126 }
 127
 128 /* fix for silly behavior of realloc */
 129 static inline void* realloc_simple(void *ptr, size_t size)
 130 {
 131   void *ptr2 = realloc(ptr, size);
 132   if(ptr && !ptr2 && size > 0)
 133   {
 134     free(ptr);
 135     return NULL;
 136   }
 137   else
 138     return ptr2;
 139 }
 140
 141 size_t CCurlFile::CReadState::HeaderCallback(void *ptr, size_t size, size_t nmemb)
 142 {
 143   std::string inString;
 144   // libcurl doc says that this info is not always \0 terminated
 145   const char* strBuf = (const char*)ptr;
 146   const size_t iSize = size * nmemb;
 147   if (strBuf[iSize - 1] == 0)
 148     inString.assign(strBuf, iSize - 1); // skip last char if it's zero
 149   else
 150     inString.append(strBuf, iSize);
 151
 152   m_httpheader.Parse(inString);
 153
 154   return iSize;
 155 }
 156
 157 size_t CCurlFile::CReadState::ReadCallback(char *buffer, size_t size, size_t nitems)
 158 {
 159   if (m_fileSize == 0)
 160     return 0;
 161
 162   if (m_filePos >= m_fileSize)
 163   {
 164     m_isPaused = true;
 165     return CURL_READFUNC_PAUSE;
 166   }
 167
 168   int64_t retSize = XMIN(m_fileSize - m_filePos, int64_t(nitems * size));
 169   memcpy(buffer, m_readBuffer + m_filePos, retSize);
 170   m_filePos += retSize;
 171
 172   return retSize;
 173 }
 174
 175 size_t CCurlFile::CReadState::WriteCallback(char *buffer, size_t size, size_t nitems)
 176 {
 177   unsigned int amount = size * nitems;
 178 //  CLog::Log(LOGDEBUG, "CCurlFile::WriteCallback (%p) with %i bytes, readsize = %i, writesize = %i", this, amount, m_buffer.getMaxReadSize(), m_buffer.getMaxWriteSize() - m_overflowSize);
 179   if (m_overflowSize)
 180   {
 181     // we have our overflow buffer - first get rid of as much as we can
 182     unsigned int maxWriteable = XMIN((unsigned int)m_buffer.getMaxWriteSize(), m_overflowSize);
 183     if (maxWriteable)
 184     {
 185       if (!m_buffer.WriteData(m_overflowBuffer, maxWriteable))
 186         CLog::Log(LOGERROR, "CCurlFile::WriteCallback - Unable to write to buffer - what's up?");
 187       if (m_overflowSize > maxWriteable)
 188       { // still have some more - copy it down
 189         memmove(m_overflowBuffer, m_overflowBuffer + maxWriteable, m_overflowSize - maxWriteable);
 190       }
 191       m_overflowSize -= maxWriteable;
 192     }
 193   }
 194   // ok, now copy the data into our ring buffer
 195   unsigned int maxWriteable = XMIN((unsigned int)m_buffer.getMaxWriteSize(), amount);
 196   if (maxWriteable)
 197   {
 198     if (!m_buffer.WriteData(buffer, maxWriteable))
 199     {
 200       CLog::Log(LOGERROR, "CCurlFile::WriteCallback - Unable to write to buffer with %i bytes - what's up?", maxWriteable);
 201     }
 202     else
 203     {
 204       amount -= maxWriteable;
 205       buffer += maxWriteable;
 206     }
 207   }
 208   if (amount)
 209   {
 210 //    CLog::Log(LOGDEBUG, "CCurlFile::WriteCallback(%p) not enough free space for %i bytes", (void*)this,  amount);
 211
 212     m_overflowBuffer = (char*)realloc_simple(m_overflowBuffer, amount + m_overflowSize);
 213     if(m_overflowBuffer == NULL)
 214     {
 215       CLog::Log(LOGWARNING, "CCurlFile::WriteCallback - Failed to grow overflow buffer from %i bytes to %i bytes", m_overflowSize, amount + m_overflowSize);
 216       return 0;
 217     }
 218     memcpy(m_overflowBuffer + m_overflowSize, buffer, amount);
 219     m_overflowSize += amount;
 220   }
 221   return size * nitems;
 222 }
 223
 224 CCurlFile::CReadState::CReadState()
 225 {
 226   m_easyHandle = NULL;
 227   m_multiHandle = NULL;
 228   m_overflowBuffer = NULL;
 229   m_overflowSize = 0;
 230   m_filePos = 0;
 231   m_fileSize = 0;
 232   m_bufferSize = 0;
 233   m_cancelled = false;
 234   m_bFirstLoop = true;
 235   m_sendRange = true;
 236   m_readBuffer = 0;
 237   m_isPaused = false;
 238   m_curlHeaderList = NULL;
 239   m_curlAliasList = NULL;
 240 }
 241
 242 CCurlFile::CReadState::~CReadState()
 243 {
 244   Disconnect();
 245
 246   if(m_easyHandle)
 247     g_curlInterface.easy_release(&m_easyHandle, &m_multiHandle);
 248 }
 249
 250 bool CCurlFile::CReadState::Seek(int64_t pos)
 251 {
 252   if(pos == m_filePos)
 253     return true;
 254
 255   if(FITS_INT(pos - m_filePos) && m_buffer.SkipBytes((int)(pos - m_filePos)))
 256   {
 257     m_filePos = pos;
 258     return true;
 259   }
 260
 261   if(pos > m_filePos && pos < m_filePos + m_bufferSize)
 262   {
 263     int len = m_buffer.getMaxReadSize();
 264     m_filePos += len;
 265     m_buffer.SkipBytes(len);
 266     if(!FillBuffer(m_bufferSize))
 267     {
 268       if(!m_buffer.SkipBytes(-len))
 269         CLog::Log(LOGERROR, "%s - Failed to restore position after failed fill", __FUNCTION__);
 270       else
 271         m_filePos -= len;
 272       return false;
 273     }
 274
 275     if(!FITS_INT(pos - m_filePos) || !m_buffer.SkipBytes((int)(pos - m_filePos)))
 276     {
 277       CLog::Log(LOGERROR, "%s - Failed to skip to position after having filled buffer", __FUNCTION__);
 278       if(!m_buffer.SkipBytes(-len))
 279         CLog::Log(LOGERROR, "%s - Failed to restore position after failed seek", __FUNCTION__);
 280       else
 281         m_filePos -= len;
 282       return false;
 283     }
 284     m_filePos = pos;
 285     return true;
 286   }
 287   return false;
 288 }
 289
 290 void CCurlFile::CReadState::SetResume(void)
 291 {
 292   /*
 293    * Explicitly set RANGE header when filepos=0 as some http servers require us to always send the range
 294    * request header. If we don't the server may provide different content causing seeking to fail.
 295    * This only affects HTTP-like items, for FTP it's a null operation.
 296    */
 297   if (m_sendRange && m_filePos == 0)
 298     g_curlInterface.easy_setopt(m_easyHandle, CURLOPT_RANGE, "0-");
 299   else
 300   {
 301     g_curlInterface.easy_setopt(m_easyHandle, CURLOPT_RANGE, NULL);
 302     m_sendRange = false;
 303   }
 304
 305   g_curlInterface.easy_setopt(m_easyHandle, CURLOPT_RESUME_FROM_LARGE, m_filePos);
 306 }
 307
 308 long CCurlFile::CReadState::Connect(unsigned int size)
 309 {
 310   if (m_filePos != 0)
 311     CLog::Log(LOGDEBUG,"CurlFile::CReadState::Connect - Resume from position %"PRId64, m_filePos);
 312
 313   SetResume();
 314   g_curlInterface.multi_add_handle(m_multiHandle, m_easyHandle);
 315
 316   m_bufferSize = size;
 317   m_buffer.Destroy();
 318   m_buffer.Create(size * 3);
 319   m_httpheader.Clear();
 320
 321   // read some data in to try and obtain the length
 322   // maybe there's a better way to get this info??
 323   m_stillRunning = 1;
 324   if (!FillBuffer(1))
 325   {
 326     CLog::Log(LOGERROR, "CCurlFile::CReadState::Connect, didn't get any data from stream.");
 327     return -1;
 328   }
 329
 330   double length;
 331   if (CURLE_OK == g_curlInterface.easy_getinfo(m_easyHandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length))
 332   {
 333     if (length < 0)
 334       length = 0.0;
 335     m_fileSize = m_filePos + (int64_t)length;
 336   }
 337
 338   long response;
 339   if (CURLE_OK == g_curlInterface.easy_getinfo(m_easyHandle, CURLINFO_RESPONSE_CODE, &response))
 340     return response;
 341
 342   return -1;
 343 }
 344
 345 void CCurlFile::CReadState::Disconnect()
 346 {
 347   if(m_multiHandle && m_easyHandle)
 348     g_curlInterface.multi_remove_handle(m_multiHandle, m_easyHandle);
 349
 350   m_buffer.Clear();
 351   free(m_overflowBuffer);
 352   m_overflowBuffer = NULL;
 353   m_overflowSize = 0;
 354   m_filePos = 0;
 355   m_fileSize = 0;
 356   m_bufferSize = 0;
 357   m_readBuffer = 0;
 358
 359   /* cleanup */
 360   if( m_curlHeaderList )
 361     g_curlInterface.slist_free_all(m_curlHeaderList);
 362   m_curlHeaderList = NULL;
 363
 364   if( m_curlAliasList )
 365     g_curlInterface.slist_free_all(m_curlAliasList);
 366   m_curlAliasList = NULL;
 367 }
 368
 369
 370 CCurlFile::~CCurlFile()
 371 {
 372   Close();
 373   delete m_state;
 374   delete m_oldState;
 375   g_curlInterface.Unload();
 376 }
 377
 378 CCurlFile::CCurlFile()
 379 {
 380   g_curlInterface.Load(); // loads the curl dll and resolves exports etc.
 381   m_opened = false;
 382   m_forWrite = false;
 383   m_inError = false;
 384   m_multisession  = true;
 385   m_seekable = true;
 386   m_useOldHttpVersion = false;
 387   m_connecttimeout = 0;
 388   m_lowspeedtime = 0;
 389   m_ftpauth = "";
 390   m_ftpport = "";
 391   m_ftppasvip = false;
 392   m_bufferSize = 32768;
 393   m_binary = true;
 394   m_postdata = "";
 395   m_postdataset = false;
 396   m_username = "";
 397   m_password = "";
 398   m_httpauth = "";
 399   m_proxytype = PROXY_HTTP;
 400   m_state = new CReadState();
 401   m_oldState = NULL;
 402   m_skipshout = false;
 403   m_httpresponse = -1;
 404   m_acceptCharset = "UTF-8,*;q=0.8"; /* prefer UTF-8 if available */
 405 }
 406
 407 //Has to be called before Open()
 408 void CCurlFile::SetBufferSize(unsigned int size)
 409 {
 410   m_bufferSize = size;
 411 }
 412
 413 void CCurlFile::Close()
 414 {
 415   if (m_opened && m_forWrite && !m_inError)
 416       Write(NULL, 0);
 417
 418   m_state->Disconnect();
 419   delete m_oldState;
 420   m_oldState = NULL;
 421
 422   m_url.clear();
 423   m_referer.clear();
 424   m_cookie.clear();
 425
 426   m_opened = false;
 427   m_forWrite = false;
 428   m_inError = false;
 429 }
 430
 431 void CCurlFile::SetCommonOptions(CReadState* state)
 432 {
 433   CURL_HANDLE* h = state->m_easyHandle;
 434
 435   g_curlInterface.easy_reset(h);
 436
 437   g_curlInterface.easy_setopt(h, CURLOPT_DEBUGFUNCTION, debug_callback);
 438
 439   if( g_advancedSettings.m_logLevel >= LOG_LEVEL_DEBUG )
 440     g_curlInterface.easy_setopt(h, CURLOPT_VERBOSE, TRUE);
 441   else
 442     g_curlInterface.easy_setopt(h, CURLOPT_VERBOSE, FALSE);
 443
 444   g_curlInterface.easy_setopt(h, CURLOPT_WRITEDATA, state);
 445   g_curlInterface.easy_setopt(h, CURLOPT_WRITEFUNCTION, write_callback);
 446
 447   g_curlInterface.easy_setopt(h, CURLOPT_READDATA, state);
 448   g_curlInterface.easy_setopt(h, CURLOPT_READFUNCTION, read_callback);
 449
 450   // set username and password for current handle
 451   if (m_username.length() > 0 && m_password.length() > 0)
 452   {
 453     CStdString userpwd = m_username + ":" + m_password;
 454     g_curlInterface.easy_setopt(h, CURLOPT_USERPWD, userpwd.c_str());
 455   }
 456
 457   // make sure headers are seperated from the data stream
 458   g_curlInterface.easy_setopt(h, CURLOPT_WRITEHEADER, state);
 459   g_curlInterface.easy_setopt(h, CURLOPT_HEADERFUNCTION, header_callback);
 460   g_curlInterface.easy_setopt(h, CURLOPT_HEADER, FALSE);
 461
 462   g_curlInterface.easy_setopt(h, CURLOPT_FTP_USE_EPSV, 0); // turn off epsv
 463
 464   // Allow us to follow two redirects
 465   g_curlInterface.easy_setopt(h, CURLOPT_FOLLOWLOCATION, TRUE);
 466   g_curlInterface.easy_setopt(h, CURLOPT_MAXREDIRS, 5);
 467
 468   // Enable cookie engine for current handle to re-use them in future requests
 469   CStdString strCookieFile;
 470   CStdString strTempPath = CSpecialProtocol::TranslatePath(g_advancedSettings.m_cachePath);
 471   strCookieFile = URIUtils::AddFileToFolder(strTempPath, "cookies.dat");
 472
 473   g_curlInterface.easy_setopt(h, CURLOPT_COOKIEFILE, strCookieFile.c_str());
 474   g_curlInterface.easy_setopt(h, CURLOPT_COOKIEJAR, strCookieFile.c_str());
 475
 476   // Set custom cookie if requested
 477   if (!m_cookie.empty())
 478     g_curlInterface.easy_setopt(h, CURLOPT_COOKIE, m_cookie.c_str());
 479
 480   g_curlInterface.easy_setopt(h, CURLOPT_COOKIELIST, "FLUSH");
 481
 482   // When using multiple threads you should set the CURLOPT_NOSIGNAL option to
 483   // TRUE for all handles. Everything will work fine except that timeouts are not
 484   // honored during the DNS lookup - which you can work around by building libcurl
 485   // with c-ares support. c-ares is a library that provides asynchronous name
 486   // resolves. Unfortunately, c-ares does not yet support IPv6.
 487   g_curlInterface.easy_setopt(h, CURLOPT_NOSIGNAL, TRUE);
 488
 489   // not interested in failed requests
 490   g_curlInterface.easy_setopt(h, CURLOPT_FAILONERROR, 1);
 491
 492   // enable support for icecast / shoutcast streams
 493   if ( NULL == state->m_curlAliasList )
 494     // m_curlAliasList is used only by this one place, but SetCommonOptions can
 495     // be called multiple times, only append to list if it's empty.
 496     state->m_curlAliasList = g_curlInterface.slist_append(state->m_curlAliasList, "ICY 200 OK");
 497   g_curlInterface.easy_setopt(h, CURLOPT_HTTP200ALIASES, state->m_curlAliasList);
 498
 499   // never verify peer, we don't have any certificates to do this
 500   g_curlInterface.easy_setopt(h, CURLOPT_SSL_VERIFYPEER, 0);
 501   g_curlInterface.easy_setopt(h, CURLOPT_SSL_VERIFYHOST, 0);
 502
 503   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_URL, m_url.c_str());
 504   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TRANSFERTEXT, FALSE);
 505
 506   // setup POST data if it is set (and it may be empty)
 507   if (m_postdataset)
 508   {
 509     g_curlInterface.easy_setopt(h, CURLOPT_POST, 1 );
 510     g_curlInterface.easy_setopt(h, CURLOPT_POSTFIELDSIZE, m_postdata.length());
 511     g_curlInterface.easy_setopt(h, CURLOPT_POSTFIELDS, m_postdata.c_str());
 512   }
 513
 514   // setup Referer header if needed
 515   if (!m_referer.empty())
 516     g_curlInterface.easy_setopt(h, CURLOPT_REFERER, m_referer.c_str());
 517   else
 518   {
 519     g_curlInterface.easy_setopt(h, CURLOPT_REFERER, NULL);
 520     g_curlInterface.easy_setopt(h, CURLOPT_AUTOREFERER, TRUE);
 521   }
 522
 523   // setup any requested authentication
 524   if( m_ftpauth.length() > 0 )
 525   {
 526     g_curlInterface.easy_setopt(h, CURLOPT_FTP_SSL, CURLFTPSSL_TRY);
 527     if( m_ftpauth.Equals("any") )
 528       g_curlInterface.easy_setopt(h, CURLOPT_FTPSSLAUTH, CURLFTPAUTH_DEFAULT);
 529     else if( m_ftpauth.Equals("ssl") )
 530       g_curlInterface.easy_setopt(h, CURLOPT_FTPSSLAUTH, CURLFTPAUTH_SSL);
 531     else if( m_ftpauth.Equals("tls") )
 532       g_curlInterface.easy_setopt(h, CURLOPT_FTPSSLAUTH, CURLFTPAUTH_TLS);
 533   }
 534
 535   // setup requested http authentication method
 536   if(m_httpauth.length() > 0)
 537   {
 538     if( m_httpauth.Equals("any") )
 539       g_curlInterface.easy_setopt(h, CURLOPT_HTTPAUTH, CURLAUTH_ANY);
 540     else if( m_httpauth.Equals("anysafe") )
 541       g_curlInterface.easy_setopt(h, CURLOPT_HTTPAUTH, CURLAUTH_ANYSAFE);
 542     else if( m_httpauth.Equals("digest") )
 543       g_curlInterface.easy_setopt(h, CURLOPT_HTTPAUTH, CURLAUTH_DIGEST);
 544     else if( m_httpauth.Equals("ntlm") )
 545       g_curlInterface.easy_setopt(h, CURLOPT_HTTPAUTH, CURLAUTH_NTLM);
 546   }
 547
 548   // allow passive mode for ftp
 549   if( m_ftpport.length() > 0 )
 550     g_curlInterface.easy_setopt(h, CURLOPT_FTPPORT, m_ftpport.c_str());
 551   else
 552     g_curlInterface.easy_setopt(h, CURLOPT_FTPPORT, NULL);
 553
 554   // allow curl to not use the ip address in the returned pasv response
 555   if( m_ftppasvip )
 556     g_curlInterface.easy_setopt(h, CURLOPT_FTP_SKIP_PASV_IP, 0);
 557   else
 558     g_curlInterface.easy_setopt(h, CURLOPT_FTP_SKIP_PASV_IP, 1);
 559
 560   // setup Content-Encoding if requested
 561   if( m_contentencoding.length() > 0 )
 562     g_curlInterface.easy_setopt(h, CURLOPT_ENCODING, m_contentencoding.c_str());
 563
 564   if (!m_useOldHttpVersion && !m_acceptCharset.empty())
 565     SetRequestHeader("Accept-Charset", m_acceptCharset);
 566
 567   if (m_userAgent.length() > 0)
 568     g_curlInterface.easy_setopt(h, CURLOPT_USERAGENT, m_userAgent.c_str());
 569   else /* set some default agent as shoutcast doesn't return proper stuff otherwise */
 570     g_curlInterface.easy_setopt(h, CURLOPT_USERAGENT, g_advancedSettings.m_userAgent.c_str());
 571
 572   if (m_useOldHttpVersion)
 573     g_curlInterface.easy_setopt(h, CURLOPT_HTTP_VERSION, CURL_HTTP_VERSION_1_0);
 574
 575   if (g_advancedSettings.m_curlDisableIPV6)
 576     g_curlInterface.easy_setopt(h, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
 577
 578   if (m_proxy.length() > 0)
 579   {
 580     g_curlInterface.easy_setopt(h, CURLOPT_PROXY, m_proxy.c_str());
 581     g_curlInterface.easy_setopt(h, CURLOPT_PROXYTYPE, proxyType2CUrlProxyType[m_proxytype]);
 582     if (m_proxyuserpass.length() > 0)
 583       g_curlInterface.easy_setopt(h, CURLOPT_PROXYUSERPWD, m_proxyuserpass.c_str());
 584
 585   }
 586   if (m_customrequest.length() > 0)
 587     g_curlInterface.easy_setopt(h, CURLOPT_CUSTOMREQUEST, m_customrequest.c_str());
 588
 589   if (m_connecttimeout == 0)
 590     m_connecttimeout = g_advancedSettings.m_curlconnecttimeout;
 591
 592   // set our timeouts, we abort connection after m_timeout, and reads after no data for m_timeout seconds
 593   g_curlInterface.easy_setopt(h, CURLOPT_CONNECTTIMEOUT, m_connecttimeout);
 594
 595   // We abort in case we transfer less than 1byte/second
 596   g_curlInterface.easy_setopt(h, CURLOPT_LOW_SPEED_LIMIT, 1);
 597
 598   if (m_lowspeedtime == 0)
 599     m_lowspeedtime = g_advancedSettings.m_curllowspeedtime;
 600
 601   // Set the lowspeed time very low as it seems Curl takes much longer to detect a lowspeed condition
 602   g_curlInterface.easy_setopt(h, CURLOPT_LOW_SPEED_TIME, m_lowspeedtime);
 603
 604   if (m_skipshout)
 605     // For shoutcast file, content-length should not be set, and in libcurl there is a bug, if the
 606     // cast file was 302 redirected then getinfo of CURLINFO_CONTENT_LENGTH_DOWNLOAD will return
 607     // the 302 response's body length, which cause the next read request failed, so we ignore
 608     // content-length for shoutcast file to workaround this.
 609     g_curlInterface.easy_setopt(h, CURLOPT_IGNORE_CONTENT_LENGTH, 1);
 610 }
 611
 612 void CCurlFile::SetRequestHeaders(CReadState* state)
 613 {
 614   if(state->m_curlHeaderList)
 615   {
 616     g_curlInterface.slist_free_all(state->m_curlHeaderList);
 617     state->m_curlHeaderList = NULL;
 618   }
 619
 620   MAPHTTPHEADERS::iterator it;
 621   for(it = m_requestheaders.begin(); it != m_requestheaders.end(); it++)
 622   {
 623     CStdString buffer = it->first + ": " + it->second;
 624     state->m_curlHeaderList = g_curlInterface.slist_append(state->m_curlHeaderList, buffer.c_str());
 625   }
 626
 627   // add user defined headers
 628   if (state->m_easyHandle)
 629     g_curlInterface.easy_setopt(state->m_easyHandle, CURLOPT_HTTPHEADER, state->m_curlHeaderList);
 630 }
 631
 632 void CCurlFile::SetCorrectHeaders(CReadState* state)
 633 {
 634   CHttpHeader& h = state->m_httpheader;
 635   /* workaround for shoutcast server wich doesn't set content type on standard mp3 */
 636   if( h.GetMimeType().empty() )
 637   {
 638     if( !h.GetValue("icy-notice1").empty()
 639     || !h.GetValue("icy-name").empty()
 640     || !h.GetValue("icy-br").empty() )
 641       h.AddParam("Content-Type", "audio/mpeg");
 642   }
 643
 644   /* hack for google video */
 645   if (StringUtils::EqualsNoCase(h.GetMimeType(),"text/html")
 646   &&  !h.GetValue("Content-Disposition").empty() )
 647   {
 648     CStdString strValue = h.GetValue("Content-Disposition");
 649     if (strValue.find("filename=") != std::string::npos &&
 650         strValue.find(".flv") != std::string::npos)
 651       h.AddParam("Content-Type", "video/flv");
 652   }
 653 }
 654
 655 void CCurlFile::ParseAndCorrectUrl(CURL &url2)
 656 {
 657   CStdString strProtocol = url2.GetTranslatedProtocol();
 658   url2.SetProtocol(strProtocol);
 659
 660   if( strProtocol.Equals("ftp")
 661   ||  strProtocol.Equals("ftps") )
 662   {
 663     // we was using url optons for urls, keep the old code work and warning
 664     if (!url2.GetOptions().empty())
 665     {
 666       CLog::Log(LOGWARNING, "%s: ftp url option is deprecated, please switch to use protocol option (change '?' to '|'), url: [%s]", __FUNCTION__, url2.GetRedacted().c_str());
 667       url2.SetProtocolOptions(url2.GetOptions().substr(1));
 668       /* ftp has no options */
 669       url2.SetOptions("");
 670     }
 671
 672     /* this is uggly, depending on from where   */
 673     /* we get the link it may or may not be     */
 674     /* url encoded. if handed from ftpdirectory */
 675     /* it won't be so let's handle that case    */
 676
 677     CStdString filename(url2.GetFileName());
 678     std::vector<std::string> array;
 679
 680     // if server sent us the filename in non-utf8, we need send back with same encoding.
 681     if (url2.GetProtocolOption("utf8") == "0")
 682       g_charsetConverter.utf8ToStringCharset(filename);
 683
 684     /* TODO: create a tokenizer that doesn't skip empty's */
 685     StringUtils::Tokenize(filename, array, "/");
 686     filename.clear();
 687     for(std::vector<std::string>::iterator it = array.begin(); it != array.end(); it++)
 688     {
 689       if(it != array.begin())
 690         filename += "/";
 691
 692       filename += CURL::Encode(*it);
 693     }
 694
 695     /* make sure we keep slashes */
 696     if(StringUtils::EndsWith(url2.GetFileName(), "/"))
 697       filename += "/";
 698
 699     url2.SetFileName(filename);
 700
 701     m_ftpauth = "";
 702     if (url2.HasProtocolOption("auth"))
 703     {
 704       m_ftpauth = url2.GetProtocolOption("auth");
 705       if(m_ftpauth.empty())
 706         m_ftpauth = "any";
 707     }
 708     m_ftpport = "";
 709     if (url2.HasProtocolOption("active"))
 710     {
 711       m_ftpport = url2.GetProtocolOption("active");
 712       if(m_ftpport.empty())
 713         m_ftpport = "-";
 714     }
 715     m_ftppasvip = url2.HasProtocolOption("pasvip") && url2.GetProtocolOption("pasvip") != "0";
 716   }
 717   else if( strProtocol.Equals("http")
 718        ||  strProtocol.Equals("https"))
 719   {
 720     if (CSettings::Get().GetBool("network.usehttpproxy")
 721         && !CSettings::Get().GetString("network.httpproxyserver").empty()
 722         && CSettings::Get().GetInt("network.httpproxyport") > 0
 723         && m_proxy.empty())
 724     {
 725       m_proxy = CSettings::Get().GetString("network.httpproxyserver");
 726       m_proxy += StringUtils::Format(":%d", CSettings::Get().GetInt("network.httpproxyport"));
 727       if (CSettings::Get().GetString("network.httpproxyusername").length() > 0 && m_proxyuserpass.empty())
 728       {
 729         m_proxyuserpass = CSettings::Get().GetString("network.httpproxyusername");
 730         m_proxyuserpass += ":" + CSettings::Get().GetString("network.httpproxypassword");
 731       }
 732       m_proxytype = (ProxyType)CSettings::Get().GetInt("network.httpproxytype");
 733       CLog::Log(LOGDEBUG, "Using proxy %s, type %d", m_proxy.c_str(), proxyType2CUrlProxyType[m_proxytype]);
 734     }
 735
 736     // get username and password
 737     m_username = url2.GetUserName();
 738     m_password = url2.GetPassWord();
 739
 740     // handle any protocol options
 741     std::map<CStdString, CStdString> options;
 742     url2.GetProtocolOptions(options);
 743     if (options.size() > 0)
 744     {
 745       // clear protocol options
 746       url2.SetProtocolOptions("");
 747       // set xbmc headers
 748       for(std::map<CStdString, CStdString>::const_iterator it = options.begin(); it != options.end(); ++it)
 749       {
 750         const CStdString &name = it->first;
 751         const CStdString &value = it->second;
 752
 753         if(name.Equals("auth"))
 754         {
 755           m_httpauth = value;
 756           if(m_httpauth.empty())
 757             m_httpauth = "any";
 758         }
 759         else if (name.Equals("Referer"))
 760           SetReferer(value);
 761         else if (name.Equals("User-Agent"))
 762           SetUserAgent(value);
 763         else if (name.Equals("Cookie"))
 764           SetCookie(value);
 765         else if (name.Equals("Encoding"))
 766           SetContentEncoding(value);
 767         else if (name.Equals("noshout") && value.Equals("true"))
 768           m_skipshout = true;
 769         else if (name.Equals("seekable") && value.Equals("0"))
 770           m_seekable = false;
 771         else if (name.Equals("Accept-Charset"))
 772           SetAcceptCharset(value);
 773         else if (name.Equals("HttpProxy"))
 774           SetStreamProxy(value, PROXY_HTTP);
 775         else
 776           SetRequestHeader(name, value);
 777       }
 778     }
 779   }
 780
 781   if (m_username.length() > 0 && m_password.length() > 0)
 782     m_url = url2.GetWithoutUserDetails();
 783   else
 784     m_url = url2.Get();
 785 }
 786
 787 void CCurlFile::SetStreamProxy(const CStdString &proxy, ProxyType type)
 788 {
 789   CURL url(proxy);
 790   m_proxy = url.GetWithoutUserDetails();
 791   m_proxyuserpass = url.GetUserName();
 792   if (!url.GetPassWord().empty())
 793     m_proxyuserpass += ":" + url.GetPassWord();
 794   m_proxytype = type;
 795   CLog::Log(LOGDEBUG, "Overriding proxy from URL parameter: %s, type %d", m_proxy.c_str(), proxyType2CUrlProxyType[m_proxytype]);
 796 }
 797
 798 bool CCurlFile::Post(const CStdString& strURL, const CStdString& strPostData, CStdString& strHTML)
 799 {
 800   m_postdata = strPostData;
 801   m_postdataset = true;
 802   return Service(strURL, strHTML);
 803 }
 804
 805 bool CCurlFile::Get(const CStdString& strURL, CStdString& strHTML)
 806 {
 807   m_postdata = "";
 808   m_postdataset = false;
 809   return Service(strURL, strHTML);
 810 }
 811
 812 bool CCurlFile::Service(const CStdString& strURL, CStdString& strHTML)
 813 {
 814   if (Open(strURL))
 815   {
 816     if (ReadData(strHTML))
 817     {
 818       Close();
 819       return true;
 820     }
 821   }
 822   Close();
 823   return false;
 824 }
 825
 826 bool CCurlFile::ReadData(CStdString& strHTML)
 827 {
 828   int size_read = 0;
 829   int data_size = 0;
 830   strHTML = "";
 831   char buffer[16384];
 832   while( (size_read = Read(buffer, sizeof(buffer)-1) ) > 0 )
 833   {
 834     buffer[size_read] = 0;
 835     strHTML.append(buffer, size_read);
 836     data_size += size_read;
 837   }
 838   if (m_state->m_cancelled)
 839     return false;
 840   return true;
 841 }
 842
 843 bool CCurlFile::Download(const CStdString& strURL, const CStdString& strFileName, LPDWORD pdwSize)
 844 {
 845   CLog::Log(LOGINFO, "CCurlFile::Download - %s->%s", strURL.c_str(), strFileName.c_str());
 846
 847   CStdString strData;
 848   if (!Get(strURL, strData))
 849     return false;
 850
 851   XFILE::CFile file;
 852   if (!file.OpenForWrite(strFileName, true))
 853   {
 854     CLog::Log(LOGERROR, "CCurlFile::Download - Unable to open file %s: %u",
 855     strFileName.c_str(), GetLastError());
 856     return false;
 857   }
 858   if (strData.size())
 859     file.Write(strData.c_str(), strData.size());
 860   file.Close();
 861
 862   if (pdwSize != NULL)
 863   {
 864     *pdwSize = strData.size();
 865   }
 866
 867   return true;
 868 }
 869
 870 // Detect whether we are "online" or not! Very simple and dirty!
 871 bool CCurlFile::IsInternet(bool checkDNS /* = true */)
 872 {
 873   CStdString strURL = "http://www.google.com";
 874   if (!checkDNS)
 875     strURL = "http://74.125.19.103"; // www.google.com ip
 876
 877   bool found = Exists(strURL);
 878   Close();
 879
 880   return found;
 881 }
 882
 883 void CCurlFile::Cancel()
 884 {
 885   m_state->m_cancelled = true;
 886   while (m_opened)
 887     Sleep(1);
 888 }
 889
 890 void CCurlFile::Reset()
 891 {
 892   m_state->m_cancelled = false;
 893 }
 894
 895 bool CCurlFile::Open(const CURL& url)
 896 {
 897   m_opened = true;
 898   m_seekable = true;
 899
 900   CURL url2(url);
 901   ParseAndCorrectUrl(url2);
 902
 903   std::string redactPath = CURL::GetRedacted(m_url);
 904   CLog::Log(LOGDEBUG, "CurlFile::Open(%p) %s", (void*)this, redactPath.c_str());
 905
 906   ASSERT(!(!m_state->m_easyHandle ^ !m_state->m_multiHandle));
 907   if( m_state->m_easyHandle == NULL )
 908     g_curlInterface.easy_aquire(url2.GetProtocol(), url2.GetHostName(), &m_state->m_easyHandle, &m_state->m_multiHandle );
 909
 910   // setup common curl options
 911   SetCommonOptions(m_state);
 912   SetRequestHeaders(m_state);
 913   m_state->m_sendRange = m_seekable;
 914
 915   m_httpresponse = m_state->Connect(m_bufferSize);
 916   if( m_httpresponse < 0 || m_httpresponse >= 400)
 917     return false;
 918
 919   SetCorrectHeaders(m_state);
 920
 921   // since we can't know the stream size up front if we're gzipped/deflated
 922   // flag the stream with an unknown file size rather than the compressed
 923   // file size.
 924   if (m_contentencoding.size() > 0)
 925     m_state->m_fileSize = 0;
 926
 927   // check if this stream is a shoutcast stream. sometimes checking the protocol line is not enough so examine other headers as well.
 928   // shoutcast streams should be handled by FileShoutcast.
 929   if ((m_state->m_httpheader.GetProtoLine().substr(0, 3) == "ICY" || !m_state->m_httpheader.GetValue("icy-notice1").empty()
 930      || !m_state->m_httpheader.GetValue("icy-name").empty()
 931      || !m_state->m_httpheader.GetValue("icy-br").empty()) && !m_skipshout)
 932   {
 933     CLog::Log(LOGDEBUG,"CCurlFile::Open - File <%s> is a shoutcast stream. Re-opening", redactPath.c_str());
 934     throw new CRedirectException(new CShoutcastFile);
 935   }
 936
 937   m_multisession = false;
 938   if(url2.GetProtocol().Equals("http") || url2.GetProtocol().Equals("https"))
 939   {
 940     m_multisession = true;
 941     if(m_state->m_httpheader.GetValue("Server").find("Portable SDK for UPnP devices") != std::string::npos)
 942     {
 943       CLog::Log(LOGWARNING, "CCurlFile::Open - Disabling multi session due to broken libupnp server");
 944       m_multisession = false;
 945     }
 946   }
 947
 948   if(StringUtils::EqualsNoCase(m_state->m_httpheader.GetValue("Transfer-Encoding"), "chunked"))
 949     m_state->m_fileSize = 0;
 950
 951   if(m_state->m_fileSize <= 0)
 952     m_seekable = false;
 953   if (m_seekable)
 954   {
 955     if(url2.GetProtocol().Equals("http")
 956     || url2.GetProtocol().Equals("https"))
 957     {
 958       // if server says explicitly it can't seek, respect that
 959       if(StringUtils::EqualsNoCase(m_state->m_httpheader.GetValue("Accept-Ranges"),"none"))
 960         m_seekable = false;
 961     }
 962   }
 963
 964   char* efurl;
 965   if (CURLE_OK == g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_EFFECTIVE_URL,&efurl) && efurl)
 966     m_url = efurl;
 967
 968   return true;
 969 }
 970
 971 bool CCurlFile::OpenForWrite(const CURL& url, bool bOverWrite)
 972 {
 973   if(m_opened)
 974     return false;
 975
 976   if (Exists(url) && !bOverWrite)
 977     return false;
 978
 979   CURL url2(url);
 980   ParseAndCorrectUrl(url2);
 981
 982   CLog::Log(LOGDEBUG, "CCurlFile::OpenForWrite(%p) %s", (void*)this, CURL::GetRedacted(m_url).c_str());
 983
 984   ASSERT(m_state->m_easyHandle == NULL);
 985   g_curlInterface.easy_aquire(url2.GetProtocol(), url2.GetHostName(), &m_state->m_easyHandle, &m_state->m_multiHandle);
 986
 987     // setup common curl options
 988   SetCommonOptions(m_state);
 989   SetRequestHeaders(m_state);
 990
 991   char* efurl;
 992   if (CURLE_OK == g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_EFFECTIVE_URL,&efurl) && efurl)
 993     m_url = efurl;
 994
 995   m_opened = true;
 996   m_forWrite = true;
 997   m_inError = false;
 998   m_writeOffset = 0;
 999
1000   ASSERT(m_state->m_multiHandle);
1001
1002   SetCommonOptions(m_state);
1003   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_UPLOAD, 1);
1004
1005   g_curlInterface.multi_add_handle(m_state->m_multiHandle, m_state->m_easyHandle);
1006
1007   m_state->SetReadBuffer(NULL, 0);
1008
1009   return true;
1010 }
1011
1012 int CCurlFile::Write(const void* lpBuf, int64_t uiBufSize)
1013 {
1014   if (!(m_opened && m_forWrite) || m_inError)
1015     return -1;
1016
1017   ASSERT(m_state->m_multiHandle);
1018
1019   m_state->SetReadBuffer(lpBuf, uiBufSize);
1020   m_state->m_isPaused = false;
1021   g_curlInterface.easy_pause(m_state->m_easyHandle, CURLPAUSE_CONT);
1022
1023   CURLMcode result = CURLM_OK;
1024
1025   m_stillRunning = 1;
1026   while (m_stillRunning && !m_state->m_isPaused)
1027   {
1028     while ((result = g_curlInterface.multi_perform(m_state->m_multiHandle, &m_stillRunning)) == CURLM_CALL_MULTI_PERFORM);
1029
1030     if (!m_stillRunning)
1031       break;
1032
1033     if (result != CURLM_OK)
1034     {
1035       long code;
1036       if(g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_RESPONSE_CODE, &code) == CURLE_OK )
1037         CLog::Log(LOGERROR, "%s - Unable to write curl resource (%s) - %ld", __FUNCTION__, CURL::GetRedacted(m_url).c_str(), code);
1038       m_inError = true;
1039       return -1;
1040     }
1041   }
1042
1043   m_writeOffset += m_state->m_filePos;
1044   return m_state->m_filePos;
1045 }
1046
1047 bool CCurlFile::CReadState::ReadString(char *szLine, int iLineLength)
1048 {
1049   unsigned int want = (unsigned int)iLineLength;
1050
1051   if((m_fileSize == 0 || m_filePos < m_fileSize) && !FillBuffer(want))
1052     return false;
1053
1054   // ensure only available data is considered
1055   want = XMIN((unsigned int)m_buffer.getMaxReadSize(), want);
1056
1057   /* check if we finished prematurely */
1058   if (!m_stillRunning && (m_fileSize == 0 || m_filePos != m_fileSize) && !want)
1059   {
1060     if (m_fileSize != 0)
1061       CLog::Log(LOGWARNING, "%s - Transfer ended before entire file was retrieved pos %"PRId64", size %"PRId64, __FUNCTION__, m_filePos, m_fileSize);
1062
1063     return false;
1064   }
1065
1066   char* pLine = szLine;
1067   do
1068   {
1069     if (!m_buffer.ReadData(pLine, 1))
1070       break;
1071
1072     pLine++;
1073   } while (((pLine - 1)[0] != '\n') && ((unsigned int)(pLine - szLine) < want));
1074   pLine[0] = 0;
1075   m_filePos += (pLine - szLine);
1076   return (bool)((pLine - szLine) > 0);
1077 }
1078
1079 bool CCurlFile::Exists(const CURL& url)
1080 {
1081   // if file is already running, get info from it
1082   if( m_opened )
1083   {
1084     CLog::Log(LOGWARNING, "CCurlFile::Exists - Exist called on open file %s", url.GetRedacted().c_str());
1085     return true;
1086   }
1087
1088   CURL url2(url);
1089   ParseAndCorrectUrl(url2);
1090
1091   ASSERT(m_state->m_easyHandle == NULL);
1092   g_curlInterface.easy_aquire(url2.GetProtocol(), url2.GetHostName(), &m_state->m_easyHandle, NULL);
1093
1094   SetCommonOptions(m_state);
1095   SetRequestHeaders(m_state);
1096   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TIMEOUT, 5);
1097   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_NOBODY, 1);
1098   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_WRITEDATA, NULL); /* will cause write failure*/
1099
1100   if(url2.GetProtocol() == "ftp")
1101   {
1102     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FILETIME, 1);
1103     // nocwd is less standard, will return empty list for non-existed remote dir on some ftp server, avoid it.
1104     if (StringUtils::EndsWith(url2.GetFileName(), "/"))
1105       g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FTP_FILEMETHOD, CURLFTPMETHOD_SINGLECWD);
1106     else
1107       g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FTP_FILEMETHOD, CURLFTPMETHOD_NOCWD);
1108   }
1109
1110   CURLcode result = g_curlInterface.easy_perform(m_state->m_easyHandle);
1111   g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
1112
1113   if (result == CURLE_WRITE_ERROR || result == CURLE_OK)
1114     return true;
1115
1116   if (result == CURLE_HTTP_RETURNED_ERROR)
1117   {
1118     long code;
1119     if(g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_RESPONSE_CODE, &code) == CURLE_OK && code != 404 )
1120       CLog::Log(LOGERROR, "CCurlFile::Exists - Failed: HTTP returned error %ld for %s", code, url.GetRedacted().c_str());
1121   }
1122   else if (result != CURLE_REMOTE_FILE_NOT_FOUND && result != CURLE_FTP_COULDNT_RETR_FILE)
1123   {
1124     CLog::Log(LOGERROR, "CCurlFile::Exists - Failed: %s(%d) for %s", g_curlInterface.easy_strerror(result), result, url.GetRedacted().c_str());
1125   }
1126
1127   errno = ENOENT;
1128   return false;
1129 }
1130
1131 int64_t CCurlFile::Seek(int64_t iFilePosition, int iWhence)
1132 {
1133   int64_t nextPos = m_state->m_filePos;
1134   switch(iWhence)
1135   {
1136     case SEEK_SET:
1137       nextPos = iFilePosition;
1138       break;
1139     case SEEK_CUR:
1140       nextPos += iFilePosition;
1141       break;
1142     case SEEK_END:
1143       if (m_state->m_fileSize)
1144         nextPos = m_state->m_fileSize + iFilePosition;
1145       else
1146         return -1;
1147       break;
1148     default:
1149       return -1;
1150   }
1151
1152   // We can't seek beyond EOF
1153   if (m_state->m_fileSize && nextPos > m_state->m_fileSize) return -1;
1154
1155   if(m_state->Seek(nextPos))
1156     return nextPos;
1157
1158   if (m_oldState && m_oldState->Seek(nextPos))
1159   {
1160     CReadState *tmp = m_state;
1161     m_state = m_oldState;
1162     m_oldState = tmp;
1163     return nextPos;
1164   }
1165
1166   if(!m_seekable)
1167     return -1;
1168
1169   CReadState* oldstate = NULL;
1170   if(m_multisession)
1171   {
1172     CURL url(m_url);
1173     oldstate = m_oldState;
1174     m_oldState = m_state;
1175     m_state = new CReadState();
1176
1177     g_curlInterface.easy_aquire(url.GetProtocol(), url.GetHostName(), &m_state->m_easyHandle, &m_state->m_multiHandle );
1178
1179     m_state->m_fileSize = m_oldState->m_fileSize;
1180   }
1181   else
1182     m_state->Disconnect();
1183
1184   // re-setup common curl options
1185   SetCommonOptions(m_state);
1186
1187   /* caller might have changed some headers (needed for daap)*/
1188   SetRequestHeaders(m_state);
1189
1190   m_state->m_filePos = nextPos;
1191   m_state->m_sendRange = true;
1192
1193   long response = m_state->Connect(m_bufferSize);
1194   if(response < 0 && (m_state->m_fileSize == 0 || m_state->m_fileSize != m_state->m_filePos))
1195   {
1196     m_seekable = false;
1197     if(m_multisession && m_oldState)
1198     {
1199       delete m_state;
1200       m_state = m_oldState;
1201       m_oldState = oldstate;
1202     }
1203     return -1;
1204   }
1205
1206   SetCorrectHeaders(m_state);
1207   delete oldstate;
1208
1209   return m_state->m_filePos;
1210 }
1211
1212 int64_t CCurlFile::GetLength()
1213 {
1214   if (!m_opened) return 0;
1215   return m_state->m_fileSize;
1216 }
1217
1218 int64_t CCurlFile::GetPosition()
1219 {
1220   if (!m_opened) return 0;
1221   return m_state->m_filePos;
1222 }
1223
1224 int CCurlFile::Stat(const CURL& url, struct __stat64* buffer)
1225 {
1226   // if file is already running, get info from it
1227   if( m_opened )
1228   {
1229     CLog::Log(LOGWARNING, "CCurlFile::Stat - Stat called on open file %s", url.GetRedacted().c_str());
1230     if (buffer)
1231     {
1232       memset(buffer, 0, sizeof(struct __stat64));
1233       buffer->st_size = GetLength();
1234       buffer->st_mode = _S_IFREG;
1235     }
1236     return 0;
1237   }
1238
1239   CURL url2(url);
1240   ParseAndCorrectUrl(url2);
1241
1242   ASSERT(m_state->m_easyHandle == NULL);
1243   g_curlInterface.easy_aquire(url2.GetProtocol(), url2.GetHostName(), &m_state->m_easyHandle, NULL);
1244
1245   SetCommonOptions(m_state);
1246   SetRequestHeaders(m_state);
1247   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TIMEOUT, g_advancedSettings.m_curlconnecttimeout);
1248   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_NOBODY, 1);
1249   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_WRITEDATA, NULL); /* will cause write failure*/
1250   g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FILETIME , 1);
1251
1252   if(url2.GetProtocol() == "ftp")
1253   {
1254     // nocwd is less standard, will return empty list for non-existed remote dir on some ftp server, avoid it.
1255     if (StringUtils::EndsWith(url2.GetFileName(), "/"))
1256       g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FTP_FILEMETHOD, CURLFTPMETHOD_SINGLECWD);
1257     else
1258       g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FTP_FILEMETHOD, CURLFTPMETHOD_NOCWD);
1259   }
1260
1261   CURLcode result = g_curlInterface.easy_perform(m_state->m_easyHandle);
1262
1263   if(result == CURLE_HTTP_RETURNED_ERROR)
1264   {
1265     long code;
1266     if(g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_RESPONSE_CODE, &code) == CURLE_OK && code == 404 )
1267       return -1;
1268   }
1269
1270   if(result == CURLE_GOT_NOTHING
1271   || result == CURLE_HTTP_RETURNED_ERROR
1272   || result == CURLE_RECV_ERROR /* some silly shoutcast servers */ )
1273   {
1274     /* some http servers and shoutcast servers don't give us any data on a head request */
1275     /* request normal and just fail out, it's their loss */
1276     /* somehow curl doesn't reset CURLOPT_NOBODY properly so reset everything */
1277     SetCommonOptions(m_state);
1278     SetRequestHeaders(m_state);
1279     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_TIMEOUT, g_advancedSettings.m_curlconnecttimeout);
1280     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_RANGE, "0-0");
1281     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_WRITEDATA, NULL); /* will cause write failure*/
1282     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_FILETIME, 1);
1283     result = g_curlInterface.easy_perform(m_state->m_easyHandle);
1284   }
1285
1286   if( result == CURLE_HTTP_RANGE_ERROR )
1287   {
1288     /* crap can't use the range option, disable it and try again */
1289     g_curlInterface.easy_setopt(m_state->m_easyHandle, CURLOPT_RANGE, NULL);
1290     result = g_curlInterface.easy_perform(m_state->m_easyHandle);
1291   }
1292
1293   if( result != CURLE_WRITE_ERROR && result != CURLE_OK )
1294   {
1295     g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
1296     errno = ENOENT;
1297     CLog::Log(LOGERROR, "CCurlFile::Stat - Failed: %s(%d) for %s", g_curlInterface.easy_strerror(result), result, url.GetRedacted().c_str());
1298     return -1;
1299   }
1300
1301   double length;
1302   result = g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_CONTENT_LENGTH_DOWNLOAD, &length);
1303   if (result != CURLE_OK || length < 0.0)
1304   {
1305     if (url.GetProtocol() == "ftp")
1306     {
1307       g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
1308       CLog::Log(LOGNOTICE, "CCurlFile::Stat - Content length failed: %s(%d) for %s", g_curlInterface.easy_strerror(result), result, url.GetRedacted().c_str());
1309       errno = ENOENT;
1310       return -1;
1311     }
1312     else
1313       length = 0.0;
1314   }
1315
1316   SetCorrectHeaders(m_state);
1317
1318   if(buffer)
1319   {
1320     char *content;
1321     result = g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_CONTENT_TYPE, &content);
1322     if (result != CURLE_OK)
1323     {
1324       CLog::Log(LOGNOTICE, "CCurlFile::Stat - Content type failed: %s(%d) for %s", g_curlInterface.easy_strerror(result), result, url.GetRedacted().c_str());
1325       g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
1326       errno = ENOENT;
1327       return -1;
1328     }
1329     else
1330     {
1331       memset(buffer, 0, sizeof(struct __stat64));
1332       buffer->st_size = (int64_t)length;
1333       if(content && strstr(content, "text/html")) //consider html files directories
1334         buffer->st_mode = _S_IFDIR;
1335       else
1336         buffer->st_mode = _S_IFREG;
1337     }
1338     long filetime;
1339     result = g_curlInterface.easy_getinfo(m_state->m_easyHandle, CURLINFO_FILETIME, &filetime);
1340     if (result != CURLE_OK)
1341     {
1342       CLog::Log(LOGNOTICE, "CCurlFile::Stat - Filetime failed: %s(%d) for %s", g_curlInterface.easy_strerror(result), result, url.GetRedacted().c_str());
1343     }
1344     else
1345     {
1346       if (filetime != -1)
1347         buffer->st_mtime = filetime;
1348     }
1349   }
1350   g_curlInterface.easy_release(&m_state->m_easyHandle, NULL);
1351   return 0;
1352 }
1353
1354 unsigned int CCurlFile::CReadState::Read(void* lpBuf, int64_t uiBufSize)
1355 {
1356   /* only request 1 byte, for truncated reads (only if not eof) */
1357   if((m_fileSize == 0 || m_filePos < m_fileSize) && !FillBuffer(1))
1358     return 0;
1359
1360   /* ensure only available data is considered */
1361   unsigned int want = (unsigned int)XMIN(m_buffer.getMaxReadSize(), uiBufSize);
1362
1363   /* xfer data to caller */
1364   if (m_buffer.ReadData((char *)lpBuf, want))
1365   {
1366     m_filePos += want;
1367     return want;
1368   }
1369
1370   /* check if we finished prematurely */
1371   if (!m_stillRunning && (m_fileSize == 0 || m_filePos != m_fileSize))
1372   {
1373     CLog::Log(LOGWARNING, "%s - Transfer ended before entire file was retrieved pos %"PRId64", size %"PRId64, __FUNCTION__, m_filePos, m_fileSize);
1374     return 0;
1375   }
1376
1377   return 0;
1378 }
1379
1380 /* use to attempt to fill the read buffer up to requested number of bytes */
1381 bool CCurlFile::CReadState::FillBuffer(unsigned int want)
1382 {
1383   int retry = 0;
1384   fd_set fdread;
1385   fd_set fdwrite;
1386   fd_set fdexcep;
1387
1388   // only attempt to fill buffer if transactions still running and buffer
1389   // doesnt exceed required size already
1390   while ((unsigned int)m_buffer.getMaxReadSize() < want && m_buffer.getMaxWriteSize() > 0 )
1391   {
1392     if (m_cancelled)
1393       return false;
1394
1395     /* if there is data in overflow buffer, try to use that first */
1396     if (m_overflowSize)
1397     {
1398       unsigned amount = XMIN((unsigned int)m_buffer.getMaxWriteSize(), m_overflowSize);
1399       m_buffer.WriteData(m_overflowBuffer, amount);
1400
1401       if (amount < m_overflowSize)
1402         memcpy(m_overflowBuffer, m_overflowBuffer+amount,m_overflowSize-amount);
1403
1404       m_overflowSize -= amount;
1405       m_overflowBuffer = (char*)realloc_simple(m_overflowBuffer, m_overflowSize);
1406       continue;
1407     }
1408
1409     CURLMcode result = g_curlInterface.multi_perform(m_multiHandle, &m_stillRunning);
1410     if (!m_stillRunning)
1411     {
1412       if (result == CURLM_OK)
1413       {
1414         /* if we still have stuff in buffer, we are fine */
1415         if (m_buffer.getMaxReadSize())
1416           return true;
1417
1418         /* verify that we are actually okey */
1419         int msgs;
1420         CURLcode CURLresult = CURLE_OK;
1421         CURLMsg* msg;
1422         while ((msg = g_curlInterface.multi_info_read(m_multiHandle, &msgs)))
1423         {
1424           if (msg->msg == CURLMSG_DONE)
1425           {
1426             if (msg->data.result == CURLE_OK)
1427               return true;
1428
1429             CLog::Log(LOGERROR, "CCurlFile::FillBuffer - Failed: %s(%d)", g_curlInterface.easy_strerror(msg->data.result), msg->data.result);
1430
1431             // We need to check the result here as we don't want to retry on every error
1432             if ( (msg->data.result == CURLE_OPERATION_TIMEDOUT ||
1433                   msg->data.result == CURLE_PARTIAL_FILE       ||
1434                   msg->data.result == CURLE_COULDNT_CONNECT    ||
1435                   msg->data.result == CURLE_RECV_ERROR)        &&
1436                   !m_bFirstLoop)
1437               CURLresult = msg->data.result;
1438             else if ( (msg->data.result == CURLE_HTTP_RANGE_ERROR     ||
1439                        msg->data.result == CURLE_HTTP_RETURNED_ERROR) &&
1440                        m_bFirstLoop                                   &&
1441                        m_filePos == 0                                 &&
1442                        m_sendRange)
1443             {
1444               // If server returns a range or http error, retry with range disabled
1445               CURLresult = msg->data.result;
1446               m_sendRange = false;
1447             }
1448             else
1449               return false;
1450           }
1451         }
1452
1453         // Don't retry when we didn't "see" any error
1454         if (CURLresult == CURLE_OK)
1455           return false;
1456
1457         // Close handle
1458         if (m_multiHandle && m_easyHandle)
1459           g_curlInterface.multi_remove_handle(m_multiHandle, m_easyHandle);
1460
1461         // Reset all the stuff like we would in Disconnect()
1462         m_buffer.Clear();
1463         free(m_overflowBuffer);
1464         m_overflowBuffer = NULL;
1465         m_overflowSize = 0;
1466
1467         // If we got here something is wrong
1468         if (++retry > g_advancedSettings.m_curlretries)
1469         {
1470           CLog::Log(LOGERROR, "CCurlFile::FillBuffer - Reconnect failed!");
1471           // Reset the rest of the variables like we would in Disconnect()
1472           m_filePos = 0;
1473           m_fileSize = 0;
1474           m_bufferSize = 0;
1475
1476           return false;
1477         }
1478
1479         CLog::Log(LOGNOTICE, "CCurlFile::FillBuffer - Reconnect, (re)try %i", retry);
1480
1481         // Connect + seek to current position (again)
1482         SetResume();
1483         g_curlInterface.multi_add_handle(m_multiHandle, m_easyHandle);
1484
1485         // Return to the beginning of the loop:
1486         continue;
1487       }
1488       return false;
1489     }
1490
1491     // We've finished out first loop
1492     if(m_bFirstLoop && m_buffer.getMaxReadSize() > 0)
1493       m_bFirstLoop = false;
1494
1495     switch (result)
1496     {
1497       case CURLM_OK:
1498       {
1499         int maxfd = -1;
1500         FD_ZERO(&fdread);
1501         FD_ZERO(&fdwrite);
1502         FD_ZERO(&fdexcep);
1503
1504         // get file descriptors from the transfers
1505         g_curlInterface.multi_fdset(m_multiHandle, &fdread, &fdwrite, &fdexcep, &maxfd);
1506
1507         long timeout = 0;
1508         if (CURLM_OK != g_curlInterface.multi_timeout(m_multiHandle, &timeout) || timeout == -1)
1509           timeout = 200;
1510
1511         struct timeval t = { timeout / 1000, (timeout % 1000) * 1000 };
1512
1513         /* Wait until data is available or a timeout occurs.
1514            We call dllselect(maxfd + 1, ...), specially in case of (maxfd == -1),
1515            we call dllselect(0, ...), which is basically equal to sleep. */
1516         if (SOCKET_ERROR == dllselect(maxfd + 1, &fdread, &fdwrite, &fdexcep, &t))
1517         {
1518           CLog::Log(LOGERROR, "CCurlFile::FillBuffer - Failed with socket error");
1519           return false;
1520         }
1521       }
1522       break;
1523       case CURLM_CALL_MULTI_PERFORM:
1524       {
1525         // we don't keep calling here as that can easily overwrite our buffer which we want to avoid
1526         // docs says we should call it soon after, but aslong as we are reading data somewhere
1527         // this aught to be soon enough. should stay in socket otherwise
1528         continue;
1529       }
1530       break;
1531       default:
1532       {
1533         CLog::Log(LOGERROR, "CCurlFile::FillBuffer - Multi perform failed with code %d, aborting", result);
1534         return false;
1535       }
1536       break;
1537     }
1538   }
1539   return true;
1540 }
1541
1542 void CCurlFile::CReadState::SetReadBuffer(const void* lpBuf, int64_t uiBufSize)
1543 {
1544   m_readBuffer = (char*)lpBuf;
1545   m_fileSize = uiBufSize;
1546   m_filePos = 0;
1547 }
1548
1549 void CCurlFile::ClearRequestHeaders()
1550 {
1551   m_requestheaders.clear();
1552 }
1553
1554 void CCurlFile::SetRequestHeader(CStdString header, CStdString value)
1555 {
1556   m_requestheaders[header] = value;
1557 }
1558
1559 void CCurlFile::SetRequestHeader(CStdString header, long value)
1560 {
1561   m_requestheaders[header] = StringUtils::Format("%ld", value);
1562 }
1563
1564 std::string CCurlFile::GetServerReportedCharset(void)
1565 {
1566   if (!m_state)
1567     return "";
1568
1569   return m_state->m_httpheader.GetCharset();
1570 }
1571
1572 /* STATIC FUNCTIONS */
1573 bool CCurlFile::GetHttpHeader(const CURL &url, CHttpHeader &headers)
1574 {
1575   try
1576   {
1577     CCurlFile file;
1578     if(file.Stat(url, NULL) == 0)
1579     {
1580       headers = file.GetHttpHeader();
1581       return true;
1582     }
1583     return false;
1584   }
1585   catch(...)
1586   {
1587     CLog::Log(LOGERROR, "%s - Exception thrown while trying to retrieve header url: %s", __FUNCTION__, url.GetRedacted().c_str());
1588     return false;
1589   }
1590 }
1591
1592 bool CCurlFile::GetMimeType(const CURL &url, CStdString &content, CStdString useragent)
1593 {
1594   CCurlFile file;
1595   if (!useragent.empty())
1596     file.SetUserAgent(useragent);
1597
1598   struct __stat64 buffer;
1599   std::string redactUrl = url.GetRedacted();
1600   if( file.Stat(url, &buffer) == 0 )
1601   {
1602     if (buffer.st_mode == _S_IFDIR)
1603       content = "x-directory/normal";
1604     else
1605       content = file.GetMimeType();
1606     CLog::Log(LOGDEBUG, "CCurlFile::GetMimeType - %s -> %s", redactUrl.c_str(), content.c_str());
1607     return true;
1608   }
1609   CLog::Log(LOGDEBUG, "CCurlFile::GetMimeType - %s -> failed", redactUrl.c_str());
1610   content = "";
1611   return false;
1612 }
1613
1614 bool CCurlFile::GetCookies(const CURL &url, std::string &cookies)
1615 {
1616   std::string cookiesStr;
1617   struct curl_slist*     curlCookies;
1618   XCURL::CURL_HANDLE*    easyHandle;
1619   XCURL::CURLM*          multiHandle;
1620
1621   // get the cookies list
1622   g_curlInterface.easy_aquire(url.GetProtocol(), url.GetHostName(), &easyHandle, &multiHandle);
1623   if (CURLE_OK == g_curlInterface.easy_getinfo(easyHandle, CURLINFO_COOKIELIST, &curlCookies))
1624   {
1625     // iterate over each cookie and format it into an RFC 2109 formatted Set-Cookie string
1626     struct curl_slist* curlCookieIter = curlCookies;
1627     while(curlCookieIter)
1628     {
1629       // tokenize the CURL cookie string
1630       std::vector<std::string> valuesVec;
1631       StringUtils::Tokenize(curlCookieIter->data, valuesVec, "\t");
1632
1633       // ensure the length is valid
1634       if (valuesVec.size() < 7)
1635       {
1636         CLog::Log(LOGERROR, "CCurlFile::GetCookies - invalid cookie: '%s'", curlCookieIter->data);
1637         curlCookieIter = curlCookieIter->next;
1638         continue;
1639       }
1640
1641       // create a http-header formatted cookie string
1642       std::string cookieStr = valuesVec[5] + "=" + valuesVec[6] +
1643                               "; path=" + valuesVec[2] +
1644                               "; domain=" + valuesVec[0];
1645
1646       // append this cookie to the string containing all cookies
1647       if (!cookiesStr.empty())
1648         cookiesStr += "\n";
1649       cookiesStr += cookieStr;
1650
1651       // move on to the next cookie
1652       curlCookieIter = curlCookieIter->next;
1653     }
1654
1655     // free the curl cookies
1656     g_curlInterface.slist_free_all(curlCookies);
1657
1658     // release our handles
1659     g_curlInterface.easy_release(&easyHandle, &multiHandle);
1660
1661     // if we have a non-empty cookie string, return it
1662     if (!cookiesStr.empty())
1663     {
1664       cookies = cookiesStr;
1665       return true;
1666     }
1667   }
1668
1669   // no cookies to return
1670   return false;
1671 }
1672
1673 int CCurlFile::IoControl(EIoControl request, void* param)
1674 {
1675   if(request == IOCTRL_SEEK_POSSIBLE)
1676     return m_seekable ? 1 : 0;
1677
1678   return -1;
1679 }