/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtNetwork module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

//#define QNETWORKACCESSHTTPBACKEND_DEBUG

#include "qnetworkaccesshttpbackend_p.h"

#include "qnetworkaccessmanager_p.h"

#include "qnetworkaccesscache_p.h"

#include "qabstractnetworkcache.h"

#include "qnetworkrequest.h"

#include "qnetworkreply.h"

#include "qnetworkrequest_p.h"

#include "qnetworkcookie_p.h"

#include "QtCore/qdatetime.h"

#include "QtNetwork/qsslconfiguration.h"

#ifndef QT_NO_HTTP

#include <string.h>             // for strchr

QT_BEGIN_NAMESPACE

enum {

    DefaultHttpPort = 80,

    DefaultHttpsPort = 443

};

class QNetworkProxy;

static QByteArray makeCacheKey(QNetworkAccessHttpBackend *backend, QNetworkProxy *proxy)

{

    QByteArray result;

    QUrl copy = backend->url();

    bool isEncrypted = copy.scheme().toLower() == QLatin1String("https");

    copy.setPort(copy.port(isEncrypted ? DefaultHttpsPort : DefaultHttpPort));

    result = copy.toEncoded(QUrl::RemovePassword | QUrl::RemovePath |

                            QUrl::RemoveQuery | QUrl::RemoveFragment);

#ifndef QT_NO_NETWORKPROXY

    if (proxy->type() != QNetworkProxy::NoProxy) {

        QUrl key;

        switch (proxy->type()) {

        case QNetworkProxy::Socks5Proxy:

            key.setScheme(QLatin1String("proxy-socks5"));

            break;

        case QNetworkProxy::HttpProxy:

        case QNetworkProxy::HttpCachingProxy:

            key.setScheme(QLatin1String("proxy-http"));

            break;

        default:

            break;

        }

        if (!key.scheme().isEmpty()) {

            key.setUserName(proxy->user());

            key.setHost(proxy->hostName());

            key.setPort(proxy->port());

            key.setEncodedQuery(result);

            result = key.toEncoded();

        }

    }

#endif

    return "http-connection:" + result;

}

static inline bool isSeparator(register char c)

{

    static const char separators[] = "()<>@,;:\\\"/[]?={}";

    return isLWS(c) || strchr(separators, c) != 0;

}

// ### merge with nextField in cookiejar.cpp

static QHash<QByteArray, QByteArray> parseHttpOptionHeader(const QByteArray &header)

{

    // The HTTP header is of the form:

    // header          = #1(directives)

    // directives      = token | value-directive

    // value-directive = token "=" (token | quoted-string)

    QHash<QByteArray, QByteArray> result;

    int pos = 0;

    while (true) {

        // skip spaces

        pos = nextNonWhitespace(header, pos);

        if (pos == header.length())

            return result;      // end of parsing

        // pos points to a non-whitespace

        int comma = header.indexOf(',', pos);

        int equal = header.indexOf('=', pos);

        if (comma == pos || equal == pos)

            // huh? Broken header.

            return result;

        // The key name is delimited by either a comma, an equal sign or the end

        // of the header, whichever comes first

        int end = comma;

        if (end == -1)

            end = header.length();

        if (equal != -1 && end > equal)

            end = equal;        // equal sign comes before comma/end

        QByteArray key = QByteArray(header.constData() + pos, end - pos).trimmed().toLower();

        pos = end + 1;

        if (uint(equal) < uint(comma)) {

            // case: token "=" (token | quoted-string)

            // skip spaces

            pos = nextNonWhitespace(header, pos);

            if (pos == header.length())

                // huh? Broken header

                return result;

            QByteArray value;

            value.reserve(header.length() - pos);

            if (header.at(pos) == '"') {

                // case: quoted-string

                // quoted-string  = ( <"> *(qdtext | quoted-pair ) <"> )

                // qdtext         = <any TEXT except <">>

                // quoted-pair    = "\" CHAR

                ++pos;

                while (pos < header.length()) {

                    register char c = header.at(pos);

                    if (c == '"') {

                        // end of quoted text

                        break;

                    } else if (c == '\\') {

                        ++pos;

                        if (pos >= header.length())

                            // broken header

                            return result;

                        c = header.at(pos);

                    }

                    value += c;

                    ++pos;

                }

            } else {

                // case: token

                while (pos < header.length()) {

                    register char c = header.at(pos);

                    if (isSeparator(c))

                        break;

                    value += c;

                    ++pos;

                }

            }

            result.insert(key, value);

            // find the comma now:

            comma = header.indexOf(',', pos);

            if (comma == -1)

                return result;  // end of parsing

            pos = comma + 1;

        } else {

            // case: token

            // key is already set

            result.insert(key, QByteArray());

        }

    }

}

