path: root/comm/mailnews/base/src/nsMsgPurgeService.cpp

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsMsgPurgeService.h"
#include "nsIMsgAccountManager.h"
#include "nsMsgUtils.h"
#include "nsMsgSearchCore.h"
#include "msgCore.h"
#include "nsISpamSettings.h"
#include "nsIMsgSearchTerm.h"
#include "nsIMsgHdr.h"
#include "nsIMsgProtocolInfo.h"
#include "nsIMsgFilterPlugin.h"
#include "nsIPrefBranch.h"
#include "nsIPrefService.h"
#include "mozilla/Logging.h"
#include "nsMsgFolderFlags.h"
#include "nsITimer.h"
#include <stdlib.h>
#include "nsComponentManagerUtils.h"
#include "nsServiceManagerUtils.h"

static mozilla::LazyLogModule MsgPurgeLogModule("MsgPurge");

NS_IMPL_ISUPPORTS(nsMsgPurgeService, nsIMsgPurgeService, nsIMsgSearchNotify)

void OnPurgeTimer(nsITimer* timer, void* aPurgeService) {
  nsMsgPurgeService* purgeService = (nsMsgPurgeService*)aPurgeService;
  purgeService->PerformPurge();
}

nsMsgPurgeService::nsMsgPurgeService() {
  mHaveShutdown = false;
  // never purge a folder more than once every 8 hours (60 min/hour * 8 hours.
  mMinDelayBetweenPurges = 480;
  // fire the purge timer every 5 minutes, starting 5 minutes after the service
  // is created (when we load accounts).
  mPurgeTimerInterval = 5;
}

nsMsgPurgeService::~nsMsgPurgeService() {
  if (mPurgeTimer) mPurgeTimer->Cancel();

  if (!mHaveShutdown) Shutdown();
}

NS_IMETHODIMP nsMsgPurgeService::Init() {
  nsresult rv;

  // these prefs are here to help QA test this feature
  nsCOMPtr<nsIPrefBranch> prefBranch(
      do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
  if (NS_SUCCEEDED(rv)) {
    int32_t min_delay;
    rv = prefBranch->GetIntPref("mail.purge.min_delay", &min_delay);
    if (NS_SUCCEEDED(rv) && min_delay) mMinDelayBetweenPurges = min_delay;

    int32_t purge_timer_interval;
    rv = prefBranch->GetIntPref("mail.purge.timer_interval",
                                &purge_timer_interval);
    if (NS_SUCCEEDED(rv) && purge_timer_interval)
      mPurgeTimerInterval = purge_timer_interval;
  }

  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("mail.purge.min_delay=%d minutes", mMinDelayBetweenPurges));
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("mail.purge.timer_interval=%d minutes", mPurgeTimerInterval));

  // don't start purging right away.
  // because the accounts aren't loaded and because the user might be trying to
  // sign in or startup, etc.
  SetupNextPurge();

  mHaveShutdown = false;
  return NS_OK;
}

NS_IMETHODIMP nsMsgPurgeService::Shutdown() {
  if (mPurgeTimer) {
    mPurgeTimer->Cancel();
    mPurgeTimer = nullptr;
  }

  mHaveShutdown = true;
  return NS_OK;
}

nsresult nsMsgPurgeService::SetupNextPurge() {
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("setting to check again in %d minutes", mPurgeTimerInterval));

  // Convert mPurgeTimerInterval into milliseconds
  uint32_t timeInMSUint32 = mPurgeTimerInterval * 60000;

  // Can't currently reset a timer when it's in the process of
  // calling Notify. So, just release the timer here and create a new one.
  if (mPurgeTimer) mPurgeTimer->Cancel();

  nsresult rv = NS_NewTimerWithFuncCallback(
      getter_AddRefs(mPurgeTimer), OnPurgeTimer, (void*)this, timeInMSUint32,
      nsITimer::TYPE_ONE_SHOT, "nsMsgPurgeService::OnPurgeTimer", nullptr);
  if (NS_FAILED(rv)) {
    NS_WARNING("Could not start mPurgeTimer timer");
  }

  return NS_OK;
}

