Removal of all user tracking and shareware parts

Shared/PluginClassThread.cpp

 #include "PluginStdAfx.h"
 
 #include <ctime>
 
 #include "PluginClass.h"
 #include "PluginDictionary.h"
 #include "PluginSettings.h"
 #include "PluginSystem.h"
 #include "PluginConfiguration.h"
 #ifdef SUPPORT_FILTER
@@ skipping 32 matching lines @@
     CString debugText;
 
     CString threadInfo;
     threadInfo.Format(L"%d.%d", ::GetCurrentProcessId(), ::GetCurrentThreadId());
     
     debugText += L"================================================================================";
     debugText += L"\nMAIN THREAD " + threadInfo + L" Plugin version:" + CString(IEPLUGIN_VERSION);
     debugText += L"\n================================================================================";
 
     debugText += L"\nPlugin version:    " + CString(IEPLUGIN_VERSION);
-    debugText += L"\nPlugin id:         " + system->GetPluginId();
-    debugText += L"\nMAC address:       " + system->GetMacId(true);
-    debugText += L"\nComputer name:     " + system->GetComputerName();
-    debugText += L"\nUser id:           " + settings->GetString(SETTING_USER_ID, "N/A");
-    debugText += L"\nUser name:         " + system->GetUserName();
     debugText += L"\nBrowser version:   " + system->GetBrowserVersion();
     debugText += L"\nBrowser language:  " + system->GetBrowserLanguage();
 
     DWORD osVersion = ::GetVersion();
 
     CString ver;
     ver.Format(L"%d.%d", LOBYTE(LOWORD(osVersion)), HIBYTE(LOWORD(osVersion)));
 
     debugText += L"\nWindows version:   " + ver;
     
@@ skipping 74 matching lines @@
                     settings->Remove(SETTING_PLUGIN_INFO_PANEL);
                 settings->Write();
             }
         }
     }
 
         // --------------------------------------------------------------------
     // Should update plugin ?
     // --------------------------------------------------------------------
 
-#ifndef ENTERPRISE
     if (!IsMainThreadDone(hMainThread) && settings->IsPluginUpdateAvailable())
     {
         DEBUG_THREAD(L"Thread::Should update plugin");
 
             CString lastUpdateStr = settings->GetString(SETTING_PLUGIN_UPDATE_TIME);
 
             std::time_t today = std::time(NULL);
             std::time_t lastUpdate = lastUpdateStr.IsEmpty() ? today : _wtoi(lastUpdateStr.GetBuffer());
 
             if (today != (std::time_t)(-1) && lastUpdate != (std::time_t)(-1))
@@ skipping 13 matching lines @@
                             {
                                     s_isPluginToBeUpdated = true;
                             }
 
                             settings->SetValue(SETTING_PLUGIN_UPDATE_TIME, (int)today);
                             settings->Write();
                     }
             }
     }
 
-#endif
         // --------------------------------------------------------------------
         // Main loop
         // --------------------------------------------------------------------
 
         DWORD mainLoopIteration = 1;
