modules/demux/adaptive/http/HTTPConnection.cpp

   1 /*
   2  * HTTPConnection.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2014-2015 - VideoLAN and VLC Authors
   5  *
   6  * This program is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU Lesser General Public License as published
   8  * by the Free Software Foundation; either version 2.1 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14  * GNU Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  19  *****************************************************************************/
  20 #ifdef HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include "HTTPConnection.hpp"
  25 #include "ConnectionParams.hpp"
  26 #include "Sockets.hpp"
  27 #include "../adaptive/tools/Helper.h"
  28
  29 #include <cstdio>
  30 #include <sstream>
  31 #include <vlc_stream.h>
  32
  33 using namespace adaptive::http;
  34
  35 AbstractConnection::AbstractConnection(vlc_object_t *p_object_)
  36 {
  37     p_object = p_object_;
  38     available = true;
  39     bytesRead = 0;
  40     contentLength = 0;
  41 }
  42
  43 AbstractConnection::~AbstractConnection()
  44 {
  45
  46 }
  47
  48 bool AbstractConnection::prepare(const ConnectionParams &params_)
  49 {
  50     if (!available)
  51         return false;
  52     params = params_;
  53     available = false;
  54     return true;
  55 }
  56
  57 size_t AbstractConnection::getContentLength() const
  58 {
  59     return contentLength;
  60 }
  61
  62 HTTPConnection::HTTPConnection(vlc_object_t *p_object_, Socket *socket_, bool persistent)
  63     : AbstractConnection( p_object_ )
  64 {
  65     socket = socket_;
  66     psz_useragent = var_InheritString(p_object_, "http-user-agent");
  67     queryOk = false;
  68     retries = 0;
  69     connectionClose = !persistent;
  70     chunked = false;
  71     chunked_eof = false;
  72     chunkLength = 0;
  73 }
  74
  75 HTTPConnection::~HTTPConnection()
  76 {
  77     free(psz_useragent);
  78     delete socket;
  79 }
  80
  81 bool HTTPConnection::canReuse(const ConnectionParams &params_) const
  82 {
  83     return ( available &&
  84              params.getHostname() == params_.getHostname() &&
  85              params.getScheme() == params_.getScheme() &&
  86              params.getPort() == params_.getPort() );
  87 }
  88
  89 bool HTTPConnection::connect()
  90 {
  91     return socket->connect(p_object, params.getHostname().c_str(),
  92                                      params.getPort());
  93 }
  94
  95 bool HTTPConnection::connected() const
  96 {
  97     return socket->connected();
  98 }
  99
 100 void HTTPConnection::disconnect()
 101 {
 102     queryOk = false;
 103     bytesRead = 0;
 104     contentLength = 0;
 105     chunked = false;
 106     chunkLength = 0;
 107     bytesRange = BytesRange();
 108     socket->disconnect();
 109 }
 110
 111 int HTTPConnection::request(const std::string &path, const BytesRange &range)
 112 {
 113     queryOk = false;
 114     chunked = false;
 115     chunked_eof = false;
 116     chunkLength = 0;
 117
 118     /* Set new path for this query */
 119     params.setPath(path);
 120
 121     msg_Dbg(p_object, "Retrieving %s @%zu", params.getUrl().c_str(),
 122                        range.isValid() ? range.getStartByte() : 0);
 123
 124     if(!connected() && ( params.getHostname().empty() || !connect() ))
 125         return VLC_EGENERIC;
 126
 127     bytesRange = range;
 128     if(range.isValid() && range.getEndByte() > 0)
 129         contentLength = range.getEndByte() - range.getStartByte() + 1;
 130
 131     std::string header = buildRequestHeader(path);
 132     if(connectionClose)
 133         header.append("Connection: close\r\n");
 134     header.append("\r\n");
 135
 136     if(!send( header ))
 137     {
 138         socket->disconnect();
 139         if(!connectionClose)
 140         {
 141             /* server closed connection pipeline after last req. need new */
 142             connectionClose = true;
 143             return request(path, range);
 144         }
 145         return VLC_EGENERIC;
 146     }
 147
 148     int i_ret = parseReply();
 149     if(i_ret == VLC_SUCCESS)
 150     {
 151         queryOk = true;
 152     }
 153     else if(i_ret == VLC_ETIMEOUT) /* redir */
 154     {
 155         socket->disconnect();
 156         if(locationparams.getScheme().empty())
 157             params.setPath(locationparams.getPath());
 158         else
 159             params = locationparams;
 160         locationparams = ConnectionParams();
 161     }
 162     else if(i_ret == VLC_EGENERIC)
 163     {
 164         socket->disconnect();
 165         if(!connectionClose)
 166         {
 167             connectionClose = true;
 168             return request(path, range);
 169         }
 170     }
 171
 172     return i_ret;
 173 }
 174
 175 ssize_t HTTPConnection::read(void *p_buffer, size_t len)
 176 {
 177     if( !connected() ||
 178        (!queryOk && bytesRead == 0) )
 179         return VLC_EGENERIC;
 180
 181     if(len == 0)
 182         return VLC_SUCCESS;
 183
 184     queryOk = false;
 185
 186     const size_t toRead = (contentLength) ? contentLength - bytesRead : len;
 187     if (toRead == 0)
 188         return VLC_SUCCESS;
 189
 190     if(len > toRead)
 191         len = toRead;
 192
 193     ssize_t ret = ( chunked ) ? readChunk(p_buffer, len)
 194                               : socket->read(p_object, p_buffer, len);
 195     if(ret >= 0)
 196         bytesRead += ret;
 197
 198     if(ret < 0 || (size_t)ret < len || /* set EOF */
 199        (contentLength == bytesRead && connectionClose))
 200     {
 201         socket->disconnect();
 202         return ret;
 203     }
 204
 205     return ret;
 206 }
 207
 208 bool HTTPConnection::send(const std::string &data)
 209 {
 210     return send(data.c_str(), data.length());
 211 }
 212
 213 bool HTTPConnection::send(const void *buf, size_t size)
 214 {
 215     return socket->send(p_object, buf, size);
 216 }
 217
 218 int HTTPConnection::parseReply()
 219 {
 220     std::string statusline = readLine();
 221
 222     if(statusline.empty())
 223         return VLC_EGENERIC;
 224
 225     if (statusline.compare(0, 9, "HTTP/1.1 ")!=0)
 226     {
 227         if(statusline.compare(0, 9, "HTTP/1.0 ")!=0)
 228             return VLC_ENOOBJ;
 229         else
 230             connectionClose = true;
 231     }
 232
 233     std::istringstream ss(statusline.substr(9));
 234     ss.imbue(std::locale("C"));
 235     int replycode;
 236     ss >> replycode;
 237
 238     std::string line = readLine();
 239
 240     while(!line.empty() && line.compare("\r\n"))
 241     {
 242         size_t split = line.find_first_of(':');
 243         size_t value = split + 1;
 244
 245         while(line.at(value) == ' ')
 246             value++;
 247
 248         onHeader(line.substr(0, split), line.substr(value));
 249         line = readLine();
 250     }
 251
 252     if((replycode == 301 || replycode == 302 || replycode == 307 || replycode == 308) &&
 253        !locationparams.getUrl().empty())
 254     {
 255         msg_Info(p_object, "%d redirection to %s", replycode, locationparams.getUrl().c_str());
 256         return VLC_ETIMEOUT;
 257     }
 258     else if (replycode != 200 && replycode != 206)
 259     {
 260         msg_Err(p_object, "Failed reading %s: %s", params.getUrl().c_str(), statusline.c_str());
 261         return VLC_ENOOBJ;
 262     }
 263
 264     return VLC_SUCCESS;
 265 }
 266
 267 ssize_t HTTPConnection::readChunk(void *p_buffer, size_t len)
 268 {
 269     size_t copied = 0;
 270
 271     for( ; copied < len && !chunked_eof; )
 272     {
 273         /* adapted from access/http/chunked.c */
 274         if(chunkLength == 0)
 275         {
 276             std::string line = readLine();
 277             int end;
 278             if (std::sscanf(line.c_str(), "%zx%n", &chunkLength, &end) < 1
 279                     || (line[end] != '\0' && line[end] != ';' /* ignore extension(s) */))
 280                 return -1;
 281         }
 282
 283         if(chunkLength > 0)
 284         {
 285             size_t toread = len - copied;
 286             if(toread > chunkLength)
 287                 toread = chunkLength;
 288
 289             ssize_t in = socket->read(p_object, &((uint8_t*)p_buffer)[copied], toread);
 290             if(in < 0)
 291             {
 292                 return (copied == 0) ? in : copied;
 293             }
 294             else if((size_t)in < toread)
 295             {
 296                return copied + in;
 297             }
 298             copied += in;
 299             chunkLength -= in;
 300         }
 301         else chunked_eof = true;
 302
 303         if(chunkLength == 0)
 304         {
 305             char crlf[2];
 306             ssize_t in = socket->read(p_object, &crlf, 2);
 307             if(in < 2 || memcmp(crlf, "\r\n", 2))
 308                 return (copied == 0) ? -1 : copied;
 309         }
 310     }
 311
 312     return copied;
 313 }
 314
 315 std::string HTTPConnection::readLine()
 316 {
 317     return socket->readline(p_object);
 318 }
 319
 320 void HTTPConnection::setUsed( bool b )
 321 {
 322     available = !b;
 323     if(available)
 324     {
 325         if(!connectionClose && contentLength == bytesRead )
 326         {
 327             queryOk = false;
 328             bytesRead = 0;
 329             contentLength = 0;
 330             bytesRange = BytesRange();
 331         }
 332         else  /* We can't resend request if we haven't finished reading */
 333             disconnect();
 334     }
 335 }
 336
 337 void HTTPConnection::onHeader(const std::string &key,
 338                               const std::string &value)
 339 {
 340     if(key == "Content-Length")
 341     {
 342         std::istringstream ss(value);
 343         ss.imbue(std::locale("C"));
 344         size_t length;
 345         ss >> length;
 346         contentLength = length;
 347     }
 348     else if (key == "Connection" && value =="close")
 349     {
 350         connectionClose = true;
 351     }
 352     else if (key == "Transfer-Encoding" && value == "chunked")
 353     {
 354         chunked = true;
 355     }
 356     else if(key == "Location")
 357     {
 358         locationparams = ConnectionParams( value );
 359     }
 360 }
 361
 362 std::string HTTPConnection::buildRequestHeader(const std::string &path) const
 363 {
 364     std::stringstream req;
 365     req << "GET " << path << " HTTP/1.1\r\n";
 366     if((params.getScheme() == "http" && params.getPort() != 80) ||
 367             (params.getScheme() == "https" && params.getPort() != 443))
 368     {
 369         req << "Host: " << params.getHostname() << ":" << params.getPort() << "\r\n";
 370     }
 371     else
 372     {
 373         req << "Host: " << params.getHostname() << "\r\n";
 374     }
 375     req << "Cache-Control: no-cache" << "\r\n" <<
 376            "User-Agent: " << std::string(psz_useragent) << "\r\n";
 377     req << extraRequestHeaders();
 378     return req.str();
 379 }
 380
 381 std::string HTTPConnection::extraRequestHeaders() const
 382 {
 383     std::stringstream ss;
 384     ss.imbue(std::locale("C"));
 385     if(bytesRange.isValid())
 386     {
 387         ss << "Range: bytes=" << bytesRange.getStartByte() << "-";
 388         if(bytesRange.getEndByte())
 389             ss << bytesRange.getEndByte();
 390         ss << "\r\n";
 391     }
 392     return ss.str();
 393 }
 394
 395 StreamUrlConnection::StreamUrlConnection(vlc_object_t *p_object)
 396     : AbstractConnection(p_object)
 397 {
 398     p_streamurl = NULL;
 399     bytesRead = 0;
 400     contentLength = 0;
 401 }
 402
 403 StreamUrlConnection::~StreamUrlConnection()
 404 {
 405     reset();
 406 }
 407
 408 void StreamUrlConnection::reset()
 409 {
 410     if(p_streamurl)
 411         vlc_stream_Delete(p_streamurl);
 412     p_streamurl = NULL;
 413     bytesRead = 0;
 414     contentLength = 0;
 415     bytesRange = BytesRange();
 416 }
 417
 418 bool StreamUrlConnection::canReuse(const ConnectionParams &) const
 419 {
 420     return available;
 421 }
 422
 423 int StreamUrlConnection::request(const std::string &path, const BytesRange &range)
 424 {
 425     reset();
 426
 427     /* Set new path for this query */
 428     params.setPath(path);
 429
 430     msg_Dbg(p_object, "Retrieving %s @%zu", params.getUrl().c_str(),
 431                       range.isValid() ? range.getStartByte() : 0);
 432
 433     p_streamurl = vlc_stream_NewURL(p_object, params.getUrl().c_str());
 434     if(!p_streamurl)
 435         return VLC_EGENERIC;
 436
 437     stream_t *p_chain = vlc_stream_FilterNew( p_streamurl, "inflate" );
 438     if( p_chain )
 439         p_streamurl = p_chain;
 440
 441     if(range.isValid() && range.getEndByte() > 0)
 442     {
 443         if(vlc_stream_Seek(p_streamurl, range.getStartByte()) != VLC_SUCCESS)
 444         {
 445             vlc_stream_Delete(p_streamurl);
 446             return VLC_EGENERIC;
 447         }
 448         bytesRange = range;
 449         contentLength = range.getEndByte() - range.getStartByte() + 1;
 450     }
 451
 452     int64_t i_size = stream_Size(p_streamurl);
 453     if(i_size > -1)
 454     {
 455         if(!range.isValid() || contentLength > (size_t) i_size)
 456             contentLength = (size_t) i_size;
 457     }
 458     return VLC_SUCCESS;
 459 }
 460
 461 ssize_t StreamUrlConnection::read(void *p_buffer, size_t len)
 462 {
 463     if( !p_streamurl )
 464         return VLC_EGENERIC;
 465
 466     if(len == 0)
 467         return VLC_SUCCESS;
 468
 469     const size_t toRead = (contentLength) ? contentLength - bytesRead : len;
 470     if (toRead == 0)
 471         return VLC_SUCCESS;
 472
 473     if(len > toRead)
 474         len = toRead;
 475
 476     ssize_t ret = vlc_stream_Read(p_streamurl, p_buffer, len);
 477     if(ret >= 0)
 478         bytesRead += ret;
 479
 480     if(ret < 0 || (size_t)ret < len || /* set EOF */
 481        contentLength == bytesRead )
 482     {
 483         reset();
 484         return ret;
 485     }
 486
 487     return ret;
 488 }
 489
 490 void StreamUrlConnection::setUsed( bool b )
 491 {
 492     available = !b;
 493     if(available && contentLength == bytesRead)
 494        reset();
 495 }
 496
 497 ConnectionFactory::ConnectionFactory()
 498 {
 499 }
 500
 501 ConnectionFactory::~ConnectionFactory()
 502 {
 503 }
 504
 505 AbstractConnection * ConnectionFactory::createConnection(vlc_object_t *p_object,
 506                                                          const ConnectionParams &params)
 507 {
 508     if((params.getScheme() != "http" && params.getScheme() != "https") || params.getHostname().empty())
 509         return NULL;
 510
 511     const int sockettype = (params.getScheme() == "https") ? TLSSocket::TLS : Socket::REGULAR;
 512     Socket *socket = (sockettype == TLSSocket::TLS) ? new (std::nothrow) TLSSocket()
 513                                                     : new (std::nothrow) Socket();
 514     if(!socket)
 515         return NULL;
 516
 517     /* disable pipelined tls until we have ticket/resume session support */
 518     HTTPConnection *conn = new (std::nothrow)
 519             HTTPConnection(p_object, socket, sockettype != TLSSocket::TLS);
 520     if(!conn)
 521     {
 522         delete socket;
 523         return NULL;
 524     }
 525
 526     return conn;
 527 }
 528
 529 AbstractConnection * StreamUrlConnectionFactory::createConnection(vlc_object_t *p_object,
 530                                                                   const ConnectionParams &)
 531 {
 532     return new (std::nothrow) StreamUrlConnection(p_object);
 533 }