// This is the function that looks for the first folder to purge. It also
// applies retention settings to any folder that hasn't had retention settings
// applied in mMinDelayBetweenPurges minutes (default, 8 hours).
// However, if we've spent more than .5 seconds in this loop, don't
// apply any more retention settings because it might lock up the UI.
// This might starve folders later on in the hierarchy, since we always
// start at the top, but since we also apply retention settings when you
// open a folder, or when you compact all folders, I think this will do
// for now, until we have a cleanup on shutdown architecture.
nsresult nsMsgPurgeService::PerformPurge() {
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("performing purge"));

  nsresult rv;

  nsCOMPtr<nsIMsgAccountManager> accountManager =
      do_GetService("@mozilla.org/messenger/account-manager;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  bool keepApplyingRetentionSettings = true;

  nsTArray<RefPtr<nsIMsgIncomingServer>> allServers;
  rv = accountManager->GetAllServers(allServers);
  if (NS_SUCCEEDED(rv)) {
    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
            ("%d servers", (int)allServers.Length()));
    nsCOMPtr<nsIMsgFolder> folderToPurge;
    PRIntervalTime startTime = PR_IntervalNow();
    int32_t purgeIntervalToUse = 0;
    PRTime oldestPurgeTime =
        0;  // we're going to pick the least-recently purged folder

    // apply retention settings to folders that haven't had retention settings
    // applied in mMinDelayBetweenPurges minutes (default 8 hours)
    // Because we get last purge time from the folder cache,
    // this code won't open db's for folders until it decides it needs
    // to apply retention settings, and since
    // nsIMsgFolder::ApplyRetentionSettings will close any db's it opens, this
    // code won't leave db's open.
    for (uint32_t serverIndex = 0; serverIndex < allServers.Length();
         serverIndex++) {
      nsCOMPtr<nsIMsgIncomingServer> server(allServers[serverIndex]);
      if (server) {
        if (keepApplyingRetentionSettings) {
          nsCOMPtr<nsIMsgFolder> rootFolder;
          rv = server->GetRootFolder(getter_AddRefs(rootFolder));
          NS_ENSURE_SUCCESS(rv, rv);

          nsTArray<RefPtr<nsIMsgFolder>> childFolders;
          rv = rootFolder->GetDescendants(childFolders);
          NS_ENSURE_SUCCESS(rv, rv);

          for (auto childFolder : childFolders) {
            uint32_t folderFlags;
            (void)childFolder->GetFlags(&folderFlags);
            if (folderFlags & nsMsgFolderFlags::Virtual) continue;
            PRTime curFolderLastPurgeTime = 0;
            nsCString curFolderLastPurgeTimeString, curFolderUri;
            rv = childFolder->GetStringProperty("LastPurgeTime",
                                                curFolderLastPurgeTimeString);
            if (NS_FAILED(rv))
              continue;  // it is ok to fail, go on to next folder

            if (!curFolderLastPurgeTimeString.IsEmpty()) {
              PRTime theTime;
              PR_ParseTimeString(curFolderLastPurgeTimeString.get(), false,
                                 &theTime);
              curFolderLastPurgeTime = theTime;
            }

            childFolder->GetURI(curFolderUri);
            MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                    ("%s curFolderLastPurgeTime=%s (if blank, then never)",
                     curFolderUri.get(), curFolderLastPurgeTimeString.get()));

            // check if this folder is due to purge
            // has to have been purged at least mMinDelayBetweenPurges minutes
            // ago we don't want to purge the folders all the time - once a
            // day is good enough
            int64_t minDelayBetweenPurges(mMinDelayBetweenPurges);
            int64_t microSecondsPerMinute(60000000);
            PRTime nextPurgeTime =
                curFolderLastPurgeTime +
                (minDelayBetweenPurges * microSecondsPerMinute);
            if (nextPurgeTime < PR_Now()) {
              MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                      ("purging %s", curFolderUri.get()));
              childFolder->ApplyRetentionSettings();
            }
            PRIntervalTime elapsedTime = PR_IntervalNow() - startTime;
            // check if more than 500 milliseconds have elapsed in this purge
            // process
            if (PR_IntervalToMilliseconds(elapsedTime) > 500) {
              keepApplyingRetentionSettings = false;
              break;
            }
          }
        }
        nsCString type;
        nsresult rv = server->GetType(type);
        NS_ENSURE_SUCCESS(rv, rv);

        nsCString hostName;
        server->GetHostName(hostName);
        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] %s (%s)", serverIndex, hostName.get(), type.get()));

        nsCOMPtr<nsISpamSettings> spamSettings;
        rv = server->GetSpamSettings(getter_AddRefs(spamSettings));
        NS_ENSURE_SUCCESS(rv, rv);

        int32_t spamLevel;
        spamSettings->GetLevel(&spamLevel);
        // clang-format off
        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] spamLevel=%d (if 0, don't purge)", serverIndex, spamLevel));
        // clang-format on
        if (!spamLevel) continue;

        // check if we are set up to purge for this server
        // if not, skip it.
        bool purgeSpam;
        spamSettings->GetPurge(&purgeSpam);

        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] purgeSpam=%s (if false, don't purge)", serverIndex,
                 purgeSpam ? "true" : "false"));
        if (!purgeSpam) continue;

        // check if the spam folder uri is set for this server
        // if not skip it.
        nsCString junkFolderURI;
        rv = spamSettings->GetSpamFolderURI(junkFolderURI);
        NS_ENSURE_SUCCESS(rv, rv);

        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] junkFolderURI=%s (if empty, don't purge)", serverIndex,
                 junkFolderURI.get()));
        if (junkFolderURI.IsEmpty()) continue;

        // if the junk folder doesn't exist
        // because the folder pane isn't built yet, for example
        // skip this account
        nsCOMPtr<nsIMsgFolder> junkFolder;
        rv = FindFolder(junkFolderURI, getter_AddRefs(junkFolder));
        NS_ENSURE_SUCCESS(rv, rv);

        // clang-format off
        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] %s exists? %s (if doesn't exist, don't purge)", serverIndex,
                 junkFolderURI.get(), junkFolder ? "true" : "false"));
        // clang-format on
        if (!junkFolder) continue;

        PRTime curJunkFolderLastPurgeTime = 0;
        nsCString curJunkFolderLastPurgeTimeString;
        rv = junkFolder->GetStringProperty("curJunkFolderLastPurgeTime",
                                           curJunkFolderLastPurgeTimeString);
        if (NS_FAILED(rv))
          continue;  // it is ok to fail, junk folder may not exist

        if (!curJunkFolderLastPurgeTimeString.IsEmpty()) {
          PRTime theTime;
          PR_ParseTimeString(curJunkFolderLastPurgeTimeString.get(), false,
                             &theTime);
          curJunkFolderLastPurgeTime = theTime;
        }

        MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                ("[%d] %s curJunkFolderLastPurgeTime=%s (if blank, then never)",
                 serverIndex, junkFolderURI.get(),
                 curJunkFolderLastPurgeTimeString.get()));

        // check if this account is due to purge
        // has to have been purged at least mMinDelayBetweenPurges minutes ago
        // we don't want to purge the folders all the time
        PRTime nextPurgeTime =
            curJunkFolderLastPurgeTime +
            mMinDelayBetweenPurges * 60000000  // convert to microseconds.
            ;
        if (nextPurgeTime < PR_Now()) {
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] last purge greater than min delay", serverIndex));

          nsCOMPtr<nsIMsgIncomingServer> junkFolderServer;
          rv = junkFolder->GetServer(getter_AddRefs(junkFolderServer));
          NS_ENSURE_SUCCESS(rv, rv);

          bool serverBusy = false;
          bool serverRequiresPassword = true;
          bool passwordPromptRequired;
          bool canSearchMessages = false;
          junkFolderServer->GetPasswordPromptRequired(&passwordPromptRequired);
          junkFolderServer->GetServerBusy(&serverBusy);
          junkFolderServer->GetServerRequiresPasswordForBiff(
              &serverRequiresPassword);
          junkFolderServer->GetCanSearchMessages(&canSearchMessages);
          // Make sure we're logged on before doing the search (assuming we need
          // to be) and make sure the server isn't already in the middle of
          // downloading new messages and make sure a search isn't already going
          // on
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] (search in progress? %s)", serverIndex,
                   mSearchSession ? "true" : "false"));
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] (server busy? %s)", serverIndex,
                   serverBusy ? "true" : "false"));
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] (serverRequiresPassword? %s)", serverIndex,
                   serverRequiresPassword ? "true" : "false"));
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] (passwordPromptRequired? %s)", serverIndex,
                   passwordPromptRequired ? "true" : "false"));
          if (canSearchMessages && !mSearchSession && !serverBusy &&
              (!serverRequiresPassword || !passwordPromptRequired)) {
            int32_t purgeInterval;
            spamSettings->GetPurgeInterval(&purgeInterval);

            if ((oldestPurgeTime == 0) ||
                (curJunkFolderLastPurgeTime < oldestPurgeTime)) {
              // clang-format off
              MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                      ("[%d] purging! searching for messages older than %d days",
                       serverIndex, purgeInterval));
              // clang-format on
              oldestPurgeTime = curJunkFolderLastPurgeTime;
              purgeIntervalToUse = purgeInterval;
              folderToPurge = junkFolder;
              // if we've never purged this folder, do it...
              if (curJunkFolderLastPurgeTime == 0) break;
            }
          } else {
            NS_ASSERTION(canSearchMessages,
                         "unexpected, you should be able to search");
            MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                    ("[%d] not a good time for this server, try again later",
                     serverIndex));
          }
        } else {
          MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
                  ("[%d] last purge too recent", serverIndex));
        }
      }
    }
    if (folderToPurge && purgeIntervalToUse != 0)
      rv = SearchFolderToPurge(folderToPurge, purgeIntervalToUse);
  }

  // set up timer to check accounts again
  SetupNextPurge();
  return rv;
}

