Issue 5146 - Implement DownloadableSubscription parsing in C++

compiled/subscription/DownloadableSubscription.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus 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 Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #include <cwctype>
+#include <limits>
 
 #include "DownloadableSubscription.h"
 #include "../FilterNotifier.h"
 #include "../StringScanner.h"
 #include "../filter/CommentFilter.h"
 
+ABP_NS_USING
+
 namespace {
   constexpr int MILLIS_IN_HOUR = 60 * 60 * 1000;
   constexpr int MILLIS_IN_DAY = 24 * MILLIS_IN_HOUR;
-}
-
-_DownloadableSubscription_Parser::_DownloadableSubscription_Parser(DownloadableSubscription& sub)
-    : mSubscription(&sub)
-{
-}
-
-void _DownloadableSubscription_Parser::Process(DependentString& line)
-{
-  auto filter = FilterPtr(Filter::FromText(line), false);
-  if (filter->mType == Filter::Type::COMMENT)
-  {
-    auto comment = filter->As<CommentFilter>();
-    if (!comment->GetParam().empty())
+  // limits
+  constexpr int64_t MAX_HOUR = std::numeric_limits<int64_t>::max() / MILLIS_IN_HOUR;
+  constexpr int64_t MAX_DAY = std::numeric_limits<int64_t>::max() / MILLIS_IN_DAY;
+
+  typedef std::pair<DependentString, DependentString> Param;
+
+  Param ParseParam(const String& text)
+  {
+    Param param;
+
+    if (text[0] == u'!')
     {
-      if (comment->GetParam() == u"checksum"_str)
+      bool foundColon = false;
+      String::size_type beginParam = 0;
+      String::size_type endParam = 0;
+      String::size_type beginValue = 0;
+      for (String::size_type i = 1; i < text.length(); i++)
       {
-        // XXX we'll have to calculate the checksum.

[hub, 2017/11/13 22:35:27]

this part will require import a md5sum calculation function from somewhere.

But TODO before for the final patch.

+        switch (text[i])
+        {
+        case ' ':
+        case '\t':
+          if (beginParam > 0 && !foundColon)
+          {
+            endParam = i;
+          }
+          break;
+        case ':':
+          foundColon = true;
+          endParam = i;
+          break;
+        default:
+          if (foundColon)
+          {
+            beginValue = i;
+          }
+          else
+          {
+            if (beginParam == 0)
+              beginParam = i;
+          }
+          break;
+        }
+        if (beginValue > 0)
+          break;
       }
-      mParams[comment->GetParam()] = comment->GetValue();
+      if (beginValue > 0)
+      {
+        param.first = DependentString(text, beginParam, endParam - beginParam);
+        param.first.toLower();
+        param.second = DependentString(
+          text, beginValue, text.length() - beginValue);
+      }
     }
-  }
-
-  if (filter)
-    mFilters.push_back(filter);
-}
-
-int _DownloadableSubscription_Parser::ParseExpires(const String& expires)
+    return param;
+  }
+}
+
+DownloadableSubscription_Parser::DownloadableSubscription_Parser()
+  : mFirstLine(true)
+{
+  annotate_address(this, "DownloadableSubscription_Parser");
+}
+
+namespace {
+  const DependentString ADBLOCK_HEADER(u"[Adblock"_str);
+}
+
+void DownloadableSubscription_Parser::Process(const String& line)
+{
+  bool isHeader = false;
+  isHeader = line.find(ADBLOCK_HEADER) != String::npos;
+  if (!isHeader)
+  {
+    auto param = ParseParam(line);
+    if (param.first.is_invalid())
+      mFiltersText.emplace_back(line);
+    else
+      mParams[param.first] = param.second;
+  }
+}
+
+int64_t DownloadableSubscription_Parser::ParseExpires(const String& expires)
 {
   bool isHour = false;
   StringScanner scanner(expires);
   String::size_type numStart = 0;
   String::size_type numLen = 0;
   while(!scanner.done())
   {
     auto ch = scanner.next();
     if (std::iswdigit(ch))
     {
       if (numLen == 0)
         numStart = scanner.position();
       numLen++;
     }
     else if (std::iswspace(ch))
     {
       if (numLen)
         break;
     }
     else
     {
       if (numLen)
         scanner.back();
       break;
     }
   }
 
   DependentString numStr(expires, numStart, numLen);
-  int num = numStr.toInt();
+  int64_t num = lexical_cast<int64_t>(numStr);
   if (num == 0)
     return 0;
 
   while (!scanner.done())
   {
     auto ch = scanner.next();
     if (std::iswspace(ch))
       continue;
+
     if (ch == u'h')
-    {
       isHour = true;
-      // assume we are done here. The rest is ignored.
-      break;
-    }
+
+    // assume we are done here. The rest is ignored.
+    break;
   }
   // check for overflow.
-  if (!isHour && num > 24)

[hub, 2017/11/13 22:35:27]

I should check the overflow for the expiration in hours as well. And make this
"24" a const. (basically 2^31 / (24 * 3600 * 1000) rounded down).

There is note about not using 64-bits integer.

+  if ((isHour && (num > MAX_HOUR)) || (num > MAX_DAY))
     return 0;
 
   num *= isHour ? MILLIS_IN_HOUR : MILLIS_IN_DAY;
   return num;
 }
 
