rbutil/rbutilqt/base/httpget.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2013 by Dominik Riebeling
  10  *
  11  * All files in this archive are subject to the GNU General Public License.
  12  * See the file COPYING in the source tree root for full license agreement.
  13  *
  14  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  15  * KIND, either express or implied.
  16  *
  17  ****************************************************************************/
  18
  19 #include <QtNetwork>
  20 #include <QtDebug>
  21
  22 #include <QNetworkAccessManager>
  23 #include <QNetworkRequest>
  24
  25 #include "httpget.h"
  26
  27 QString HttpGet::m_globalUserAgent; //< globally set user agent for requests
  28 QDir HttpGet::m_globalCache; //< global cach path value for new objects
  29 QNetworkProxy HttpGet::m_globalProxy;
  30
  31 HttpGet::HttpGet(QObject *parent)
  32     : QObject(parent)
  33 {
  34     m_mgr = new QNetworkAccessManager(this);
  35     m_cache = NULL;
  36     m_cachedir = m_globalCache;
  37     setCache(true);
  38     connect(m_mgr, SIGNAL(finished(QNetworkReply*)),
  39             this, SLOT(requestFinished(QNetworkReply*)));
  40     m_outputFile = NULL;
  41     m_lastServerTimestamp = QDateTime();
  42     m_proxy = QNetworkProxy::NoProxy;
  43     m_reply = NULL;
  44 }
  45
  46
  47 //! @brief set cache path
  48 //  @param d new directory to use as cache path
  49 void HttpGet::setCache(const QDir& d)
  50 {
  51     if(m_cache && m_cachedir == d.absolutePath())
  52         return;
  53     m_cachedir = d.absolutePath();
  54     setCache(true);
  55 }
  56
  57
  58 /** @brief enable / disable cache useage
  59  *  @param c set cache usage
  60  */
  61 void HttpGet::setCache(bool c)
  62 {
  63     // don't change cache if it's already (un)set.
  64     if(c && m_cache) return;
  65     if(!c && !m_cache) return;
  66     // don't delete the old cache directly, it might still be in use. Just
  67     // instruct it to delete itself later.
  68     if(m_cache) m_cache->deleteLater();
  69     m_cache = NULL;
  70
  71     QString path = m_cachedir.absolutePath();
  72
  73     if(!c || m_cachedir.absolutePath().isEmpty()) {
  74         qDebug() << "[HttpGet] disabling download cache";
  75     }
  76     else {
  77         // append the cache path to make it unique in case the path points to
  78         // the system temporary path. In that case using it directly might
  79         // cause problems. Extra path also used in configure dialog.
  80         path += "/rbutil-cache";
  81         qDebug() << "[HttpGet] setting cache folder to" << path;
  82         m_cache = new QNetworkDiskCache(this);
  83         m_cache->setCacheDirectory(path);
  84     }
  85     m_mgr->setCache(m_cache);
  86 }
  87
  88
  89 /** @brief read all downloaded data into a buffer
  90  *  @return data
  91  */
  92 QByteArray HttpGet::readAll()
  93 {
  94     return m_data;
  95 }
  96
  97
  98 void HttpGet::setProxy(const QUrl &proxy)
  99 {
 100     qDebug() << "[HttpGet] Proxy set to" << proxy;
 101     m_proxy.setType(QNetworkProxy::HttpProxy);
 102     m_proxy.setHostName(proxy.host());
 103     m_proxy.setPort(proxy.port());
 104     m_proxy.setUser(proxy.userName());
 105     m_proxy.setPassword(proxy.password());
 106     m_mgr->setProxy(m_proxy);
 107 }
 108
 109
 110 void HttpGet::setProxy(bool enable)
 111 {
 112     if(enable) m_mgr->setProxy(m_proxy);
 113     else m_mgr->setProxy(QNetworkProxy::NoProxy);
 114 }
 115
 116
 117 void HttpGet::setFile(QFile *file)
 118 {
 119     m_outputFile = file;
 120 }
 121
 122
 123 void HttpGet::abort()
 124 {
 125     if(m_reply) m_reply->abort();
 126 }
 127
 128
 129 void HttpGet::requestFinished(QNetworkReply* reply)
 130 {
 131     m_lastStatusCode
 132         = reply->attribute(QNetworkRequest::HttpStatusCodeAttribute).toInt();
 133     qDebug() << "[HttpGet] Request finished, status code:" << m_lastStatusCode;
 134     m_lastServerTimestamp
 135         = reply->header(QNetworkRequest::LastModifiedHeader).toDateTime().toLocalTime();
 136     qDebug() << "[HttpGet] Data from cache:"
 137              << reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool();
 138     m_lastRequestCached =
 139         reply->attribute(QNetworkRequest::SourceIsFromCacheAttribute).toBool();
 140     if(reply->attribute(QNetworkRequest::RedirectionTargetAttribute).isValid()) {
 141         // handle relative URLs using QUrl::resolved()
 142         QUrl org = reply->request().url();
 143         QUrl url = QUrl(org).resolved(
 144                 reply->attribute(QNetworkRequest::RedirectionTargetAttribute).toUrl());
 145         // reconstruct query
 146 #if QT_VERSION < 0x050000
 147         QList<QPair<QByteArray, QByteArray> > qitms = org.encodedQueryItems();
 148         for(int i = 0; i < qitms.size(); ++i)
 149             url.addEncodedQueryItem(qitms.at(i).first, qitms.at(i).second);
 150 #else
 151         url.setQuery(org.query());
 152 #endif
 153         qDebug() << "[HttpGet] Redirected to" << url;
 154         startRequest(url);
 155         return;
 156     }
 157     else if(m_lastStatusCode == 200) {
 158         m_data = reply->readAll();
 159         if(m_outputFile && m_outputFile->open(QIODevice::WriteOnly)) {
 160             m_outputFile->write(m_data);
 161             m_outputFile->close();
 162         }
 163         emit done(false);
 164     }
 165     else {
 166         m_data.clear();
 167         emit done(true);
 168     }
 169     reply->deleteLater();
 170     m_reply = NULL;
 171 }
 172
 173
 174 void HttpGet::downloadProgress(qint64 received, qint64 total)
 175 {
 176     emit dataReadProgress((int)received, (int)total);
 177 }
 178
 179
 180 void HttpGet::startRequest(QUrl url)
 181 {
 182     qDebug() << "[HttpGet] Request started";
 183     QNetworkRequest req(url);
 184     if(!m_globalUserAgent.isEmpty())
 185         req.setRawHeader("User-Agent", m_globalUserAgent.toLatin1());
 186
 187     m_reply = m_mgr->get(req);
 188     connect(m_reply, SIGNAL(error(QNetworkReply::NetworkError)),
 189             this, SLOT(networkError(QNetworkReply::NetworkError)));
 190     connect(m_reply, SIGNAL(downloadProgress(qint64, qint64)),
 191             this, SLOT(downloadProgress(qint64, qint64)));
 192 }
 193
 194
 195 void HttpGet::networkError(QNetworkReply::NetworkError error)
 196 {
 197     qDebug() << "[HttpGet] NetworkError occured:"
 198              << error << m_reply->errorString();
 199     m_lastErrorString = m_reply->errorString();
 200 }
 201
 202
 203 bool HttpGet::getFile(const QUrl &url)
 204 {
 205     qDebug() << "[HttpGet] Get URI" << url.toString();
 206     m_data.clear();
 207     startRequest(url);
 208
 209     return false;
 210 }
 211
 212
 213 QString HttpGet::errorString(void)
 214 {
 215     return m_lastErrorString;
 216 }
 217
 218
 219 int HttpGet::httpResponse(void)
 220 {
 221     return m_lastStatusCode;
 222 }
 223