mythhttpcache.cpp

Go to the documentation of this file.

// Qt
#include <QCryptographicHash>
 
// MythTV
#include "mythlogging.h"
#include "mythdate.h"
#include "http/mythhttpdata.h"
#include "http/mythhttpfile.h"
#include "http/mythhttpcache.h"
 
void MythHTTPCache::PreConditionCheck(const HTTPResponse& Response)
{
    // Retrieve content
    auto * data = std::get_if<HTTPData>(&Response->m_response);
    auto * file = std::get_if<HTTPFile>(&Response->m_response);
    if (!(file || data))
        return;
 
    int cache = data ? (*data)->m_cacheType : (*file)->m_cacheType;
 
    // Explicitly ignore caching (error responses etc)
    if (cache == HTTPIgnoreCache)
        return;
 
    // Explicitly request no caching
    if ((cache & HTTPNoCache) == HTTPNoCache)
        return;
 
    // We use the last modified data for both the last modified header and potentially
    // hashing for the etag
    auto & lastmodified = data ? (*data)->m_lastModified : (*file)->m_lastModified;
    if (!lastmodified.isValid())
        lastmodified = QDateTime::currentDateTime();
 
    // If-Range precondition can contain either a last-modified or ETag validator
    QString ifrange = MythHTTP::GetHeader(Response->m_requestHeaders, "if-range");
    bool checkifrange = !ifrange.isEmpty();
    bool removeranges = false;
 
    if ((cache & HTTPETag) == HTTPETag)
    {
        QByteArray& etag = data ? (*data)->m_etag : (*file)->m_etag;
        if (file)
        {
            QByteArray hashdata = ((*file)->fileName() + lastmodified.toString("ddMMyyyyhhmmsszzz")).toLocal8Bit().constData();
            etag = QCryptographicHash::hash(hashdata, QCryptographicHash::Sha224).toHex();
        }
        else
        {
            etag = QCryptographicHash::hash((*data)->constData(), QCryptographicHash::Sha224).toHex();
        }
 
        // This assumes only one or other is present...
        if (checkifrange)
        {
            removeranges = !ifrange.contains(etag);
        }
        else
        {
            QString nonematch = MythHTTP::GetHeader(Response->m_requestHeaders, "if-none-match");
            if (!nonematch.isEmpty() && (nonematch.contains(etag)))
                Response->m_status = HTTPNotModified;
        }
    }
    else if (((cache & HTTPLastModified) == HTTPLastModified))
    {
        auto RemoveMilliseconds = [](QDateTime& DateTime)
        {
            auto residual = DateTime.time().msec();
            DateTime = DateTime.addMSecs(-residual);
        };
 
        auto ParseModified = [](const QString& Modified)
        {
            QDateTime time = QDateTime::fromString(Modified, Qt::RFC2822Date);
#if QT_VERSION < QT_VERSION_CHECK(6,5,0)
            time.setTimeSpec(Qt::UTC);
#else
            time.setTimeZone(QTimeZone(QTimeZone::UTC));
#endif
            return time;
        };
 
        if (checkifrange)
        {
            auto time = ParseModified(ifrange);
            if (time.isValid())
            {
                RemoveMilliseconds(lastmodified);
                removeranges = lastmodified > time;
            }
        }
        else if (Response->m_requestType == HTTPGet || Response->m_requestType == HTTPHead)
        {
            QString modified = MythHTTP::GetHeader(Response->m_requestHeaders, "if-modified-since");
            if (!modified.isEmpty())
            {
                auto time = ParseModified(modified);
                if (time.isValid())
                {
                    RemoveMilliseconds(lastmodified);
                    if (lastmodified <= time)
                        Response->m_status = HTTPNotModified;
                }
            }
        }
    }
 
    // If the If-Range precondition fails, then we need to send back the complete
    // contents i.e. ignore any ranges. So search for the range headers and remove them.
    if (removeranges && Response->m_requestHeaders && Response->m_requestHeaders->contains("range"))
        Response->m_requestHeaders->replace("range", "");
}
 
void MythHTTPCache::PreConditionHeaders(const HTTPResponse& Response)
{
    // Retrieve content
    auto * data = std::get_if<HTTPData>(&Response->m_response);
    auto * file = std::get_if<HTTPFile>(&Response->m_response);
    if (!(file || data))
        return;
 
    int cache = data ? (*data)->m_cacheType : (*file)->m_cacheType;
 
    // Explicitly ignore caching (error responses etc)
    if (cache == HTTPIgnoreCache)
        return;
 
    // Explicitly request no caching
    if ((cache & HTTPNoCache) == HTTPNoCache)
    {
        Response->AddHeader("Cache-Control", "no-store, max-age=0");
        return;
    }
 
    // Add the default cache control header
    QString duration {"0"};    // ??
    if ((cache & HTTPLongLife) == HTTPLongLife)
        duration = "604800";   // 7 days
    else if ((cache & HTTPMediumLife) == HTTPMediumLife)
        duration = "7200";     // 2 Hours
    Response->AddHeader("Cache-Control", "no-cache=\"Ext\",max-age=" + duration);
 
    if ((cache & HTTPETag) == HTTPETag)
    {
        Response->AddHeader("ETag", QString("\"") + (data ? (*data)->m_etag : (*file)->m_etag) + "\"");
    }
    else if ((cache & HTTPLastModified) == HTTPLastModified)
    {
        auto & lastmodified = data ? (*data)->m_lastModified : (*file)->m_lastModified;
        auto last = MythDate::toString(lastmodified, MythDate::kOverrideUTC | MythDate::kRFC822);
        Response->AddHeader("Last-Modified", last);
    }
}