QNetworkAccessBackend *

QNetworkAccessHttpBackendFactory::create(QNetworkAccessManager::Operation op,

                                         const QNetworkRequest &request) const

{

    // check the operation

    switch (op) {

    case QNetworkAccessManager::GetOperation:

    case QNetworkAccessManager::PostOperation:

    case QNetworkAccessManager::HeadOperation:

    case QNetworkAccessManager::PutOperation:

    case QNetworkAccessManager::DeleteOperation:

        break;

    default:

        // no, we can't handle this request

        return 0;

    }

    QUrl url = request.url();

    QString scheme = url.scheme().toLower();

    if (scheme == QLatin1String("http") || scheme == QLatin1String("https"))

        return new QNetworkAccessHttpBackend;

    return 0;

}

static QNetworkReply::NetworkError statusCodeFromHttp(int httpStatusCode, const QUrl &url)

{

    QNetworkReply::NetworkError code;

    // we've got an error

    switch (httpStatusCode) {

    case 401:               // Authorization required

        code = QNetworkReply::AuthenticationRequiredError;

        break;

    case 403:               // Access denied

        code = QNetworkReply::ContentOperationNotPermittedError;

        break;

    case 404:               // Not Found

        code = QNetworkReply::ContentNotFoundError;

        break;

    case 405:               // Method Not Allowed

        code = QNetworkReply::ContentOperationNotPermittedError;

        break;

    case 407:

        code = QNetworkReply::ProxyAuthenticationRequiredError;

        break;

    default:

        if (httpStatusCode > 500) {

            // some kind of server error

            code = QNetworkReply::ProtocolUnknownError;

        } else if (httpStatusCode >= 400) {

            // content error we did not handle above

            code = QNetworkReply::UnknownContentError;

        } else {

            qWarning("QNetworkAccess: got HTTP status code %d which is not expected from url: \"%s\"",

                     httpStatusCode, qPrintable(url.toString()));

            code = QNetworkReply::ProtocolFailure;

        }

    }

    return code;

}

class QNetworkAccessCachedHttpConnection: public QHttpNetworkConnection,

                                      public QNetworkAccessCache::CacheableObject

{

    // Q_OBJECT

public:

    QNetworkAccessCachedHttpConnection(const QString &hostName, quint16 port, bool encrypt)

        : QHttpNetworkConnection(hostName, port, encrypt)

    {

        setExpires(true);

        setShareable(true);

    }

    virtual void dispose()

    {

#if 0  // sample code; do this right with the API

        Q_ASSERT(!isWorking());

#endif

        delete this;

    }

};

QNetworkAccessHttpBackend::QNetworkAccessHttpBackend()

    : QNetworkAccessBackend(), httpReply(0), http(0), uploadDevice(0)

#ifndef QT_NO_OPENSSL

    , pendingSslConfiguration(0), pendingIgnoreAllSslErrors(false)

#endif

{

}

QNetworkAccessHttpBackend::~QNetworkAccessHttpBackend()