nsresult nsMsgPurgeService::SearchFolderToPurge(nsIMsgFolder* folder,
                                                int32_t purgeInterval) {
  nsresult rv;
  mSearchSession =
      do_CreateInstance("@mozilla.org/messenger/searchSession;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  mSearchSession->RegisterListener(this, nsIMsgSearchSession::allNotifications);

  // update the time we attempted to purge this folder
  char dateBuf[100];
  dateBuf[0] = '\0';
  PRExplodedTime exploded;
  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &exploded);
  PR_FormatTimeUSEnglish(dateBuf, sizeof(dateBuf), "%a %b %d %H:%M:%S %Y",
                         &exploded);
  folder->SetStringProperty("curJunkFolderLastPurgeTime",
                            nsDependentCString(dateBuf));
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("curJunkFolderLastPurgeTime is now %s", dateBuf));

  nsCOMPtr<nsIMsgIncomingServer> server;
  // We need to get the folder's server scope because imap can have
  // local junk folder.
  rv = folder->GetServer(getter_AddRefs(server));
  NS_ENSURE_SUCCESS(rv, rv);

  nsMsgSearchScopeValue searchScope;
  server->GetSearchScope(&searchScope);

  mSearchSession->AddScopeTerm(searchScope, folder);

  // look for messages older than the cutoff
  // you can't also search by junk status, see
  // nsMsgPurgeService::OnSearchHit()
  nsCOMPtr<nsIMsgSearchTerm> searchTerm;
  mSearchSession->CreateTerm(getter_AddRefs(searchTerm));
  if (searchTerm) {
    searchTerm->SetAttrib(nsMsgSearchAttrib::AgeInDays);
    searchTerm->SetOp(nsMsgSearchOp::IsGreaterThan);
    nsCOMPtr<nsIMsgSearchValue> searchValue;
    searchTerm->GetValue(getter_AddRefs(searchValue));
    if (searchValue) {
      searchValue->SetAttrib(nsMsgSearchAttrib::AgeInDays);
      searchValue->SetAge((uint32_t)purgeInterval);
      searchTerm->SetValue(searchValue);
    }
    searchTerm->SetBooleanAnd(false);
    mSearchSession->AppendTerm(searchTerm);
  }

  // we are about to search
  // create mHdrsToDelete array (if not previously created)
  NS_ASSERTION(mHdrsToDelete.IsEmpty(), "mHdrsToDelete is not empty");

  mSearchFolder = folder;
  return mSearchSession->Search(nullptr);
}

