Issue 1793 - check whether the frame is whitelisted before injecting CSS

src/engine/Main.cpp

+/*
+ * This file is part of Adblock Plus <https://adblockplus.org/>,
+ * Copyright (C) 2006-2015 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/>.
+ */
+
+#pragma comment(linker,"\"/manifestdependency:type='win32' \
+  name='Microsoft.Windows.Common-Controls' version='6.0.0.0' \
+  processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
+
 #include <AdblockPlus.h>
 #include <functional>
 #include <vector>
+#include <deque>
 #include <thread>
+#include <mutex>
+#include <condition_variable>
 #include <Windows.h>
 
 #include "../shared/AutoHandle.h"
 #include "../shared/Communication.h"
 #include "../shared/Dictionary.h"
 #include "../shared/Utils.h"
 #include "../shared/Version.h"
 #include "../shared/CriticalSection.h"
-#include "../shared/IE_version.h"
+#include "IeVersion.h"
 #include "AdblockPlus.h"
 #include "Debug.h"
 #include "Updater.h"
+#include "Registry.h"
+#include "NotificationWindow.h"
 
 namespace
 {
+  struct ScopedAtlAxInitializer
+  {
+    ScopedAtlAxInitializer()
+    {
+      ATL::AtlAxWinInit();
+    }
+    ~ScopedAtlAxInitializer()
+    {
+      ATL::AtlAxWinTerm();
+    }
+  };
+
+  class ABPAtlModule : public ATL::CAtlExeModuleT<ABPAtlModule>
+  {
+    enum CustomMessages
+    {
+      TASK_POSTED = WM_USER + 1
+    };
+
+  public:
+    ABPAtlModule() : m_msgHWnd(nullptr)
+    {
+    }
+    void Finalize();
+    HRESULT PreMessageLoop(int showCmd) throw();
+    void RunMessageLoop() throw();
+    static HRESULT InitializeCom() throw()
+    {
+      // The default implementation initializes multithreaded version but
+      // in this case hosted ActiveX does not properly work.
+      return CoInitialize(nullptr);
+    }
+  private:
+    void onNewNotification(const AdblockPlus::NotificationPtr& notification);
+    void DispatchTask(std::function<void()>&& task);
+    void ProcessTasks();
+
+    ScopedAtlAxInitializer m_scopedAtlAxInit;
+    HWND m_msgHWnd;
+    std::recursive_mutex m_tasksMutex;
+    std::deque<std::function<void()>> m_tasks;
+    std::unique_ptr<NotificationBorderWindow> m_notificationWindow;
+  } _AtlModule;
+
   std::auto_ptr<AdblockPlus::FilterEngine> filterEngine;
   std::auto_ptr<Updater> updater;
   int activeConnections = 0;
   CriticalSection activeConnectionsLock;
   HWND callbackWindow;
 
-  bool IsWhitelisted(const std::string& urlArg,
-    const std::vector<std::string>& frameHierarchy, const std::string& type)
-  {
-    auto IsWhitelisted = [&type](const std::string& url, const std::string& parent)->bool
-    {
-      AdblockPlus::FilterPtr match = filterEngine->Matches(url, type, parent);
-      return match && match->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION;
-    };
-    bool isWhitelisted = false;

[Eric, 2015/01/13 19:52:52]

I dislike identifiers that differ only in capitalization.

In any case, it's not necessary to declare this variable here to use as a return
variable. It's actually not necessary at all, even later.

[sergei, 2015/04/13 08:06:41]

fixed

+  // it's a helper for the function below.
+  std::string GetWhitelistingFilter(const std::string& url, const std::string& parent, AdblockPlus::FilterEngine::ContentType type)
+  {
+    AdblockPlus::FilterPtr match = filterEngine->Matches(url, type, parent);
+    if (match && match->GetType() == AdblockPlus::Filter::TYPE_EXCEPTION)
+    {
+      return match->GetProperty("text")->AsString();
+    }
+    return "";
+  };
+
+  std::string GetWhitelistingFilter(const std::string& urlArg,
+    const std::vector<std::string>& frameHierarchy, AdblockPlus::FilterEngine::ContentType type)
+  {
     if (frameHierarchy.empty())
     {
-      isWhitelisted = IsWhitelisted(urlArg, "");

[Eric, 2015/01/13 19:52:52]

We can simply return here and skip the subsequent 'else'

[sergei, 2015/04/13 08:06:41]

fixed

-    }
-    else
-    {
-      auto frame_ii = frameHierarchy.begin();

[Eric, 2015/01/13 19:52:52]

As much as I prefer underscores, ABP doesn't use them in identifiers.

[sergei, 2015/04/13 08:06:41]

fixed

-      std::string parentUrl;
-      std::string url = urlArg;
-      while (!isWhitelisted && frame_ii != frameHierarchy.end())

[Eric, 2015/01/13 19:52:52]

We only need the second term here.

[sergei, 2015/04/13 08:06:41]

fixed

-      {
-        parentUrl = *frame_ii;
-        isWhitelisted = IsWhitelisted(url, parentUrl);

[Eric, 2015/01/13 19:52:52]

if (IsWhitelisted(...)) return true;

[sergei, 2015/04/13 08:06:41]

fixed

-        url = parentUrl;
-        ++frame_ii;
-      }

[Eric, 2015/01/13 19:52:52]

Just return false if the loop terminates having reached the end.

[sergei, 2015/04/13 08:06:41]

fixed

-    }
-    return isWhitelisted;
-  }
-
-  void WriteStrings(Communication::OutputBuffer& response,
-      const std::vector<std::string>& strings)
-  {
-    int32_t count = static_cast<int32_t>(strings.size());
-    response << count;
-    for (int32_t i = 0; i < count; i++)
-      response << strings[i];
+      return GetWhitelistingFilter(urlArg, "", type);
+    }
+    auto frameIterator = frameHierarchy.begin();
+    std::string url = urlArg;
+    do
+    {
+      std::string parentUrl = *frameIterator++;
+      auto filterText = GetWhitelistingFilter(url, parentUrl, type);
+      if (!filterText.empty())
+      {
+        return filterText;
+      }
+      url = parentUrl;
+    }
+    while (frameIterator != frameHierarchy.end());
+    return "";
   }
 
   void WriteSubscriptions(Communication::OutputBuffer& response,
       const std::vector<AdblockPlus::SubscriptionPtr>& subscriptions)
   {
     int32_t count = static_cast<int32_t>(subscriptions.size());
     response << count;
     for (int32_t i = 0; i < count; i++)
     {
       AdblockPlus::SubscriptionPtr subscription = subscriptions[i];
@@ skipping 39 matching lines @@
   {
     Communication::OutputBuffer response;
 
     Communication::ProcType procedure;
     request >> procedure;
     switch (procedure)
     {
       case Communication::PROC_MATCHES:
       {
         std::string url;
-        std::string type;
+        using namespace AdblockPlus;
         std::string documentUrl;
+        int32_t type;
         request >> url >> type >> documentUrl;
-        referrerMapping.Add(url, documentUrl); 
-        AdblockPlus::FilterPtr filter = filterEngine->Matches(url, type, referrerMapping.BuildReferrerChain(documentUrl));
-        response << (filter && filter->GetType() != AdblockPlus::Filter::TYPE_EXCEPTION);
+        referrerMapping.Add(url, documentUrl);
+        auto contentType = static_cast<FilterEngine::ContentType>(type);
+        FilterPtr filter = filterEngine->Matches(url, contentType, referrerMapping.BuildReferrerChain(documentUrl));
+        response << (filter && filter->GetType() != Filter::TYPE_EXCEPTION);
         break;
       }
       case Communication::PROC_GET_ELEMHIDE_SELECTORS:
       {
         std::string domain;
         request >> domain;
-        WriteStrings(response, filterEngine->GetElementHidingSelectors(domain));
+        response << filterEngine->GetElementHidingSelectors(domain);
         break;
       }
       case Communication::PROC_AVAILABLE_SUBSCRIPTIONS:
       {
         WriteSubscriptions(response, filterEngine->FetchAvailableSubscriptions());
         break;
       }
       case Communication::PROC_LISTED_SUBSCRIPTIONS:
       {
         WriteSubscriptions(response, filterEngine->GetListedSubscriptions());
@@ skipping 64 matching lines @@
             const size_t prefixLen = strlen(prefix);
             const size_t suffixLen = strlen(suffix);
             if (!text.compare(0, prefixLen, prefix) &&
                 !text.compare(text.size() - suffixLen, suffixLen, suffix))
             {
               domains.push_back(text.substr(prefixLen, text.size() - prefixLen - suffixLen));
             }
           }
         }
 
-        WriteStrings(response, domains);
-        break;
-      }
-      case Communication::PROC_IS_WHITELISTED_URL:
+        response << domains;
+        break;
+      }
+      case Communication::PROC_GET_WHITELISTING_FITER:
       {
         std::string url;
         request >> url;
         std::vector<std::string> frameHierarchy;
         request >> frameHierarchy;
-        response << IsWhitelisted(url, frameHierarchy, "DOCUMENT");;
+        response << GetWhitelistingFilter(url, frameHierarchy, AdblockPlus::FilterEngine::CONTENT_TYPE_DOCUMENT);
         break;
       }
       case Communication::PROC_IS_ELEMHIDE_WHITELISTED_ON_URL:
       {
         std::string url;
         request >> url;
         std::vector<std::string> frameHierarchy;
         request >> frameHierarchy;
-        response << IsWhitelisted(url, frameHierarchy, "ELEMHIDE");
+        response << !GetWhitelistingFilter(url, frameHierarchy, AdblockPlus::FilterEngine::CONTENT_TYPE_ELEMHIDE).empty();
         break;
       }
       case Communication::PROC_ADD_FILTER:
       {
         std::string text;
         request >> text;
 
         filterEngine->GetFilter(text)->AddToList();
         break;
       }
@@ skipping 171 matching lines @@
 
     Debug("Client disconnected " + threadString);
 
     {
       CriticalSection::Lock lock(activeConnectionsLock);
       activeConnections--;
       if (activeConnections < 1)
       {
         Debug("No connections left, shutting down the engine");
         activeConnections = 0;
+
+        // The following exit(0) calls the destructor of _AtlModule from the
+        // current thread which results in the disaster because there is a
+        // running message loop as well as there can be alive notification
+        // window which holds v8::Value as well as m_tasks can hold v8::Value
+        // but JS Engine is destroyed before _AtlModule. BTW, various free
+        // running threads like Timeout also cause the crash because the engine
+        // is already destroyed.
+        _AtlModule.Finalize();
         exit(0);
       }
     }
 
   }
 
   void OnUpdateAvailable(AdblockPlus::JsValueList& params)
   {
     if (params.size() < 1)
     {
       Debug("updateAvailable event missing URL");
       return;
     }
     updateAvailable = true;
 
     updater->Update(params[0]->AsString());
   }
-}
+
+  std::wstring PreconfigurationValueFromRegistry(const std::wstring& preconfigName)
+  {
+    try
+    {
+      AdblockPlus::RegistryKey regKey(HKEY_CURRENT_USER, L"Software\\AdblockPlus");
+      return regKey.value_wstring(preconfigName);
+    }
+    catch (const std::runtime_error&)
+    {
+      return L"";
+    }
+  }
 
 std::auto_ptr<AdblockPlus::FilterEngine> CreateFilterEngine(const std::wstring& locale)
 {
   AdblockPlus::AppInfo appInfo;
   appInfo.version = ToUtf8String(IEPLUGIN_VERSION);
   appInfo.name = "adblockplusie";
 #ifdef _WIN64
   appInfo.application = "msie64";
 #else
   appInfo.application = "msie32";
 #endif
   appInfo.applicationVersion = ToUtf8String(AdblockPlus::IE::InstalledVersionString());
   appInfo.locale = ToUtf8String(locale);
 #ifdef ADBLOCK_PLUS_TEST_MODE
   appInfo.developmentBuild = true;
 #else
   appInfo.developmentBuild = false;
 #endif
 
   AdblockPlus::JsEnginePtr jsEngine = AdblockPlus::JsEngine::New(appInfo);
   jsEngine->SetEventCallback("updateAvailable", &OnUpdateAvailable);
 
   std::string dataPath = ToUtf8String(GetAppDataPath());
   dynamic_cast<AdblockPlus::DefaultFileSystem*>(jsEngine->GetFileSystem().get())->SetBasePath(dataPath);
-  std::auto_ptr<AdblockPlus::FilterEngine> filterEngine(new AdblockPlus::FilterEngine(jsEngine));
+  std::map<std::string, AdblockPlus::JsValuePtr> preconfig;
+  preconfig["disable_auto_updates"] = jsEngine->NewValue(
+    PreconfigurationValueFromRegistry(L"disable_auto_updates") == L"true");
+  preconfig["suppress_first_run_page"] = jsEngine->NewValue(
+    PreconfigurationValueFromRegistry(L"suppress_first_run_page") == L"true");
+  std::auto_ptr<AdblockPlus::FilterEngine> filterEngine(new AdblockPlus::FilterEngine(jsEngine, preconfig));
   return filterEngine;
 }
 
