Source code

Revision control

Copy as Markdown

Other Tools

/* -*- 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 "msgCore.h" // precompiled header...
#include "nsMsgLocalStoreUtils.h"
#include "nsIFile.h"
#include "nsIDBFolderInfo.h"
#include "nsIMsgDatabase.h"
#include "HeaderReader.h"
#include "nsPrintfCString.h"
#include "nsReadableUtils.h"
#include "mozilla/Buffer.h"
#include "nsIInputStream.h"
#include "nsIOutputStream.h"
#include "prprf.h"
#define EXTRA_SAFETY_SPACE 0x400000 // (4MiB)
nsMsgLocalStoreUtils::nsMsgLocalStoreUtils() {}
nsresult nsMsgLocalStoreUtils::AddDirectorySeparator(nsIFile* path) {
nsAutoString leafName;
path->GetLeafName(leafName);
leafName.AppendLiteral(FOLDER_SUFFIX);
return path->SetLeafName(leafName);
}
bool nsMsgLocalStoreUtils::nsShouldIgnoreFile(nsAString& name, nsIFile* path) {
if (name.IsEmpty()) return true;
char16_t firstChar = name.First();
if (firstChar == '.' || firstChar == '#' ||
name.CharAt(name.Length() - 1) == '~')
return true;
if (name.LowerCaseEqualsLiteral("msgfilterrules.dat") ||
name.LowerCaseEqualsLiteral("rules.dat") ||
name.LowerCaseEqualsLiteral("filterlog.html") ||
name.LowerCaseEqualsLiteral("junklog.html") ||
name.LowerCaseEqualsLiteral("rulesbackup.dat"))
return true;
// don't add summary files to the list of folders;
// don't add popstate files to the list either, or rules (sort.dat).
if (StringEndsWith(name, u".snm"_ns) ||
name.LowerCaseEqualsLiteral("popstate.dat") ||
name.LowerCaseEqualsLiteral("sort.dat") ||
name.LowerCaseEqualsLiteral("mailfilt.log") ||
name.LowerCaseEqualsLiteral("filters.js") ||
StringEndsWith(name, u".toc"_ns))
return true;
// ignore RSS data source files (see FeedUtils.jsm)
if (name.LowerCaseEqualsLiteral("feeds.json") ||
name.LowerCaseEqualsLiteral("feeds.json.tmp") ||
name.LowerCaseEqualsLiteral("feeds.json.backup") ||
name.LowerCaseEqualsLiteral("feeds.json.corrupt") ||
name.LowerCaseEqualsLiteral("feeditems.json") ||
name.LowerCaseEqualsLiteral("feeditems.json.tmp") ||
name.LowerCaseEqualsLiteral("feeditems.json.backup") ||
name.LowerCaseEqualsLiteral("feeditems.json.corrupt") ||
name.LowerCaseEqualsLiteral("feeds.rdf") ||
name.LowerCaseEqualsLiteral("feeditems.rdf") ||
StringBeginsWith(name, u"feeditems_error"_ns))
return true;
// Ignore hidden and other special system files.
bool specialFile = false;
path->IsHidden(&specialFile);
if (specialFile) return true;
specialFile = false;
path->IsSpecial(&specialFile);
if (specialFile) return true;
// The .mozmsgs dir is for spotlight support
return (StringEndsWith(name, u".mozmsgs"_ns) ||
StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(FOLDER_SUFFIX)) ||
StringEndsWith(name, NS_LITERAL_STRING_FROM_CSTRING(SUMMARY_SUFFIX)));
}
// Attempts to fill a buffer. Returns a span holding the data read.
// Might be less than buffer size, if EOF was encountered.
// Upon error, an empty span is returned.
static mozilla::Span<char> readBuf(nsIInputStream* readable,
mozilla::Buffer<char>& buf) {
uint32_t total = 0;
while (total < buf.Length()) {
uint32_t n;
nsresult rv =
readable->Read(buf.Elements() + total, buf.Length() - total, &n);
if (NS_FAILED(rv)) {
total = 0;
break;
}
if (n == 0) {
break; // EOF
}
total += n;
}
return mozilla::Span<char>(buf.Elements(), total);
}
// Write data to outputstream, until complete or error.
static nsresult writeBuf(nsIOutputStream* writeable, const char* data,
size_t dataSize) {
uint32_t written = 0;
while (written < dataSize) {
uint32_t n;
nsresult rv = writeable->Write(data + written, dataSize - written, &n);
NS_ENSURE_SUCCESS(rv, rv);
written += n;
}
return NS_OK;
}
/**
* Attempt to update X-Mozilla-Status and X-Mozilla-Status2 headers with
* new message flags by rewriting them in place.
*/
nsresult nsMsgLocalStoreUtils::RewriteMsgFlags(nsISeekableStream* seekable,
uint32_t msgFlags) {
nsresult rv;
// Remember where we started.
int64_t msgStart;
rv = seekable->Tell(&msgStart);
NS_ENSURE_SUCCESS(rv, rv);
// We edit the file in-place, so need to be able to read and write too.
nsCOMPtr<nsIInputStream> readable(do_QueryInterface(seekable, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIOutputStream> writable = do_QueryInterface(seekable, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Read in the first chunk of the header and search for the X-Mozilla-Status
// headers. We know that those headers always appear at the beginning, so
// don't need to look too far in.
mozilla::Buffer<char> buf(512);
mozilla::Span<const char> data = readBuf(readable, buf);
// If there's a "From " line, consume it.
mozilla::Span<const char> fromLine;
if (data.Length() >= 5 &&
nsDependentCSubstring(data.First(5)).EqualsLiteral("From ")) {
fromLine = FirstLine(data);
data = data.From(fromLine.Length());
}
HeaderReader::Hdr statusHdr;
HeaderReader::Hdr status2Hdr;
auto findHeadersFn = [&](auto const& hdr) {
if (hdr.Name(data).EqualsLiteral(X_MOZILLA_STATUS)) {
statusHdr = hdr;
} else if (hdr.Name(data).EqualsLiteral(X_MOZILLA_STATUS2)) {
status2Hdr = hdr;
} else {
return true; // Keep looking.
}
// Keep looking until we find both.
return statusHdr.IsEmpty() || status2Hdr.IsEmpty();
};
HeaderReader rdr;
rdr.Parse(data, findHeadersFn);
// Update X-Mozilla-Status (holds the lower 16bits worth of flags).
if (!statusHdr.IsEmpty()) {
uint32_t oldFlags = statusHdr.Value(data).ToInteger(&rv, 16);
if (NS_SUCCEEDED(rv)) {
// Preserve the Queued flag from existing X-Mozilla-Status header.
// (Note: not sure why we do this, but keeping it in for now. - BenC)
msgFlags |= oldFlags & nsMsgMessageFlags::Queued;
if ((msgFlags & 0xFFFF) != oldFlags) {
auto out = nsPrintfCString("%4.4x", msgFlags & 0xFFFF);
if (out.Length() <= statusHdr.rawValLen) {
rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
msgStart + fromLine.Length() + statusHdr.pos +
statusHdr.rawValOffset);
NS_ENSURE_SUCCESS(rv, rv);
// Should be an exact fit already, but just in case...
while (out.Length() < statusHdr.rawValLen) {
out.Append(' ');
}
rv = writeBuf(writable, out.BeginReading(), out.Length());
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
}
// Update X-Mozilla-Status2 (holds the upper 16bit flags only(!)).
if (!status2Hdr.IsEmpty()) {
uint32_t oldFlags = status2Hdr.Value(data).ToInteger(&rv, 16);
if (NS_SUCCEEDED(rv)) {
if ((msgFlags & 0xFFFF0000) != oldFlags) {
auto out = nsPrintfCString("%8.8x", msgFlags & 0xFFFF0000);
if (out.Length() <= status2Hdr.rawValLen) {
rv = seekable->Seek(nsISeekableStream::NS_SEEK_SET,
msgStart + fromLine.Length() + status2Hdr.pos +
status2Hdr.rawValOffset);
NS_ENSURE_SUCCESS(rv, rv);
while (out.Length() < status2Hdr.rawValLen) {
out.Append(' ');
}
rv = writeBuf(writable, out.BeginReading(), out.Length());
NS_ENSURE_SUCCESS(rv, rv);
}
}
}
}
return NS_OK;
}
/**
* Returns true if there is enough space on disk.
*
* @param aFile Any file in the message store that is on a logical
* disk volume so that it can be queried for disk space.
* @param aSpaceRequested The size of free space there must be on the disk
* to return true.
*/
bool nsMsgLocalStoreUtils::DiskSpaceAvailableInStore(nsIFile* aFile,
uint64_t aSpaceRequested) {
int64_t diskFree;
nsresult rv = aFile->GetDiskSpaceAvailable(&diskFree);
if (NS_SUCCEEDED(rv)) {
#ifdef DEBUG
printf("GetDiskSpaceAvailable returned: %lld bytes\n", (long long)diskFree);
#endif
// When checking for disk space available, take into consideration
// possible database changes, therefore ask for a little more
// (EXTRA_SAFETY_SPACE) than what the requested size is. Also, due to disk
// sector sizes, allocation blocks, etc. The space "available" may be
// greater than the actual space usable.
return ((aSpaceRequested + EXTRA_SAFETY_SPACE) < (uint64_t)diskFree);
} else if (rv == NS_ERROR_NOT_IMPLEMENTED) {
// The call to GetDiskSpaceAvailable is not implemented!
// This will happen on certain platforms where GetDiskSpaceAvailable
// is not implemented. Since people on those platforms still need
// to download mail, we will simply bypass the disk-space check.
//
// We'll leave a debug message to warn people.
#ifdef DEBUG
printf(
"Call to GetDiskSpaceAvailable FAILED because it is not "
"implemented!\n");
#endif
return true;
} else {
printf("Call to GetDiskSpaceAvailable FAILED!\n");
return false;
}
}
/**
* Resets forceReparse in the database.
*
* @param aMsgDb The database to reset.
*/
void nsMsgLocalStoreUtils::ResetForceReparse(nsIMsgDatabase* aMsgDB) {
if (aMsgDB) {
nsCOMPtr<nsIDBFolderInfo> folderInfo;
aMsgDB->GetDBFolderInfo(getter_AddRefs(folderInfo));
if (folderInfo) folderInfo->SetBooleanProperty("forceReparse", false);
}
}
/**
* Update the value of an X-Mozilla-Keys header in place.
*
* @param seekable The stream containing the message, positioned at the
* beginning of the message (must also be readable and
* writable).
* @param keywordsToAdd The list of keywords to add.
* @param keywordsToRemove The list of keywords to remove.
* @param notEnoughRoom Upon return, this will be set if the header is missing
* or too small to contain the new keywords.
*
*/
nsresult nsMsgLocalStoreUtils::ChangeKeywordsHelper(
nsISeekableStream* seekable, nsTArray<nsCString> const& keywordsToAdd,
nsTArray<nsCString> const& keywordsToRemove, bool& notEnoughRoom) {
notEnoughRoom = false;
nsresult rv;
// Remember where we started.
int64_t msgStart;
rv = seekable->Tell(&msgStart);
NS_ENSURE_SUCCESS(rv, rv);
// We edit the file in-place, so need to be able to read and write too.
nsCOMPtr<nsIInputStream> readable(do_QueryInterface(seekable, &rv));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIOutputStream> writable = do_QueryInterface(seekable, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Read in the first chunk of the header and search for X-Mozilla-Keys.
// We know that it always appears near the beginning, so don't need to look
// too far in.
mozilla::Buffer<char> buf(512);
mozilla::Span<const char> data = readBuf(readable, buf);
// If there's a "From " line, consume it.
mozilla::Span<const char> fromLine;
if (data.Length() >= 5 &&
nsDependentCSubstring(data.First(5)).EqualsLiteral("From ")) {
fromLine = FirstLine(data);
data = data.From(fromLine.Length());
}
HeaderReader::Hdr kwHdr;
auto findHeaderFn = [&](auto const& hdr) {
if (hdr.Name(data).EqualsLiteral(HEADER_X_MOZILLA_KEYWORDS)) {
kwHdr = hdr;
return false;
}
return true; // Keep looking.
};
HeaderReader rdr;
rdr.Parse(data, findHeaderFn);
if (kwHdr.IsEmpty()) {
NS_WARNING("X-Mozilla-Keys header not found.");
notEnoughRoom = true;
return NS_OK;
}
// Get existing keywords.
nsTArray<nsCString> keywords;
nsAutoCString old(kwHdr.Value(data));
old.CompressWhitespace();
for (nsACString const& kw : old.Split(' ')) {
keywords.AppendElement(kw);
}
bool altered = false;
// Add missing keywords.
for (auto const& add : keywordsToAdd) {
if (!keywords.Contains(add)) {
keywords.AppendElement(add);
altered = true;
}
}
// Remove any keywords we want gone.
for (auto const& remove : keywordsToRemove) {
auto idx = keywords.IndexOf(remove);
if (idx != keywords.NoIndex) {
keywords.RemoveElementAt(idx);
altered = true;
}
}
if (!altered) {
return NS_OK;
}
// Write updated keywords over existing value.
auto out = StringJoin(" "_ns, keywords);
if (out.Length() > kwHdr.rawValLen) {
NS_WARNING("X-Mozilla-Keys too small for new value.");
notEnoughRoom = true;
return NS_OK;
}
while (out.Length() < kwHdr.rawValLen) {
out.Append(' ');
}
rv = seekable->Seek(
nsISeekableStream::NS_SEEK_SET,
msgStart + fromLine.Length() + kwHdr.pos + kwHdr.rawValOffset);
NS_ENSURE_SUCCESS(rv, rv);
rv = writeBuf(writable, out.BeginReading(), out.Length());
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}