adblocksubscription.cpp

Go to the documentation of this file.

/* ============================================================
* Falkon - Qt web browser
* Copyright (C) 2010-2018 David Rosca <nowrep@gmail.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
* ============================================================ */
#include "adblocksubscription.h"
#include "adblockmanager.h"
#include "mainapplication.h"
#include "networkmanager.h"
#include "datapaths.h"
#include "qztools.h"
 
#include <QFile>
#include <QTimer>
#include <QNetworkReply>
#include <QSaveFile>
 
AdBlockSubscription::AdBlockSubscription(const QString &title, QObject* parent)
    : QObject(parent)
    , m_reply(nullptr)
    , m_title(title)
    , m_updated(false)
{
}
 
QString AdBlockSubscription::title() const
{
    return m_title;
}
 
QString AdBlockSubscription::filePath() const
{
    return m_filePath;
}
 
void AdBlockSubscription::setFilePath(const QString &path)
{
    m_filePath = path;
}
 
QUrl AdBlockSubscription::url() const
{
    return m_url;
}
 
void AdBlockSubscription::setUrl(const QUrl &url)
{
    m_url = url;
}
 
void AdBlockSubscription::loadSubscription(const QStringList &disabledRules)
{
    QFile file(m_filePath);
 
    if (!file.exists()) {
        QTimer::singleShot(0, this, &AdBlockSubscription::updateSubscription);
        return;
    }
 
    if (!file.open(QFile::ReadOnly)) {
        qWarning() << "AdBlockSubscription::" << __FUNCTION__ << "Unable to open adblock file for reading" << m_filePath;
        QTimer::singleShot(0, this, &AdBlockSubscription::updateSubscription);
        return;
    }
 
    QTextStream textStream(&file);
    textStream.setEncoding(QStringConverter::Utf8);
    // Header is on 3rd line
    textStream.readLine(1024);
    textStream.readLine(1024);
    QString header = textStream.readLine(1024);
 
    if (!header.startsWith(QLatin1String("[Adblock")) || m_title.isEmpty()) {
        qWarning() << "AdBlockSubscription::" << __FUNCTION__ << "invalid format of adblock file" << m_filePath;
        QTimer::singleShot(0, this, &AdBlockSubscription::updateSubscription);
        return;
    }
 
    qDeleteAll(m_rules);
    m_rules.clear();
 
    while (!textStream.atEnd()) {
        const QString line = textStream.readLine().trimmed();
        if (line.isEmpty()) {
            continue;
        }
        auto *rule = new AdBlockRule(line, this);
        if (disabledRules.contains(rule->filter())) {
            rule->setEnabled(false);
        }
        m_rules.append(rule);
    }
 
    // Initial update
    if (m_rules.isEmpty() && !m_updated) {
        QTimer::singleShot(0, this, &AdBlockSubscription::updateSubscription);
    }
}
 
void AdBlockSubscription::saveSubscription()
{
}
 
void AdBlockSubscription::updateSubscription()
{
    if (m_reply || !m_url.isValid()) {
        return;
    }
 
    m_reply = mApp->networkManager()->get(QNetworkRequest(m_url));
    connect(m_reply, &QNetworkReply::finished, this, &AdBlockSubscription::subscriptionDownloaded);
}
 
void AdBlockSubscription::subscriptionDownloaded()
{
    if (m_reply != qobject_cast<QNetworkReply*>(sender())) {
        return;
    }
 
    bool error = false;
    const QByteArray response = QString::fromUtf8(m_reply->readAll()).toUtf8();
 
    if (m_reply->error() != QNetworkReply::NoError ||
        !response.startsWith(QByteArray("[Adblock")) ||
        !saveDownloadedData(response)
       ) {
        error = true;
    }
 
    m_reply->deleteLater();
    m_reply = nullptr;
 
    if (error) {
        Q_EMIT subscriptionError(tr("Cannot load subscription!"));
        return;
    }
 
    loadSubscription(AdBlockManager::instance()->disabledRules());
 
    Q_EMIT subscriptionUpdated();
    Q_EMIT subscriptionChanged();
}
 
bool AdBlockSubscription::saveDownloadedData(const QByteArray &data)
{
    QSaveFile file(m_filePath);
 
    if (!file.open(QFile::WriteOnly)) {
        qWarning() << "AdBlockSubscription::" << __FUNCTION__ << "Unable to open adblock file for writing:" << m_filePath;
        return false;
    }
 
    // Write subscription header
    file.write(QSL("Title: %1\nUrl: %2\n").arg(title(), url().toString()).toUtf8());
    file.write(data);
    file.commit();
    return true;
}
 
const AdBlockRule* AdBlockSubscription::rule(int offset) const
{
    if (!QzTools::containsIndex(m_rules, offset)) {
        return nullptr;
    }
 
    return m_rules[offset];
}
 
QVector<AdBlockRule*> AdBlockSubscription::allRules() const
{
    return m_rules;
}
 
const AdBlockRule* AdBlockSubscription::enableRule(int offset)
{
    if (!QzTools::containsIndex(m_rules, offset)) {
        return nullptr;
    }
 
    AdBlockRule* rule = m_rules[offset];
    rule->setEnabled(true);
    AdBlockManager::instance()->removeDisabledRule(rule->filter());
 
    Q_EMIT subscriptionChanged();
 
    if (rule->isCssRule())
        mApp->reloadUserStyleSheet();
 
    return rule;
}
 