{

    if (http)

        disconnectFromHttp();

#ifndef QT_NO_OPENSSL

    delete pendingSslConfiguration;

#endif

}

void QNetworkAccessHttpBackend::disconnectFromHttp()

{

    if (http) {

        // This is abut disconnecting signals, not about disconnecting TCP connections

        disconnect(http, 0, this, 0);

        // Get the object cache that stores our QHttpNetworkConnection objects

        QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);

        cache->releaseEntry(cacheKey);

    }

    // This is abut disconnecting signals, not about disconnecting TCP connections

    if (httpReply)

        disconnect(httpReply, 0, this, 0);

    http = 0;

    httpReply = 0;

    cacheKey.clear();

}

void QNetworkAccessHttpBackend::finished()

{

    if (http)

        disconnectFromHttp();

    // call parent

    QNetworkAccessBackend::finished();

}

void QNetworkAccessHttpBackend::setupConnection()

{

#ifndef QT_NO_NETWORKPROXY

    connect(http, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

            SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));

#endif

    connect(http, SIGNAL(authenticationRequired(QHttpNetworkRequest,QAuthenticator*)),

            SLOT(httpAuthenticationRequired(QHttpNetworkRequest,QAuthenticator*)));

    connect(http, SIGNAL(error(QNetworkReply::NetworkError,QString)),

            SLOT(httpError(QNetworkReply::NetworkError,QString)));

#ifndef QT_NO_OPENSSL

    connect(http, SIGNAL(sslErrors(QList<QSslError>)),

            SLOT(sslErrors(QList<QSslError>)));

#endif

}

/*

    For a given httpRequest

    1) If AlwaysNetwork, return

    2) If we have a cache entry for this url populate headers so the server can return 304

    3) Calculate if response_is_fresh and if so send the cache and set loadedFromCache to true

 */

void QNetworkAccessHttpBackend::validateCache(QHttpNetworkRequest &httpRequest, bool &loadedFromCache)

{

    QNetworkRequest::CacheLoadControl CacheLoadControlAttribute =

        (QNetworkRequest::CacheLoadControl)request().attribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferNetwork).toInt();

    if (CacheLoadControlAttribute == QNetworkRequest::AlwaysNetwork) {

        // forced reload from the network

        // tell any caching proxy servers to reload too

        httpRequest.setHeaderField("Cache-Control", "no-cache");

        httpRequest.setHeaderField("Pragma", "no-cache");

        return;

    }

    QAbstractNetworkCache *nc = networkCache();

    if (!nc)

        return;                 // no local cache

    QNetworkCacheMetaData metaData = nc->metaData(url());

    if (!metaData.isValid())

        return;                 // not in cache

    if (!metaData.saveToDisk())

        return;

    QNetworkHeadersPrivate cacheHeaders;

    QNetworkHeadersPrivate::RawHeadersList::ConstIterator it;

    cacheHeaders.setAllRawHeaders(metaData.rawHeaders());

    it = cacheHeaders.findRawHeader("etag");

    if (it != cacheHeaders.rawHeaders.constEnd())

        httpRequest.setHeaderField("If-None-Match", it->second);

    QDateTime lastModified = metaData.lastModified();

    if (lastModified.isValid())

        httpRequest.setHeaderField("If-Modified-Since", QNetworkHeadersPrivate::toHttpDate(lastModified));

    if (CacheLoadControlAttribute == QNetworkRequest::PreferNetwork) {

        it = cacheHeaders.findRawHeader("Cache-Control");

        if (it != cacheHeaders.rawHeaders.constEnd()) {

            QHash<QByteArray, QByteArray> cacheControl = parseHttpOptionHeader(it->second);

            if (cacheControl.contains("must-revalidate"))

                return;

        }

    }

    QDateTime currentDateTime = QDateTime::currentDateTime();

    QDateTime expirationDate = metaData.expirationDate();

