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 lines;
 239     for( ;; )
 240     {
 241         std::string l = readLine();
 242         if(l.empty())
 243             break;
 244         lines.append(l);
 245
 246         size_t split = lines.find_first_of(':');
 247         if(split != std::string::npos)
 248         {
 249             size_t value = lines.find_first_not_of(' ', split + 1);
 250             if(value == std::string::npos)
 251                 value = lines.length();
 252             onHeader(lines.substr(0, split), lines.substr(value));
 253             lines = std::string();
 254         }
 255     }
 256
 257     if((replycode == 301 || replycode == 302 || replycode == 307 || replycode == 308) &&
 258        !locationparams.getUrl().empty())
 259     {
 260         msg_Info(p_object, "%d redirection to %s", replycode, locationparams.getUrl().c_str());
 261         return VLC_ETIMEOUT;
 262     }
 263     else if (replycode != 200 && replycode != 206)
 264     {
 265         msg_Err(p_object, "Failed reading %s: %s", params.getUrl().c_str(), statusline.c_str());
 266         return VLC_ENOOBJ;
 267     }
 268
 269     return VLC_SUCCESS;
 270 }
 271
 272 ssize_t HTTPConnection::readChunk(void *p_buffer, size_t len)
 273 {
 274     size_t copied = 0;
 275
 276     for( ; copied < len && !chunked_eof; )
 277     {
 278         /* adapted from access/http/chunked.c */
 279         if(chunkLength == 0)
 280         {
 281             std::string line = readLine();
 282             int end;
 283             if (std::sscanf(line.c_str(), "%zx%n", &chunkLength, &end) < 1
 284                     || (line[end] != '\0' && line[end] != ';' /* ignore extension(s) */))
 285                 return -1;
 286         }
 287
 288         if(chunkLength > 0)
 289         {
 290             size_t toread = len - copied;
 291             if(toread > chunkLength)
 292                 toread = chunkLength;
 293
 294             ssize_t in = socket->read(p_object, &((uint8_t*)p_buffer)[copied], toread);
 295             if(in < 0)
 296             {
 297                 return (copied == 0) ? in : copied;
 298             }
 299             else if((size_t)in < toread)
 300             {
 301                return copied + in;
 302             }
 303             copied += in;
 304             chunkLength -= in;
 305         }
 306         else chunked_eof = true;
 307
 308         if(chunkLength == 0)
 309         {
 310             char crlf[2];
 311             ssize_t in = socket->read(p_object, &crlf, 2);
 312             if(in < 2 || memcmp(crlf, "\r\n", 2))
 313                 return (copied == 0) ? -1 : copied;
 314         }
 315     }
 316
 317     return copied;
 318 }
 319
 320 std::string HTTPConnection::readLine()
 321 {
 322     return socket->readline(p_object);
 323 }
 324
 325 void HTTPConnection::setUsed( bool b )
 326 {
 327     available = !b;
 328     if(available)
 329     {
 330         if(!connectionClose && contentLength == bytesRead )
 331         {
 332             queryOk = false;
 333             bytesRead = 0;
 334             contentLength = 0;
 335             bytesRange = BytesRange();
 336         }
 337         else  /* We can't resend request if we haven't finished reading */
 338             disconnect();
 339     }
 340 }
 341
 342 void HTTPConnection::onHeader(const std::string &key,
 343                               const std::string &value)
 344 {
 345     if(key == "Content-Length")
 346     {
 347         std::istringstream ss(value);
 348         ss.imbue(std::locale("C"));
 349         size_t length;
 350         ss >> length;
 351         contentLength = length;
 352     }
 353     else if (key == "Connection" && value =="close")
 354     {
 355         connectionClose = true;
 356     }
 357     else if (key == "Transfer-Encoding" && value == "chunked")
 358     {
 359         chunked = true;
 360     }
 361     else if(key == "Location")
 362     {
 363         locationparams = ConnectionParams( value );
 364     }
 365 }
 366
 367 std::string HTTPConnection::buildRequestHeader(const std::string &path) const
 368 {
 369     std::stringstream req;
 370     req << "GET " << path << " HTTP/1.1\r\n";
 371     if((params.getScheme() == "http" && params.getPort() != 80) ||
 372             (params.getScheme() == "https" && params.getPort() != 443))
 373     {
 374         req << "Host: " << params.getHostname() << ":" << params.getPort() << "\r\n";
 375     }
 376     else
 377     {
 378         req << "Host: " << params.getHostname() << "\r\n";
 379     }
 380     req << "Cache-Control: no-cache" << "\r\n" <<
 381            "User-Agent: " << std::string(psz_useragent) << "\r\n";
 382     req << extraRequestHeaders();
 383     return req.str();
 384 }
 385
 386 std::string HTTPConnection::extraRequestHeaders() const
 387 {
 388     std::stringstream ss;
 389     ss.imbue(std::locale("C"));
 390     if(bytesRange.isValid())
 391     {
 392         ss << "Range: bytes=" << bytesRange.getStartByte() << "-";
 393         if(bytesRange.getEndByte())
 394             ss << bytesRange.getEndByte();
 395         ss << "\r\n";
 396     }
 397     return ss.str();
 398 }
 399
 400 StreamUrlConnection::StreamUrlConnection(vlc_object_t *p_object)
 401     : AbstractConnection(p_object)
 402 {
 403     p_streamurl = NULL;
 404     bytesRead = 0;
 405     contentLength = 0;
 406 }
 407
 408 StreamUrlConnection::~StreamUrlConnection()
 409 {
 410     reset();
 411 }
 412
 413 void StreamUrlConnection::reset()
 414 {
 415     if(p_streamurl)
 416         vlc_stream_Delete(p_streamurl);
 417     p_streamurl = NULL;
 418     bytesRead = 0;
 419     contentLength = 0;
 420     bytesRange = BytesRange();
 421 }
 422
 423 bool StreamUrlConnection::canReuse(const ConnectionParams &) const
 424 {
 425     return available;
 426 }
 427
 428 int StreamUrlConnection::request(const std::string &path, const BytesRange &range)
 429 {
 430     reset();
 431
 432     /* Set new path for this query */
 433     params.setPath(path);
 434
 435     msg_Dbg(p_object, "Retrieving %s @%zu", params.getUrl().c_str(),
 436                       range.isValid() ? range.getStartByte() : 0);
 437
 438     p_streamurl = vlc_stream_NewURL(p_object, params.getUrl().c_str());
 439     if(!p_streamurl)
 440         return VLC_EGENERIC;
 441
 442     stream_t *p_chain = vlc_stream_FilterNew( p_streamurl, "inflate" );
 443     if( p_chain )
 444         p_streamurl = p_chain;
 445
 446     if(range.isValid() && range.getEndByte() > 0)
 447     {
 448         if(vlc_stream_Seek(p_streamurl, range.getStartByte()) != VLC_SUCCESS)
 449         {
 450             vlc_stream_Delete(p_streamurl);
 451             return VLC_EGENERIC;
 452         }
 453         bytesRange = range;
 454         contentLength = range.getEndByte() - range.getStartByte() + 1;
 455     }
 456
 457     int64_t i_size = stream_Size(p_streamurl);
 458     if(i_size > -1)
 459     {
 460         if(!range.isValid() || contentLength > (size_t) i_size)
 461             contentLength = (size_t) i_size;
 462     }
 463     return VLC_SUCCESS;
 464 }
 465
 466 ssize_t StreamUrlConnection::read(void *p_buffer, size_t len)
 467 {
 468     if( !p_streamurl )
 469         return VLC_EGENERIC;
 470
 471     if(len == 0)
 472         return VLC_SUCCESS;
 473
 474     const size_t toRead = (contentLength) ? contentLength - bytesRead : len;
 475     if (toRead == 0)
 476         return VLC_SUCCESS;
 477
 478     if(len > toRead)
 479         len = toRead;
 480
 481     ssize_t ret = vlc_stream_Read(p_streamurl, p_buffer, len);
 482     if(ret >= 0)
 483         bytesRead += ret;
 484
 485     if(ret < 0 || (size_t)ret < len || /* set EOF */
 486        contentLength == bytesRead )
 487     {
 488         reset();
 489         return ret;
 490     }
 491
 492     return ret;
 493 }
 494
 495 void StreamUrlConnection::setUsed( bool b )
 496 {
 497     available = !b;
 498     if(available && contentLength == bytesRead)
 499        reset();
 500 }
 501
 502 ConnectionFactory::ConnectionFactory()
 503 {
 504 }
 505
 506 ConnectionFactory::~ConnectionFactory()
 507 {
 508 }
 509
 510 AbstractConnection * ConnectionFactory::createConnection(vlc_object_t *p_object,
 511                                                          const ConnectionParams &params)
 512 {
 513     if((params.getScheme() != "http" && params.getScheme() != "https") || params.getHostname().empty())
 514         return NULL;
 515
 516     const int sockettype = (params.getScheme() == "https") ? TLSSocket::TLS : Socket::REGULAR;
 517     Socket *socket = (sockettype == TLSSocket::TLS) ? new (std::nothrow) TLSSocket()
 518                                                     : new (std::nothrow) Socket();
 519     if(!socket)
 520         return NULL;
 521
 522     /* disable pipelined tls until we have ticket/resume session support */
 523     HTTPConnection *conn = new (std::nothrow)
 524             HTTPConnection(p_object, socket, sockettype != TLSSocket::TLS);
 525     if(!conn)
 526     {
 527         delete socket;
 528         return NULL;
 529     }
 530
 531     return conn;
 532 }
 533
 534 AbstractConnection * StreamUrlConnectionFactory::createConnection(vlc_object_t *p_object,
 535                                                                   const ConnectionParams &)
 536 {
 537     return new (std::nothrow) StreamUrlConnection(p_object);
 538 }