1 files changed, 98 insertions, 47 deletions

diff --git a/lib/web/urlfilter/filterrule.cpp b/lib/web/urlfilter/filterrule.cpp
index 5a9310e..73b357b 100644
--- a/lib/web/urlfilter/filterrule.cpp
+++ b/lib/web/urlfilter/filterrule.cpp
@@ -2,57 +2,99 @@
 #include <QWebEngineUrlRequestInfo>
 #include <QJsonArray>
 
+void parseJson(std::unique_ptr<FilterRule> &rule, const QJsonObject &filter)
+{
+    // set action
+    {
+        if(!filter.value("whitelist").isUndefined()) {
+            rule->setActionType(FilterRule::Whitelist);
+
+        } else if(!filter.value("blacklist").isUndefined()) {
+            rule->setActionType(FilterRule::Blacklist);
+
+        } else if(!filter.value("redirect").isUndefined()) {
+            rule->setActionType(FilterRule::Redirect);
+            rule->setRedirectUrl(QUrl::fromUserInput(filter.value("redirect").toString()));
+
+        } else if(!filter.value("setheader").isUndefined()) {
+            rule->setActionType(FilterRule::SetHeader);
+            for(const QJsonValue v : filter.value("setheader").toArray()) {
+                QStringList h = v.toString().split(':');
+                rule->addHeaderRule(h.at(0).toLatin1(), h.at(1).toLatin1());
+            }
+        }
+
+    }
+
+    // set match type
+    {
+        const QJsonValue regexpValue = filter.value("regexp");
+        const QJsonValue endswithValue = filter.value("endswith");
+        const QJsonValue containsValue = filter.value("contains");
+
+        if(!regexpValue.isUndefined()) {
+            rule->setMatchType(FilterRule::RegExpMatchRule, regexpValue.toString());
+
+        } else if(!endswithValue.isUndefined()) {
+            rule->setMatchType(FilterRule::StringEndsMatchRule, endswithValue.toString());
+
+        } else if(!containsValue.isUndefined()) {
+            rule->setMatchType(FilterRule::StringContainsMatchRule, containsValue.toString());
+
+        } else
+            rule->setMatchType(FilterRule::MatchAllUrlsRule);
+    }
+
+}
+
 FilterRule::FilterRule(const QJsonObject &filter)
 {
-    const QString action = filter.value("action").toString();
-
-    // there is no action specified => this rule is invalid
-    if(action.isEmpty())
-        return;
-
-    if(action == "Whitelist")
-        m_action = ActionType::Whitelist;
-    else if (action == "Blacklist")
-        m_action = ActionType::Blacklist;
-    else if (action == "Redirect") {
-        m_action = ActionType::Redirect;
-        m_redirectUrl = QUrl::fromUserInput(filter.value("url").toString());
-    } else if (action == "SetHeader")
-        m_action = ActionType::SetHeader;
-    else        // invalid action
-        return;
-
-    QJsonValue regexp = filter.value("regexp");
-    QJsonValue endswith = filter.value("endswith");
-    QJsonValue contains = filter.value("contains");
-
-    if(!regexp.isUndefined()) {
-        m_type = RuleType::RegExpMatchRule;
-        this->regexp.setPattern(regexp.toString());
-    } else if(!endswith.isUndefined()) {
-        m_type = RuleType::StringEndsMatchRule;
-        pattern = endswith.toString();
-    } else if(!contains.isUndefined()) {
-        m_type = RuleType::StringContainsMatchRule;
-        this->matcher.setPattern(contains.toString());
-        this->matcher.setCaseSensitivity(Qt::CaseInsensitive);
-    } else      // invalid rule
-        return;
-
-    m_options.insert(QWebEngineUrlRequestInfo::ResourceTypeImage, true);
+    m_matcher.setCaseSensitivity(Qt::CaseInsensitive);
+}
+
+void FilterRule::setActionType(ActionType type)
+{
+    m_actionType = type;
+}
+
+void FilterRule::setMatchType(MatchType type, const QString &pattern)
+{
+    m_matchType = type;
+    switch (type) {
+    case RegExpMatchRule:
+        m_regexp.setPattern(pattern);
+        break;
+    case StringEndsMatchRule:
+        m_pattern = pattern;
+        break;
+    case StringContainsMatchRule:
+        m_matcher.setPattern(pattern);
+    default:
+        break;
+    }
+}
+
+void FilterRule::setRedirectUrl(const QUrl &url)
+{
+    m_redirectUrl = url;
+}
+
+void FilterRule::addHeaderRule(const QByteArray &header, const QByteArray &value)
+{
+    m_headers.insert(header, value);
 }
 
 bool FilterRule::isValid() const
 {
-    return m_type != RuleType::Invalid;
+    return (m_matchType != MatchType::InvalidMatch) && (m_actionType != ActionType::InvalidAction);
 }
 
 bool FilterRule::process(QWebEngineUrlRequestInfo &info) const
 {
-    Q_ASSERT(m_type != RuleType::Invalid);
+    Q_ASSERT(m_actionType != ActionType::InvalidAction);
 
     if(matchRequestUrl(info.requestUrl().toString(), info.resourceType())) {
-        switch (m_action) {
+        switch (m_actionType) {
         case ActionType::Whitelist:
             info.block(false);
             return true;
@@ -63,6 +105,11 @@ bool FilterRule::process(QWebEngineUrlRequestInfo &info) const
             info.redirect(m_redirectUrl);
             return true;
         case ActionType::SetHeader:
+            for(auto it = m_headers.constBegin(); it != m_headers.constEnd(); ++it) {
+                info.setHttpHeader(it.key(), it.value());
+            }
+            return true;
+        case ActionType::InvalidAction:
             break;
         }
     }
@@ -72,16 +119,20 @@ bool FilterRule::process(QWebEngineUrlRequestInfo &info) const
 
 bool FilterRule::matchRequestUrl(const QString &requestUrl, const QWebEngineUrlRequestInfo::ResourceType type) const
 {
-    if(!m_options.contains(type))
+    Q_ASSERT(m_matchType != MatchType::InvalidMatch);
+
+    if(!m_resourceTypeOptions.isEmpty() && !m_resourceTypeOptions.contains(type))
         return false;
 
-    switch (m_type) {
-    case RuleType::RegExpMatchRule:
-        return regexp.match(requestUrl).hasMatch();
-    case RuleType::StringEndsMatchRule:
-        return requestUrl.endsWith(pattern);
-    case RuleType::StringContainsMatchRule:
-        return matcher.indexIn(requestUrl) != -1;
+    switch (m_matchType) {
+    case MatchType::RegExpMatchRule:
+        return m_regexp.match(requestUrl).hasMatch();
+    case MatchType::StringEndsMatchRule:
+        return requestUrl.endsWith(m_pattern);
+    case MatchType::StringContainsMatchRule:
+        return m_matcher.indexIn(requestUrl) != -1;
+    case MatchType::MatchAllUrlsRule:
+        return true;
     default:
         return false;
     }