#if 0

    /*

     * age_value

     *      is the value of Age: header received by the cache with

     *              this response.

     * date_value

     *      is the value of the origin server's Date: header

     * request_time

     *      is the (local) time when the cache made the request

     *              that resulted in this cached response

     * response_time

     *      is the (local) time when the cache received the

     *              response

     * now

     *      is the current (local) time

     */

    int age_value = 0;

    it = cacheHeaders.findRawHeader("age");

    if (it != cacheHeaders.rawHeaders.constEnd())

        age_value = it->second.toInt();

    QDateTime dateHeader;

    int date_value = 0;

    it = cacheHeaders.findRawHeader("date");

    if (it != cacheHeaders.rawHeaders.constEnd()) {

        dateHeader = QNetworkHeadersPrivate::fromHttpDate(it->second);

        date_value = dateHeader.toTime_t();

    }

    int now = currentDateTime.toUTC().toTime_t();

    int request_time = now;

    int response_time = now;

    // Algorithm from RFC 2616 section 13.2.3

    int apparent_age = qMax(0, response_time - date_value);

    int corrected_received_age = qMax(apparent_age, age_value);

    int response_delay = response_time - request_time;

    int corrected_initial_age = corrected_received_age + response_delay;

    int resident_time = now - response_time;

    int current_age   = corrected_initial_age + resident_time;

    // RFC 2616 13.2.4 Expiration Calculations

    if (!expirationDate.isValid()) {

        if (lastModified.isValid()) {

            int diff = currentDateTime.secsTo(lastModified);

            expirationDate = lastModified;

            expirationDate.addSecs(diff / 10);

            if (httpRequest.headerField("Warning").isEmpty()) {

                QDateTime dt;

                dt.setTime_t(current_age);

                if (dt.daysTo(currentDateTime) > 1)

                    httpRequest.setHeaderField("Warning", "113");

            }

        }

    }

    // the cache-saving code below sets the expirationDate with date+max_age

    // if "max-age" is present, or to Expires otherwise

    int freshness_lifetime = dateHeader.secsTo(expirationDate);

    bool response_is_fresh = (freshness_lifetime > current_age);

#else

    bool response_is_fresh = currentDateTime.secsTo(expirationDate) >= 0;

#endif

    if (!response_is_fresh)

        return;

    loadedFromCache = true;

#if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)

    qDebug() << "response_is_fresh" << CacheLoadControlAttribute;

#endif

    if (!sendCacheContents(metaData))

        loadedFromCache = false;

}

void QNetworkAccessHttpBackend::postRequest()

{

    bool loadedFromCache = false;

    QHttpNetworkRequest httpRequest;

    switch (operation()) {

    case QNetworkAccessManager::GetOperation:

        httpRequest.setOperation(QHttpNetworkRequest::Get);

        validateCache(httpRequest, loadedFromCache);

        break;

    case QNetworkAccessManager::HeadOperation:

        httpRequest.setOperation(QHttpNetworkRequest::Head);

        validateCache(httpRequest, loadedFromCache);

        break;

    case QNetworkAccessManager::PostOperation:

        invalidateCache();

        httpRequest.setOperation(QHttpNetworkRequest::Post);

        httpRequest.setUploadByteDevice(createUploadByteDevice());

        break;

    case QNetworkAccessManager::PutOperation:

        invalidateCache();

        httpRequest.setOperation(QHttpNetworkRequest::Put);

        httpRequest.setUploadByteDevice(createUploadByteDevice());

        break;

    case QNetworkAccessManager::DeleteOperation:

        invalidateCache();

        httpRequest.setOperation(QHttpNetworkRequest::Delete);

        break;

    default:

        break;                  // can't happen

    }

    httpRequest.setUrl(url());

    QList<QByteArray> headers = request().rawHeaderList();

    foreach (const QByteArray &header, headers)

        httpRequest.setHeaderField(header, request().rawHeader(header));

    if (loadedFromCache) {