const AdBlockRule* AdBlockSubscription::disableRule(int offset)
{
    if (!QzTools::containsIndex(m_rules, offset)) {
        return nullptr;
    }
 
    AdBlockRule* rule = m_rules[offset];
    rule->setEnabled(false);
    AdBlockManager::instance()->addDisabledRule(rule->filter());
 
    Q_EMIT subscriptionChanged();
 
    if (rule->isCssRule())
        mApp->reloadUserStyleSheet();
 
    return rule;
}
 
bool AdBlockSubscription::canEditRules() const
{
    return false;
}
 
bool AdBlockSubscription::canBeRemoved() const
{
    return true;
}
 
int AdBlockSubscription::addRule(AdBlockRule* rule)
{
    Q_UNUSED(rule)
    return -1;
}
 
bool AdBlockSubscription::removeRule(int offset)
{
    Q_UNUSED(offset)
    return false;
}
 
const AdBlockRule* AdBlockSubscription::replaceRule(AdBlockRule* rule, int offset)
{
    Q_UNUSED(rule)
    Q_UNUSED(offset)
    return nullptr;
}
 
AdBlockSubscription::~AdBlockSubscription()
{
    qDeleteAll(m_rules);
}
 
// AdBlockCustomList
 
AdBlockCustomList::AdBlockCustomList(QObject* parent)
    : AdBlockSubscription(tr("Custom Rules"), parent)
{
    setFilePath(DataPaths::currentProfilePath() + QLatin1String("/adblock/customlist.txt"));
}
 
void AdBlockCustomList::loadSubscription(const QStringList &disabledRules)
{
    // DuckDuckGo ad whitelist rules
    // They cannot be removed, but can be disabled.
    // Please consider not disabling them. Thanks!
 
    const QString ddg1 = QSL("@@||duckduckgo.com^$document");
    const QString ddg2 = QSL("duckduckgo.com#@#.has-ad");
 
    const QString rules = QzTools::readAllFileContents(filePath());
 
    QFile file(filePath());
    if (!file.exists()) {
        saveSubscription();
    }
 
    if (file.open(QFile::WriteOnly | QFile::Append)) {
        QTextStream stream(&file);
        stream.setEncoding(QStringConverter::Utf8);
 
        if (!rules.contains(ddg1 + QL1S("\n")))
            stream << ddg1 << Qt::endl;
 
        if (!rules.contains(QL1S("\n") + ddg2))
            stream << ddg2 << Qt::endl;
    }
    file.close();
 
    AdBlockSubscription::loadSubscription(disabledRules);
}
 
void AdBlockCustomList::saveSubscription()
{
    QFile file(filePath());
 
    if (!file.open(QFile::ReadWrite | QFile::Truncate)) {
        qWarning() << "AdBlockSubscription::" << __FUNCTION__ << "Unable to open adblock file for writing:" << filePath();
        return;
    }
 
    QTextStream textStream(&file);
    textStream.setEncoding(QStringConverter::Utf8);
    textStream << "Title: " << title() << Qt::endl;
    textStream << "Url: " << url().toString() << Qt::endl;
    textStream << "[Adblock Plus 1.1.1]" << Qt::endl;
 
    for (const AdBlockRule* rule : std::as_const(m_rules)) {
        textStream << rule->filter() << Qt::endl;
    }
 
    file.close();
}
 
bool AdBlockCustomList::canEditRules() const
{
    return true;
}
 
bool AdBlockCustomList::canBeRemoved() const
{
    return false;
}
 
bool AdBlockCustomList::containsFilter(const QString &filter) const
{
    for (const AdBlockRule* rule : std::as_const(m_rules)) {
        if (rule->filter() == filter) {
            return true;
        }
    }
 
    return false;
}
 
bool AdBlockCustomList::removeFilter(const QString &filter)
{
    for (int i = 0; i < m_rules.count(); ++i) {
        const AdBlockRule* rule = m_rules.at(i);
 
        if (rule->filter() == filter) {
            return removeRule(i);
        }
    }
 
    return false;
}
 
int AdBlockCustomList::addRule(AdBlockRule* rule)
{
    m_rules.append(rule);
 
    Q_EMIT subscriptionChanged();
 
    if (rule->isCssRule())
        mApp->reloadUserStyleSheet();
 
    return m_rules.count() - 1;
}
 
bool AdBlockCustomList::removeRule(int offset)
{
    if (!QzTools::containsIndex(m_rules, offset)) {
        return false;
    }
 
    AdBlockRule* rule = m_rules.at(offset);
    const QString filter = rule->filter();
 
    m_rules.remove(offset);
 
    Q_EMIT subscriptionChanged();
 
    if (rule->isCssRule())
        mApp->reloadUserStyleSheet();
 
    AdBlockManager::instance()->removeDisabledRule(filter);
 
    delete rule;
    return true;
}
 
const AdBlockRule* AdBlockCustomList::replaceRule(AdBlockRule* rule, int offset)
{
    if (!QzTools::containsIndex(m_rules, offset)) {
        return nullptr;
    }
 
    AdBlockRule* oldRule = m_rules.at(offset);
    m_rules[offset] = rule;
 
    Q_EMIT subscriptionChanged();
 
    if (rule->isCssRule() || oldRule->isCssRule())
        mApp->reloadUserStyleSheet();
 
    delete oldRule;
    return m_rules[offset];
}