-int _DownloadableSubscription_Parser::Finalize()
+int64_t DownloadableSubscription_Parser::Finalize(DownloadableSubscription& subscription)
 {
   auto entry = mParams.find(u"title"_str);
   if (entry)
   {
-    mSubscription->SetTitle(entry->second);
-    mSubscription->SetFixedTitle(true);
+    subscription.SetTitle(entry->second);
+    subscription.SetFixedTitle(true);
   }
   else
-    mSubscription->SetFixedTitle(false);
-
-  int version = 0;
+    subscription.SetFixedTitle(false);
+
+  int32_t version = 0;
   entry = mParams.find(u"version"_str);
   if (entry)
-    version = entry->second.toInt();
-  mSubscription->SetDataRevision(version);
-
-  int expires = 0;
+    version = lexical_cast<int32_t>(entry->second);
+  subscription.SetDataRevision(version);
+
+  int64_t expires = 0;
   entry = mParams.find(u"expires"_str);
   if (entry)
     expires = ParseExpires(entry->second);
 
   FilterNotifier::SubscriptionChange(
     FilterNotifier::Topic::SUBSCRIPTION_BEFORE_FILTERS_REPLACED,
-    *mSubscription);

[hub, 2017/11/13 22:35:28]

I'm not if that's the right place to send this notification.

-  auto oldFilters = std::move(mSubscription->GetFilters());
-  mSubscription->GetFilters() = std::move(mFilters);
+    subscription);
+
+  Subscription::Filters filters;
+  filters.reserve(mFiltersText.size());
+  for (auto text : mFiltersText)
+  {
+    DependentString dependent(text);
+    filters.emplace_back(Filter::FromText(dependent), false);
+  }
+
+  subscription.SetFilters(std::move(filters));
   FilterNotifier::SubscriptionChange(
-    FilterNotifier::Topic::SUBSCRIPTION_FILTERS_REPLACED, *mSubscription);
+    FilterNotifier::Topic::SUBSCRIPTION_FILTERS_REPLACED, subscription);
 
   return expires;
 }
 
 namespace {
   DependentString emptyString = u""_str;
 }
 
-const String& _DownloadableSubscription_Parser::GetRedirect() const
+const String& DownloadableSubscription_Parser::GetRedirect() const
 {
   auto entry = mParams.find(u"redirect"_str);
   if (entry)
     return entry->second;
   return emptyString;
 }
 
-const String& _DownloadableSubscription_Parser::GetHomepage() const
+const String& DownloadableSubscription_Parser::GetHomepage() const
 {
   auto entry = mParams.find(u"homepage"_str);
   if (entry)
     return entry->second;
   return emptyString;
 }
+
+ABP_NS_USING
 
 DownloadableSubscription::DownloadableSubscription(const String& id)
     : Subscription(classType, id), mFixedTitle(false), mLastCheck(0),
       mHardExpiration(0), mSoftExpiration(0), mLastDownload(0), mLastSuccess(0),
       mErrorCount(0), mDataRevision(0), mDownloadCount(0)
 {
   SetTitle(id);
 }
 
-_DownloadableSubscription_Parser* DownloadableSubscription::ParseDownload()
-{
-  return new _DownloadableSubscription_Parser(*this);
+DownloadableSubscription_Parser* DownloadableSubscription::ParseDownload()
+{
+  return new DownloadableSubscription_Parser();
 }
 
 OwnedString DownloadableSubscription::Serialize() const
 {
   OwnedString result(Subscription::Serialize());
   if (mFixedTitle)
-    result.append(u"fixedTitle=true\n"_str);
+    result.append(ABP_TEXT("fixedTitle=true\n"_str));
   if (!mHomepage.empty())
   {
-    result.append(u"homepage="_str);
+    result.append(ABP_TEXT("homepage="_str));
     result.append(mHomepage);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mLastCheck)
   {
-    result.append(u"lastCheck="_str);
+    result.append(ABP_TEXT("lastCheck="_str));
     result.append(mLastCheck);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mHardExpiration)
   {
-    result.append(u"expires="_str);
+    result.append(ABP_TEXT("expires="_str));
     result.append(mHardExpiration);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mSoftExpiration)
   {
-    result.append(u"softExpiration="_str);
+    result.append(ABP_TEXT("softExpiration="_str));
     result.append(mSoftExpiration);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mLastDownload)
   {
-    result.append(u"lastDownload="_str);
+    result.append(ABP_TEXT("lastDownload="_str));
     result.append(mLastDownload);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (!mDownloadStatus.empty())
   {
-    result.append(u"downloadStatus="_str);
+    result.append(ABP_TEXT("downloadStatus="_str));
     result.append(mDownloadStatus);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mLastSuccess)
   {
-    result.append(u"lastSuccess="_str);
+    result.append(ABP_TEXT("lastSuccess="_str));
     result.append(mLastSuccess);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mErrorCount)
   {
-    result.append(u"errors="_str);
+    result.append(ABP_TEXT("errors="_str));
     result.append(mErrorCount);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mDataRevision)
   {
-    result.append(u"version="_str);
+    result.append(ABP_TEXT("version="_str));
     result.append(mDataRevision);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (!mRequiredVersion.empty())
   {
-    result.append(u"requiredVersion="_str);
+    result.append(ABP_TEXT("requiredVersion="_str));
     result.append(mRequiredVersion);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   if (mDownloadCount)
   {
-    result.append(u"downloadCount="_str);
+    result.append(ABP_TEXT("downloadCount="_str));
     result.append(mDownloadCount);
-    result.append(u'\n');
+    result.append(ABP_TEXT('\n'));
   }
   return result;
 }