NS_IMETHODIMP nsMsgPurgeService::OnNewSearch() {
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("on new search"));
  return NS_OK;
}

NS_IMETHODIMP nsMsgPurgeService::OnSearchHit(nsIMsgDBHdr* aMsgHdr,
                                             nsIMsgFolder* aFolder) {
  NS_ENSURE_ARG_POINTER(aMsgHdr);

  nsCString messageId;
  nsCString author;
  nsCString subject;

  aMsgHdr->GetMessageId(getter_Copies(messageId));
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("messageId=%s", messageId.get()));
  aMsgHdr->GetSubject(subject);
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("subject=%s", subject.get()));
  aMsgHdr->GetAuthor(getter_Copies(author));
  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("author=%s", author.get()));

  // double check that the message is junk before adding to
  // the list of messages to delete
  //
  // note, we can't just search for messages that are junk
  // because not all imap server support keywords
  // (which we use for the junk score)
  // so the junk status would be in the message db.
  //
  // see bug #194090
  nsCString junkScoreStr;
  nsresult rv = aMsgHdr->GetStringProperty("junkscore", junkScoreStr);
  NS_ENSURE_SUCCESS(rv, rv);

  MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
          ("junkScore=%s (if empty or != nsIJunkMailPlugin::IS_SPAM_SCORE, "
           "don't add to list delete)",
           junkScoreStr.get()));

  // if "junkscore" is not set, don't delete the message
  if (junkScoreStr.IsEmpty()) return NS_OK;

  if (atoi(junkScoreStr.get()) == nsIJunkMailPlugin::IS_SPAM_SCORE) {
    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
            ("added message to delete"));
    mHdrsToDelete.AppendElement(aMsgHdr);
  }
  return NS_OK;
}

NS_IMETHODIMP nsMsgPurgeService::OnSearchDone(nsresult status) {
  if (NS_SUCCEEDED(status)) {
    uint32_t count = mHdrsToDelete.Length();
    MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info,
            ("%d messages to delete", count));

    if (count > 0) {
      MOZ_LOG(MsgPurgeLogModule, mozilla::LogLevel::Info, ("delete messages"));
      if (mSearchFolder)
        mSearchFolder->DeleteMessages(
            mHdrsToDelete, nullptr, false /*delete storage*/, false /*isMove*/,
            nullptr, false /*allowUndo*/);
    }
  }
  mHdrsToDelete.Clear();
  if (mSearchSession) mSearchSession->UnregisterListener(this);
  // don't cache the session
  // just create another search session next time we search, rather than
  // clearing scopes, terms etc. we also use mSearchSession to determine if the
  // purge service is "busy"
  mSearchSession = nullptr;
  mSearchFolder = nullptr;
  return NS_OK;
}