Issue 5146 - Part 2: Process http response 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 "../Base64.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;
   // 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;
 
@@ skipping 52 matching lines @@
 DownloadableSubscription_Parser::DownloadableSubscription_Parser()
 {
   annotate_address(this, "DownloadableSubscription_Parser");
 }
 
 namespace {
   const DependentString ADBLOCK_HEADER(u"[Adblock"_str);
   const DependentString ADBLOCK_PLUS_EXTRA_HEADER(u"Plus"_str);
 
   const DependentString ERROR_INVALID_DATA(u"synchronize_invalid_data"_str);
-
-  // Only check for trailing base64 padding. There should be at most 2 '='.
-  // In that case return a truncated string.
-  DependentString CleanUpChecksum(const String& checksum)
-  {
-    const auto len = checksum.length();
-    if ((len > 22 && len <= 24) &&
-        (checksum[22] == u'=' && (len == 23 || checksum[23] == u'=')))
-      return DependentString(checksum, 0, 22);
-    return DependentString(checksum);
-  }
 }
 
 /// Return true if more line expected.
 bool DownloadableSubscription_Parser::GetNextLine(DependentString& buffer, DependentString& line)
 {
   StringScanner scanner(buffer);
   String::value_type ch = 0;
   while (ch != u'\r' && ch != u'\n')
   {
     ch = scanner.next();
@@ skipping 54 matching lines @@
     ;
   if (ch)
     scanner.back();
   if (scanner.position() + 1 > index)
     minVersion.reset(current, index, scanner.position() + 1 - index);
 
   if (ch != u']')
     return false;
 
   mRequiredVersion = minVersion;
-  mChecksum.Update(line);
   return true;
 }
 
 void DownloadableSubscription_Parser::ProcessLine(const String& line)
 {
   auto param = ParseParam(line);
   if (param.first.is_invalid())
   {
     if (!line.empty())
       mFiltersText.emplace_back(line);
   }
-  else if (param.first == u"checksum"_str)
-  {
-    mParams[param.first] = CleanUpChecksum(param.second);
-    return;
-  }
   else
     mParams[param.first] = param.second;
-
-  // Checksum is an MD5 checksum (base64-encoded without the trailing "=") of
-  // all lines in UTF-8 without the checksum line, joined with "\n".
-  mChecksum.Update((const uint8_t*)"\n", 1);
-  mChecksum.Update(line);
 }
 
 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())
   {
@@ skipping 11 matching lines @@
     }
     else
     {
       if (numLen)
         scanner.back();
       break;
     }
   }
 
   DependentString numStr(expires, numStart, numLen);
-  int64_t num = numStr.toInt<int64_t>();
+  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;
   }
   // check for overflow.
   if ((isHour && (num > MAX_HOUR)) || (num > MAX_DAY))
     return 0;
 
   num *= isHour ? MILLIS_IN_HOUR : MILLIS_IN_DAY;
   return num;
 }
 
-bool DownloadableSubscription_Parser::VerifyChecksum()
-{
-  if (!mParams.find(u"checksum"_str))
-    return true;
-
-  if (mB64Checksum.is_invalid())
-  {
-    uint8_t checksum[MD5::CHECKSUM_LENGTH];
-    mChecksum.Final(checksum);
-    mB64Checksum = ToBase64(checksum, MD5::CHECKSUM_LENGTH);
-  }
-  return (mParams[u"checksum"_str] == mB64Checksum);
-}
-
 int64_t DownloadableSubscription_Parser::Finalize(DownloadableSubscription& subscription)
 {
-  if (mB64Checksum.is_invalid())
-    VerifyChecksum(); // here we ignore the checksum, but we calculate it.
-
   FilterNotifier::SubscriptionChange(
     FilterNotifier::Topic::SUBSCRIPTION_BEFORE_FILTERS_REPLACED,
     subscription);
 
   if (!mRequiredVersion.empty())
     subscription.SetRequiredVersion(mRequiredVersion);
 
   auto entry = mParams.find(u"title"_str);
   if (entry)
   {
     subscription.SetTitle(entry->second);
     subscription.SetFixedTitle(true);
   }
   else
     subscription.SetFixedTitle(false);
 
   int32_t version = 0;
   entry = mParams.find(u"version"_str);
   if (entry)
-    version = entry->second.toInt<int32_t>();
+    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);
 
   Subscription::Filters filters;
   filters.reserve(mFiltersText.size());
   for (auto text : mFiltersText)
@@ skipping 21 matching lines @@
   return emptyString;
 }
 
 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();
 }
 
 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;
 }