-int WINAPI WinMain(HINSTANCE, HINSTANCE, LPSTR, int)
+void ABPAtlModule::Finalize()
+{
+  std::condition_variable cv;
+  std::mutex cvMutex;
+  std::unique_lock<std::mutex> lock(cvMutex);
+  DispatchTask([&cvMutex, &cv, this]
+  {
+    if (m_notificationWindow)
+    {
+      m_notificationWindow->SendMessage(WM_CLOSE);
+    }
+    SendMessage(m_msgHWnd, WM_QUIT, 0, 0);
+    {
+      std::lock_guard<std::recursive_mutex> lock(m_tasksMutex);
+      m_tasks.clear();
+    }
+    std::unique_lock<std::mutex> lock(cvMutex);
+    cv.notify_one();
+  });
+  cv.wait(lock);
+}
+
+HRESULT ABPAtlModule::PreMessageLoop(int showCmd) throw()
+{
+  const std::wstring className = L"ABPEngineMessageWindow";
+  WNDCLASS wc;
+  wc.style = 0;
+  wc.lpfnWndProc = DefWindowProcW;
+  wc.cbClsExtra = 0;
+  wc.cbWndExtra = 0;
+  wc.hInstance = ATL::_AtlBaseModule.GetModuleInstance();
+  wc.hIcon = nullptr;
+  wc.hCursor = nullptr;
+  wc.hbrBackground = nullptr;
+  wc.lpszMenuName = nullptr;
+  wc.lpszClassName = className.c_str();
+  ATOM atom = RegisterClass(&wc);
+  if (!atom)
+  {
+    DebugLastError("Cannot register class for message only window");
+    return E_FAIL;
+  }
+  m_msgHWnd = CreateWindowW(className.c_str(),
+    nullptr,      // window name
+    0,            // style
+    0, 0, 0, 0,   // geometry (x, y, w, h)
+    HWND_MESSAGE, // parent
+    nullptr,      // menu handle
+    wc.hInstance,
+    0);           // windows creation data.
+  if (!m_msgHWnd)
+  {
+    DebugLastError("Cannot create message only window");
+    return E_FAIL;
+  }
+
+  filterEngine->SetShowNotificationCallback([this](const AdblockPlus::NotificationPtr& notification)
+  {
+    if (!notification)
+    {
+      return;
+    }
+    DispatchTask([notification, this]
+    {
+      onNewNotification(notification);
+    });
+  });
+
+  HRESULT retValue = __super::PreMessageLoop(showCmd);
+  // __super::PreMessageLoop returns S_FALSE because there is nothing to
+  // register but S_OK is required to run message loop.
+  return FAILED(retValue) ? retValue : S_OK;
+}
+
+void ABPAtlModule::RunMessageLoop() throw()
+{
+  MSG msg = {};
+  while (GetMessage(&msg, /*hwnd*/nullptr, /*msgFilterMin*/0, /*msgFilterMax*/0))
+  {
+    if (msg.hwnd == m_msgHWnd && msg.message == CustomMessages::TASK_POSTED)
+    {
+      ProcessTasks();
+    }
+    TranslateMessage(&msg);
+    DispatchMessage(&msg);
+  }
+}
+
+void ABPAtlModule::onNewNotification(const AdblockPlus::NotificationPtr& notification)
+{
+  m_notificationWindow.reset(new NotificationBorderWindow(*notification, GetExeDir() + L"html\\templates\\"));
+  m_notificationWindow->SetOnDestroyed([notification, this]
+  {
+    notification->MarkAsShown();
+    m_notificationWindow.reset();
+  });
+  m_notificationWindow->SetOnLinkClicked([](const std::wstring& url)
+  {
+    ATL::CComPtr<IWebBrowser2> webBrowser;
+    if (SUCCEEDED(webBrowser.CoCreateInstance(__uuidof(InternetExplorer))) && webBrowser)
+    {
+      ATL::CComVariant emptyVariant;
+      webBrowser->Navigate(ATL::CComBSTR(url.c_str()), &emptyVariant, &emptyVariant, &emptyVariant, &emptyVariant);
+      webBrowser->put_Visible(VARIANT_TRUE);
+    }
+  });
+  m_notificationWindow->Create(/*parent window*/nullptr);
+  if (m_notificationWindow->operator HWND() != nullptr)
+  {
+    m_notificationWindow->ShowWindow(SW_SHOWNOACTIVATE);
+    m_notificationWindow->UpdateWindow();
+  }
+}
+
+void ABPAtlModule::DispatchTask(std::function<void()>&& task)
+{
+  {
+    std::lock_guard<std::recursive_mutex> lock(m_tasksMutex);
+    m_tasks.emplace_back(std::move(task));
+  }
+  PostMessageW(m_msgHWnd, CustomMessages::TASK_POSTED, 0, 0);
+}
+
+void ABPAtlModule::ProcessTasks()
+{
+  std::lock_guard<std::recursive_mutex> lock(m_tasksMutex);
+  while(!m_tasks.empty())
+  {
+    auto task = *m_tasks.begin();
+    m_tasks.pop_front();
+    if (task)
+      task();
+  }
+}
+
+} // namespace {
+
+int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int cmdShow)
 {
   AutoHandle mutex(CreateMutexW(0, false, L"AdblockPlusEngine"));
   if (!mutex)
   {
     DebugLastError("CreateMutex failed");
     return 1;
   }
 
   if (GetLastError() == ERROR_ALREADY_EXISTS)
   {
     DebugLastError("Named pipe exists, another engine instance appears to be running");
     return 1;
   }
 
   int argc;
   LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
   std::wstring locale(argc >= 2 ? argv[1] : L"");
   LocalFree(argv);
   Dictionary::Create(locale);
   filterEngine = CreateFilterEngine(locale);
   updater.reset(new Updater(filterEngine->GetJsEngine()));
 
-  for (;;)
-  {
-    try
-    {
-      auto pipe = std::make_shared<Communication::Pipe>(Communication::pipeName, Communication::Pipe::MODE_CREATE);
-
-      // TODO: we should wait for the finishing of the thread before exiting from this function.
-      // It works now in most cases because the browser waits for the response in the pipe, and the
-      // thread has time to finish while this response is being processed and the browser is
-      // disposing all its stuff.
-      std::thread([pipe]()
-      {
-        ClientThread(pipe.get());
-      }).detach();
-    }
-    catch(const std::system_error& ex)
-    {
-      DebugException(ex);
-      return 1;
-    }
-    catch (const std::runtime_error& e)
-    {
-      DebugException(e);
-      return 1;
-    }
-  }
-
-  return 0;
+  std::thread communicationThread([]
+  {
+    for (;;)
+    {
+      try
+      {
+        auto pipe = std::make_shared<Communication::Pipe>(Communication::pipeName, Communication::Pipe::MODE_CREATE);
+    
+        // TODO: we should wait for the finishing of the thread before exiting from this function.
+        // It works now in most cases because the browser waits for the response in the pipe, and the
+        // thread has time to finish while this response is being processed and the browser is
+        // disposing all its stuff.
+        std::thread([pipe]()
+        {
+          ClientThread(pipe.get());
+        }).detach();
+      }
+      catch(const std::system_error& ex)
+      {
+        DebugException(ex);
+        return 1;
+      }
+      catch (const std::runtime_error& e)
+      {
+        DebugException(e);
+        return 1;
+      }
+    }
+  });
+
+  int retValue = _AtlModule.WinMain(cmdShow);
+  if (communicationThread.joinable())
+  {
+    communicationThread.join();
+  }
+
+  return retValue;
 }