-        
-        bool hasUser = false;
-        int regAttempts = 1;
-        int regAttemptsThread = 1;
-                                
+                                        
         while (!IsMainThreadDone(hMainThread))
         {
             CString sMainLoopIteration;
             sMainLoopIteration.Format(L"%u", mainLoopIteration);
 
         CString debugText;
         
         debugText += L"--------------------------------------------------------------------------------";
         debugText += L"\nLoop iteration " + sMainLoopIteration;
         debugText += L"\n--------------------------------------------------------------------------------";
 
         DEBUG_GENERAL(debugText)
         
-        if (settings->Has(SETTING_REG_SUCCEEDED))
-        {
-            regAttempts = REGISTRATION_MAX_ATTEMPTS;
-        }
-        else
-        {
-            regAttempts = settings->GetValue(SETTING_REG_ATTEMPTS);
-        }
-        regAttempts = max(regAttempts, regAttemptsThread) + 1;
-
-            // --------------------------------------------------------------------
-            // Register user
-            // --------------------------------------------------------------------
-
-        if (!IsMainThreadDone(hMainThread))
-        {
-            DEBUG_THREAD("Thread::Register user");
-
-            hasUser = settings->Has(SETTING_USER_ID);
-
-                if (!hasUser && regAttempts <= REGISTRATION_MAX_ATTEMPTS)
-                {
-                        DWORD nUserTimerBase = GetTickCount() / TIMER_INTERVAL_USER_REGISTRATION;
-
-                                if (nUserTimerBase >= nNextUserTimerBase || mainLoopIteration == 1 && !settings->IsFirstRun())
-                        {
-                    DEBUG_THREAD("Thread::Register user (action)");
-
-                                try 
-                                {
-                                    isConfigutationLoaded = configuration->Download();
-                                }
-                                catch (...)
-                                {
-                                }
-
-                                nNextUserTimerBase = nUserTimerBase + nUserTimerBaseStep;
-                                nUserTimerBaseStep *= 2;
-
-                                regAttemptsThread++;
-                        }
-                }
-        }
-
             // --------------------------------------------------------------------
             // Load configuration
             // --------------------------------------------------------------------
 
         if (!IsMainThreadDone(hMainThread))
         {
             DEBUG_THREAD("Thread::Load configuration");
 
-                if (hasUser && !isConfigutationLoaded && regAttempts <= REGISTRATION_MAX_ATTEMPTS)
+                if (!isConfigutationLoaded)
                 {
                         // Initialize serverClient module
                         // we try an initialization in each loop
                         DWORD nServerClientTimerBase = GetTickCount() / TIMER_INTERVAL_SERVER_CLIENT_INIT;
 
                         if (nServerClientTimerBase >= nNextServerClientTimerBase || mainLoopIteration == 1)
                         {
                     DEBUG_THREAD("Thread::Load configuration (action)");
 
                                 try 
                                 {
                                     isConfigutationLoaded = configuration->Download();
                                 }
                                 catch (...)
                                 {
                                 }
 
                                 nNextServerClientTimerBase = nServerClientTimerBase + nServerClientTimerBaseStep;
                                 nServerClientTimerBaseStep *= 2;
-
-                                regAttemptsThread++;
                         }
                 }
         }
 
             // --------------------------------------------------------------------
             // Update settings
             // --------------------------------------------------------------------
         
         if (!IsMainThreadDone(hMainThread))
         {
             DEBUG_THREAD("Thread::Update settings");
 
             if (configuration->IsValid())
             {
                 bool isNewDictionaryVersion = false;
 #ifdef SUPPORT_FILTER
                 bool isNewFilterVersion = false;
 #endif
 #ifdef SUPPORT_CONFIG
                 bool isNewConfig = false;
 #endif
 
                 DEBUG_THREAD("Thread::Update settings (action)");
                 
                 settings->ForceConfigurationUpdateOnStart(false);
 
-                if (configuration->IsValidPluginExpired())
-                {
-                    settings->SetBool(SETTING_PLUGIN_EXPIRED, configuration->IsPluginExpired());
-                }
-
-                            if (configuration->IsValidUserId())
-                {
-                                    settings->SetString(SETTING_USER_ID, configuration->GetUserId());
-                }
-
                             if (configuration->IsValidPluginUpdate() && configuration->GetPluginUpdateVersion() != IEPLUGIN_VERSION)
                 {
                     settings->SetString(SETTING_PLUGIN_UPDATE_URL, configuration->GetPluginUpdateUrl());
                     settings->SetString(SETTING_PLUGIN_UPDATE_VERSION, configuration->GetPluginUpdateVersion());
                 }
                 else
                             {
                     settings->Remove(SETTING_PLUGIN_UPDATE_VERSION);
                     settings->Remove(SETTING_PLUGIN_UPDATE_URL);
                             }
@@ skipping 38 matching lines @@
 #endif // SUPPORT_FILTER
 
 #ifdef SUPPORT_WHITELIST
                 // Update white list
                 if (configuration->IsValidWhiteList())
                 {
                     settings->ReplaceWhiteListedDomains(configuration->GetWhiteList());
                 }
 #endif // SUPPORT_WHITELIST
 
-                // Check pluginID
-                CString newPluginId = system->GetPluginId();
-                    
-                if (newPluginId != settings->GetString(SETTING_PLUGIN_ID))
-                {
-                    DEBUG_GENERAL(L"*** pluginId has changed from " + settings->GetString(SETTING_PLUGIN_ID) + CString(L" to ") + newPluginId)
-
-                    settings->SetString(SETTING_PLUGIN_ID, newPluginId);                
-                }
-
-                settings->SetString(SETTING_REG_SUCCEEDED, "true");     
-
-                                settings->SetBool(SETTING_PLUGIN_REGISTRATION, configuration->IsPluginRegistered());
-#ifdef PRODUCT_SIMPLEADBLOCK
-                                settings->SetValue(SETTING_PLUGIN_ADBLOCKLIMIT, configuration->GetAdBlockLimit());
-#endif
                 settings->Write();
                 
                 configuration->Invalidate();
 
                                 // Update dictionary
                 if (isNewDictionaryVersion)
                 {
                                         CPluginDictionary* dictionary = CPluginDictionary::GetInstance();
 
                     if (dictionary->Download(configuration->GetDictionaryUrl(), CPluginSettings::GetDataPath(DICTIONARY_INI_FILE)))
@@ skipping 57 matching lines @@
                                         settings->SetFilterFileNamesList(fileNamesList);
                     settings->SetValue(SETTING_FILTER_VERSION, configuration->GetFilterVersion());
                     settings->Write();
 
                     settings->IncrementTabVersion(SETTING_TAB_FILTER_VERSION);
 
                                         tab->OnUpdate();
                 }
 #endif // SUPPORT_FILTER
                     }
-                    // Plugin not loaded
-                    else if (regAttempts <= REGISTRATION_MAX_ATTEMPTS)
-                    {
-                        settings->SetValue(SETTING_REG_ATTEMPTS, regAttempts);
-                            settings->Write();
-            } 
         }
 
             // --------------------------------------------------------------------
             // Check filters
             // --------------------------------------------------------------------
 #ifdef SUPPORT_FILTER
 
         DEBUG_THREAD(L"Thread::Check filters");
 
         if (!IsMainThreadDone(hMainThread))
@@ skipping 49 matching lines @@
         if (!IsMainThreadDone(hMainThread))
         {
                     bool isDone = false;
                 DWORD sleepLoopIteration = 1;
 
                     // Sleep loop
                     while (!isDone && !IsMainThreadDone(hMainThread) && !s_isPluginToBeUpdated)
                     {
                             // Non-hanging sleep
                             Sleep(50);
-
-                            if (hasUser || regAttempts >= REGISTRATION_MAX_ATTEMPTS)
-                            {
-                                    if (sleepLoopIteration++ % (TIMER_THREAD_SLEEP_MAIN_LOOP / 50) == 0)
-                                    {
-                                            isDone = true;
-                                    }
-                            }
-                            else if (sleepLoopIteration++ % (TIMER_THREAD_SLEEP_USER_REGISTRATION / 50) == 0)
+                                
+                                if (sleepLoopIteration++ % (TIMER_THREAD_SLEEP_USER_REGISTRATION / 50) == 0)
                             {
                                     isDone = true;
                             }
                     }
                 }
 
             mainLoopIteration++;
         }
 
         return 0;
@@ skipping 19 matching lines @@
     bool isDone = false;
 
     s_criticalSectionLocal.Lock();
     {
         isDone = s_isMainThreadDone || mainThread != s_hMainThread;
     }
     s_criticalSectionLocal.Unlock();
 
     return isDone;
 }