//----------------------------------------------------------------------------------------
static char* MakeUpperCase(char* aPath)
//----------------------------------------------------------------------------------------
{
// windows does not care about case. push to uppercase:
nsAutoString widePath;
nsDependentCString path(aPath);
nsresult rv = NS_CopyNativeToUnicode(path, widePath);
if (NS_FAILED(rv)) {
NS_ERROR("failed to convert a path to Unicode");
return aPath;
}
PRUnichar *start = widePath.BeginWriting();
PRUnichar *end = widePath.EndWriting();
while (start != end) {
// XXX this doesn't change any non-ASCII character
*start = towupper(*start);
++start;
}
nsCAutoString newCPath;
NS_CopyUnicodeToNative(widePath, newCPath);
NS_ASSERTION(path.Length() >= newCPath.Length(),
"uppercased string is longer than original");
::strcpy(aPath, newCPath.get());
return aPath;
}
nsresult nsEudoraFilters::GetMailboxFolder(const char* pNameHierarchy, nsIMsgFolder** ppFolder)
{
NS_ENSURE_ARG_POINTER(ppFolder);
nsCOMPtr<nsIMsgFolder> folder(*ppFolder ? *ppFolder : m_pMailboxesRoot.get());
// We've already grabbed the pointer on incoming, so now ensure
// *ppFolder is null on outgoing if there is an error
*ppFolder = nullptr;
nsAutoCString name(pNameHierarchy + 1);
int32_t sepIndex = name.FindChar(*pNameHierarchy);
if (sepIndex >= 0)
name.SetLength(sepIndex);
nsAutoString unicodeName;
NS_CopyNativeToUnicode(name, unicodeName);
nsCOMPtr<nsIMsgFolder> subFolder;
nsresult rv = folder->GetChildNamed(unicodeName, getter_AddRefs(subFolder));
if (NS_SUCCEEDED(rv))
{
*ppFolder = subFolder;
if (sepIndex >= 0)
return GetMailboxFolder(pNameHierarchy + sepIndex + 1, ppFolder);
NS_IF_ADDREF(*ppFolder);
}
return rv;
}
void
GeckoMediaPluginServiceParent::LoadFromEnvironment()
{
MOZ_ASSERT(NS_GetCurrentThread() == mGMPThread);
const char* env = PR_GetEnv("MOZ_GMP_PATH");
if (!env || !*env) {
return;
}
nsString allpaths;
if (NS_WARN_IF(NS_FAILED(NS_CopyNativeToUnicode(nsDependentCString(env), allpaths)))) {
return;
}
uint32_t pos = 0;
while (pos < allpaths.Length()) {
// Loop over multiple path entries separated by colons (*nix) or
// semicolons (Windows)
int32_t next = allpaths.FindChar(XPCOM_ENV_PATH_SEPARATOR[0], pos);
if (next == -1) {
AddOnGMPThread(nsDependentSubstring(allpaths, pos));
break;
} else {
AddOnGMPThread(nsDependentSubstring(allpaths, pos, next - pos));
pos = next + 1;
}
}
mScannedPluginOnDisk = true;
}
PRBool nsOEScanBoxes::Scan50MailboxDir( nsIFile * srcDir)
{
Reset();
MailboxEntry * pEntry;
PRInt32 index = 1;
char * pLeaf;
PRBool hasMore;
nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
nsresult rv = srcDir->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
NS_ENSURE_SUCCESS(rv, rv);
directoryEnumerator->HasMoreElements(&hasMore);
PRBool isFile;
nsCOMPtr<nsIFile> entry;
nsCString fName;
while (hasMore && NS_SUCCEEDED(rv))
{
nsCOMPtr<nsISupports> aSupport;
rv = directoryEnumerator->GetNext(getter_AddRefs(aSupport));
nsCOMPtr<nsILocalFile> entry(do_QueryInterface(aSupport, &rv));
directoryEnumerator->HasMoreElements(&hasMore);
isFile = PR_FALSE;
rv = entry->IsFile( &isFile);
if (NS_SUCCEEDED( rv) && isFile) {
pLeaf = nsnull;
rv = entry->GetNativeLeafName( fName);
if (NS_SUCCEEDED( rv) &&
(StringEndsWith(fName, NS_LITERAL_CSTRING(".dbx")))) {
// This is a *.dbx file in the mail directory
if (nsOE5File::IsLocalMailFile(entry)) {
pEntry = new MailboxEntry;
pEntry->index = index;
index++;
pEntry->parent = 0;
pEntry->child = 0;
pEntry->sibling = index;
pEntry->type = -1;
fName.SetLength(fName.Length() - 4);
pEntry->fileName = fName.get();
NS_CopyNativeToUnicode(fName, pEntry->mailName);
m_entryArray.AppendElement( pEntry);
}
}
}
}
if (m_entryArray.Count() > 0) {
pEntry = (MailboxEntry *)m_entryArray.ElementAt( m_entryArray.Count() - 1);
pEntry->sibling = -1;
return( PR_TRUE);
}
return( PR_FALSE);
}
//
// FindURLFromNativeURL
//
// we are looking for a URL and couldn't find it using our internal
// URL flavor, so look for it using the native URL flavor,
// CF_INETURLSTRW (We don't handle CF_INETURLSTRA currently)
//
bool
nsClipboard :: FindURLFromNativeURL ( IDataObject* inDataObject, UINT inIndex, void** outData, PRUint32* outDataLen )
{
bool dataFound = false;
void* tempOutData = nullptr;
PRUint32 tempDataLen = 0;
nsresult loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, ::RegisterClipboardFormat(CFSTR_INETURLW), nullptr, &tempOutData, &tempDataLen);
if ( NS_SUCCEEDED(loadResult) && tempOutData ) {
nsDependentString urlString(static_cast<PRUnichar*>(tempOutData));
// the internal mozilla URL format, text/x-moz-url, contains
// URL\ntitle. Since we don't actually have a title here,
// just repeat the URL to fake it.
*outData = ToNewUnicode(urlString + NS_LITERAL_STRING("\n") + urlString);
*outDataLen = NS_strlen(static_cast<PRUnichar*>(*outData)) * sizeof(PRUnichar);
nsMemory::Free(tempOutData);
dataFound = true;
}
else {
loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, ::RegisterClipboardFormat(CFSTR_INETURLA), nullptr, &tempOutData, &tempDataLen);
if ( NS_SUCCEEDED(loadResult) && tempOutData ) {
// CFSTR_INETURLA is (currently) equal to CFSTR_SHELLURL which is equal to CF_TEXT
// which is by definition ANSI encoded.
nsCString urlUnescapedA;
bool unescaped = NS_UnescapeURL(static_cast<char*>(tempOutData), tempDataLen, esc_OnlyNonASCII | esc_SkipControl, urlUnescapedA);
nsString urlString;
if (unescaped)
NS_CopyNativeToUnicode(urlUnescapedA, urlString);
else
NS_CopyNativeToUnicode(nsDependentCString(static_cast<char*>(tempOutData), tempDataLen), urlString);
// the internal mozilla URL format, text/x-moz-url, contains
// URL\ntitle. Since we don't actually have a title here,
// just repeat the URL to fake it.
*outData = ToNewUnicode(urlString + NS_LITERAL_STRING("\n") + urlString);
*outDataLen = NS_strlen(static_cast<PRUnichar*>(*outData)) * sizeof(PRUnichar);
nsMemory::Free(tempOutData);
dataFound = true;
}
}
return dataFound;
} // FindURLFromNativeURL
// XXX : aTryLocaleCharset is not yet effective.
nsresult
nsMIMEHeaderParamImpl::DoGetParameter(const nsACString& aHeaderVal,
const char *aParamName,
ParamDecoding aDecoding,
const nsACString& aFallbackCharset,
bool aTryLocaleCharset,
char **aLang, nsAString& aResult)
{
aResult.Truncate();
nsresult rv;
// get parameter (decode RFC 2231/5987 when applicable, as specified by
// aDecoding (5987 being a subset of 2231) and return charset.)
nsXPIDLCString med;
nsXPIDLCString charset;
rv = DoParameterInternal(PromiseFlatCString(aHeaderVal).get(), aParamName,
aDecoding, getter_Copies(charset), aLang,
getter_Copies(med));
if (NS_FAILED(rv))
return rv;
// convert to UTF-8 after charset conversion and RFC 2047 decoding
// if necessary.
nsCAutoString str1;
rv = DecodeParameter(med, charset.get(), nullptr, false, str1);
NS_ENSURE_SUCCESS(rv, rv);
if (!aFallbackCharset.IsEmpty())
{
nsCAutoString str2;
nsCOMPtr<nsIUTF8ConverterService>
cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
if (cvtUTF8 &&
NS_SUCCEEDED(cvtUTF8->ConvertStringToUTF8(str1,
PromiseFlatCString(aFallbackCharset).get(), false, true,
1, str2))) {
CopyUTF8toUTF16(str2, aResult);
return NS_OK;
}
}
if (IsUTF8(str1)) {
CopyUTF8toUTF16(str1, aResult);
return NS_OK;
}
if (aTryLocaleCharset && !NS_IsNativeUTF8())
return NS_CopyNativeToUnicode(str1, aResult);
CopyASCIItoUTF16(str1, aResult);
return NS_OK;
}
// XXX : aTryLocaleCharset is not yet effective.
NS_IMETHODIMP
nsMIMEHeaderParamImpl::GetParameter(const nsACString& aHeaderVal,
const char *aParamName,
const nsACString& aFallbackCharset,
PRBool aTryLocaleCharset,
char **aLang, nsAString& aResult)
{
aResult.Truncate();
nsresult rv;
// get parameter (decode RFC 2231 if it's RFC 2231-encoded and
// return charset.)
nsXPIDLCString med;
nsXPIDLCString charset;
rv = GetParameterInternal(PromiseFlatCString(aHeaderVal).get(), aParamName,
getter_Copies(charset), aLang, getter_Copies(med));
if (NS_FAILED(rv))
return rv;
// convert to UTF-8 after charset conversion and RFC 2047 decoding
// if necessary.
nsCAutoString str1;
rv = DecodeParameter(med, charset.get(), nsnull, PR_FALSE, str1);
NS_ENSURE_SUCCESS(rv, rv);
if (!aFallbackCharset.IsEmpty())
{
nsCAutoString str2;
nsCOMPtr<nsIUTF8ConverterService>
cvtUTF8(do_GetService(NS_UTF8CONVERTERSERVICE_CONTRACTID));
if (cvtUTF8 &&
NS_SUCCEEDED(cvtUTF8->ConvertStringToUTF8(str1,
PromiseFlatCString(aFallbackCharset).get(), PR_FALSE, str2))) {
CopyUTF8toUTF16(str2, aResult);
return NS_OK;
}
}
if (IsUTF8(str1)) {
CopyUTF8toUTF16(str1, aResult);
return NS_OK;
}
if (aTryLocaleCharset && !NS_IsNativeUTF8())
return NS_CopyNativeToUnicode(str1, aResult);
CopyASCIItoUTF16(str1, aResult);
return NS_OK;
}
nsresult nsEudoraFilters::CreateNewFilter(const char* pName)
{
nsresult rv;
rv = m_pFilterArray->Clear();
NS_ENSURE_SUCCESS(rv, rv);
nsAutoString unicodeName;
NS_CopyNativeToUnicode(nsCString(pName), unicodeName);
uint32_t numServers;
rv = m_pServerArray->GetLength(&numServers);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t serverIndex = 0; serverIndex < numServers; serverIndex++)
{
nsCOMPtr<nsIMsgIncomingServer> server = do_QueryElementAt(m_pServerArray, serverIndex, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr <nsIMsgFilterList> filterList;
rv = server->GetFilterList(nullptr, getter_AddRefs(filterList));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgFilter> newFilter;
rv = filterList->CreateFilter(unicodeName, getter_AddRefs(newFilter));
NS_ENSURE_SUCCESS(rv, rv);
rv = newFilter->SetEnabled(false);
NS_ENSURE_SUCCESS(rv, rv);
uint32_t count;
rv = filterList->GetFilterCount(&count);
NS_ENSURE_SUCCESS(rv, rv);
rv = filterList->InsertFilterAt(count, newFilter);
NS_ENSURE_SUCCESS(rv, rv);
m_pFilterArray->AppendElement(newFilter, false);
}
m_isAnd = false;
m_isUnless = false;
m_ignoreTerm = false;
m_isIncoming = false;
m_addedAction = false;
m_hasTransfer = false;
m_hasStop = false;
m_termNotGroked = false;
return NS_OK;
}
void
nsCommandLine::appendArg(const char* arg)
{
#ifdef DEBUG_COMMANDLINE
printf("Adding XP arg: %s\n", arg);
#endif
nsAutoString warg;
#ifdef XP_WIN
CopyUTF8toUTF16(nsDependentCString(arg), warg);
#else
NS_CopyNativeToUnicode(nsDependentCString(arg), warg);
#endif
mArgs.AppendElement(warg);
}
nsOEScanBoxes::MailboxEntry *nsOEScanBoxes::NewMailboxEntry(PRUint32 id, PRUint32 parent, const char *prettyName, char *pFileName)
{
MailboxEntry *pEntry = new MailboxEntry();
if (!pEntry)
return nsnull;
pEntry->index = id;
pEntry->parent = parent;
pEntry->child = 0;
pEntry->type = 0;
pEntry->sibling = -1;
pEntry->processed = PR_FALSE;
NS_CopyNativeToUnicode(nsDependentCString(prettyName), pEntry->mailName);
if (pFileName)
pEntry->fileName = pFileName;
return pEntry;
}
static int
InstallXULApp(nsIFile* aXULRunnerDir,
const char *aAppLocation,
const char *aInstallTo,
const char *aLeafName)
{
nsCOMPtr<nsILocalFile> appLocation;
nsCOMPtr<nsILocalFile> installTo;
nsAutoString leafName;
nsresult rv = XRE_GetFileFromPath(aAppLocation, getter_AddRefs(appLocation));
if (NS_FAILED(rv))
return 2;
if (aInstallTo) {
rv = XRE_GetFileFromPath(aInstallTo, getter_AddRefs(installTo));
if (NS_FAILED(rv))
return 2;
}
if (aLeafName)
NS_CopyNativeToUnicode(nsDependentCString(aLeafName), leafName);
rv = NS_InitXPCOM2(nsnull, aXULRunnerDir, nsnull);
if (NS_FAILED(rv))
return 3;
{
// Scope our COMPtr to avoid holding XPCOM refs beyond xpcom shutdown
nsCOMPtr<nsIXULAppInstall> install
(do_GetService("@mozilla.org/xulrunner/app-install-service;1"));
if (!install) {
rv = NS_ERROR_FAILURE;
}
else {
rv = install->InstallApplication(appLocation, installTo, leafName);
}
}
NS_ShutdownXPCOM(nsnull);
if (NS_FAILED(rv))
return 3;
return 0;
}
NS_IMETHODIMP
nsUserInfo::GetFullname(char16_t **aFullname)
{
struct passwd *pw = nullptr;
pw = getpwuid (geteuid());
if (!pw || !pw->PW_GECOS) return NS_ERROR_FAILURE;
#ifdef DEBUG_sspitzer
printf("fullname = %s\n", pw->PW_GECOS);
#endif
nsAutoCString fullname(pw->PW_GECOS);
// now try to parse the GECOS information, which will be in the form
// Full Name, <other stuff> - eliminate the ", <other stuff>
// also, sometimes GECOS uses "&" to mean "the user name" so do
// the appropriate substitution
// truncate at first comma (field delimiter)
int32_t index;
if ((index = fullname.Find(",")) != kNotFound)
fullname.Truncate(index);
// replace ampersand with username
if (pw->pw_name) {
nsAutoCString username(pw->pw_name);
if (!username.IsEmpty() && nsCRT::IsLower(username.CharAt(0)))
username.SetCharAt(nsCRT::ToUpper(username.CharAt(0)), 0);
fullname.ReplaceSubstring("&", username.get());
}
nsAutoString unicodeFullname;
NS_CopyNativeToUnicode(fullname, unicodeFullname);
*aFullname = ToNewUnicode(unicodeFullname);
if (*aFullname)
return NS_OK;
return NS_ERROR_FAILURE;
}
NS_CStringToUTF16(const nsACString& aSrc,
nsCStringEncoding aSrcEncoding,
nsAString& aDest)
{
switch (aSrcEncoding) {
case NS_CSTRING_ENCODING_ASCII:
CopyASCIItoUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_UTF8:
CopyUTF8toUTF16(aSrc, aDest);
break;
case NS_CSTRING_ENCODING_NATIVE_FILESYSTEM:
NS_CopyNativeToUnicode(aSrc, aDest);
break;
default:
return NS_ERROR_NOT_IMPLEMENTED;
}
return NS_OK; // XXX report errors
}
nsresult nsEudoraWin32::FoundMailbox( nsIFile *mailFile, const char *pName, nsISupportsArray *pArray, nsIImportService *pImport)
{
nsString displayName;
nsCOMPtr<nsIImportMailboxDescriptor> desc;
nsISupports * pInterface;
NS_CopyNativeToUnicode(nsDependentCString(pName), displayName);
#ifdef IMPORT_DEBUG
nsCAutoString path;
mailFile->GetNativePath(path);
if (!path.IsEmpty())
IMPORT_LOG2( "Found eudora mailbox, %s: %s\n", path.get(), pName);
else
IMPORT_LOG1( "Found eudora mailbox, %s\n", pName);
IMPORT_LOG1( "\tm_depth = %d\n", (int)m_depth);
#endif
nsresult rv = pImport->CreateNewMailboxDescriptor( getter_AddRefs( desc));
if (NS_SUCCEEDED( rv))
{
PRInt64 sz = 0;
mailFile->GetFileSize( &sz);
desc->SetDisplayName( displayName.get());
desc->SetDepth( m_depth);
desc->SetSize( sz);
nsCOMPtr <nsILocalFile> pFile = nsnull;
desc->GetFile(getter_AddRefs(pFile));
if (pFile)
{
nsCOMPtr <nsILocalFile> localMailFile = do_QueryInterface(mailFile);
pFile->InitWithFile( localMailFile);
}
rv = desc->QueryInterface( kISupportsIID, (void **) &pInterface);
pArray->AppendElement( pInterface);
pInterface->Release();
}
return( NS_OK);
}
nsresult
net_GetURLSpecFromActualFile(nsIFile *aFile, nsACString &result)
{
nsresult rv;
nsAutoCString nativePath, ePath;
nsAutoString path;
rv = aFile->GetNativePath(nativePath);
if (NS_FAILED(rv)) return rv;
// Convert to unicode and back to check correct conversion to native charset
NS_CopyNativeToUnicode(nativePath, path);
NS_CopyUnicodeToNative(path, ePath);
// Use UTF8 version if conversion was successful
if (nativePath == ePath)
CopyUTF16toUTF8(path, ePath);
else
ePath = nativePath;
nsAutoCString escPath;
NS_NAMED_LITERAL_CSTRING(prefix, "file://");
// Escape the path with the directory mask
if (NS_EscapeURL(ePath.get(), -1, esc_Directory+esc_Forced, escPath))
escPath.Insert(prefix, 0);
else
escPath.Assign(prefix + ePath);
// esc_Directory does not escape the semicolons, so if a filename
// contains semicolons we need to manually escape them.
// This replacement should be removed in bug #473280
escPath.ReplaceSubstring(";", "%3b");
result = escPath;
return NS_OK;
}
nsresult nsEudoraFilters::AddTerm(const char* pHeader, const char* pVerb, const char* pValue, bool booleanAnd, bool negateVerb)
{
nsresult rv;
nsMsgSearchAttribValue attrib = FindHeader(pHeader);
nsMsgSearchOpValue op = FindOperator(pVerb);
nsAutoCString arbitraryHeader;
nsAutoString unicodeHeader, unicodeVerb, unicodeValue;
nsAutoString filterTitle;
NS_CopyNativeToUnicode(nsCString(pHeader), unicodeHeader);
NS_CopyNativeToUnicode(nsCString(pVerb), unicodeVerb);
NS_CopyNativeToUnicode(nsCString(pValue), unicodeValue);
filterTitle = NS_LITERAL_STRING("- ");
filterTitle += unicodeHeader;
filterTitle += NS_LITERAL_STRING(" ");
filterTitle += unicodeVerb;
filterTitle += NS_LITERAL_STRING(" ");
filterTitle += unicodeValue;
filterTitle += NS_LITERAL_STRING(": ");
if (op < 0)
{
m_errorLog += filterTitle;
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_VERB, pVerb);
m_errorLog += NS_LITERAL_STRING("\n");
return NS_ERROR_INVALID_ARG;
}
if (!pHeader || !*pHeader)
{
m_errorLog += filterTitle;
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_EMPTY_HEADER);
m_errorLog += NS_LITERAL_STRING("\n");
return NS_ERROR_INVALID_ARG;
}
if (negateVerb)
{
switch (op)
{
case nsMsgSearchOp::Contains:
case nsMsgSearchOp::Is:
case nsMsgSearchOp::IsInAB:
op++;
break;
case nsMsgSearchOp::DoesntContain:
case nsMsgSearchOp::Isnt:
case nsMsgSearchOp::IsntInAB:
op--;
break;
default:
m_errorLog += filterTitle;
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_NEGATE_VERB, unicodeVerb.get());
m_errorLog += NS_LITERAL_STRING("\n");
return NS_ERROR_INVALID_ARG;
}
}
if (attrib < 0)
{
// Can't handle other Eudora meta-headers (Any Header, Personality, Junk Score)
if (*pHeader == *LDAQ)
{
m_errorLog += filterTitle;
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_META_HEADER, unicodeHeader.get());
m_errorLog += NS_LITERAL_STRING("\n");
return NS_ERROR_INVALID_ARG;
}
// Arbitrary headers for filters don't like the colon at the end
arbitraryHeader = pHeader;
int32_t index = arbitraryHeader.FindChar(':');
if (index >= 0)
arbitraryHeader.SetLength(index);
int32_t headerIndex = AddCustomHeader(arbitraryHeader.get());
NS_ENSURE_TRUE(headerIndex >= 0, NS_ERROR_FAILURE);
attrib = nsMsgSearchAttrib::OtherHeader + 1 + headerIndex;
}
uint32_t numFilters;
rv = m_pFilterArray->GetLength(&numFilters);
NS_ENSURE_SUCCESS(rv, rv);
for (uint32_t filterIndex = 0; filterIndex < numFilters; filterIndex++)
{
nsCOMPtr<nsIMsgFilter> filter = do_QueryElementAt(m_pFilterArray, filterIndex, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupportsArray> terms;
rv = filter->GetSearchTerms(getter_AddRefs(terms));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgSearchTerm> term;
if (booleanAnd)
{
term = do_QueryElementAt(terms, 0, &rv);
if (NS_SUCCEEDED(rv) && term)
{
term->SetBooleanAnd(true);
term = nullptr;
}
}
rv = filter->CreateTerm(getter_AddRefs(term));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIMsgSearchValue> value;
rv = term->GetValue(getter_AddRefs(value));
NS_ENSURE_SUCCESS(rv, rv);
value->SetAttrib(attrib);
value->SetStr(unicodeValue);
term->SetAttrib(attrib);
term->SetOp(op);
term->SetBooleanAnd(booleanAnd);
if (!arbitraryHeader.IsEmpty())
term->SetArbitraryHeader(arbitraryHeader);
term->SetValue(value);
filter->AppendTerm(term);
}
return NS_OK;
}
bool nsEudoraFilters::RealImport()
{
nsresult rv;
rv = Init();
if (NS_FAILED(rv))
{
IMPORT_LOG0("*** Error initializing filter import process\n");
return false;
}
nsCOMPtr <nsIInputStream> inputStream;
rv = NS_NewLocalFileInputStream(getter_AddRefs(inputStream), m_pLocation);
if (NS_FAILED(rv))
{
IMPORT_LOG0("*** Error opening filters file for reading\n");
return false;
}
rv = LoadServers();
if (NS_FAILED(rv))
{
IMPORT_LOG0("*** Error loading servers with filters\n");
return false;
}
nsCOMPtr<nsILineInputStream> lineStream(do_QueryInterface(inputStream, &rv));
NS_ENSURE_SUCCESS(rv, false);
nsCString line;
bool more = true;
nsAutoCString header;
nsAutoCString verb;
nsAutoString name;
// Windows Eudora filters files have a version header as a first line - just skip it
#if defined(XP_WIN)
rv = lineStream->ReadLine(line, &more);
#endif
while (more && NS_SUCCEEDED(rv))
{
rv = lineStream->ReadLine(line, &more);
const char* pLine = line.get();
if (NS_SUCCEEDED(rv))
{
// New filters start with a "rule <name>" line
if (!strncmp(pLine, "rule ", 5))
{
rv = FinalizeFilter();
if (NS_SUCCEEDED(rv))
{
const char* pName = pLine + 5;
NS_CopyNativeToUnicode(nsCString(pName), name);
rv = CreateNewFilter(pName);
}
}
#ifdef XP_MACOSX
else if (!strncmp(pLine, "id ", 3))
;// ids have no value to us, but we don't want them to produce a warning either
#endif
else if (!strncmp(pLine, "conjunction ", 12))
{
const char* cj = pLine + 12;
if (!strcmp(cj, "and"))
m_isAnd = true;
else if (!strcmp(cj, "unless"))
m_isUnless = true;
else if (!strcmp(cj, "ignore"))
m_ignoreTerm = true;
}
else if (!strncmp(pLine, "header ", 7))
header = (pLine + 7);
else if (!strncmp(pLine, "verb ", 5))
verb = (pLine + 5);
else if (!strncmp(pLine, "value ", 6))
{
if (!m_ignoreTerm)
{
rv = AddTerm(header.get(), verb.get(), pLine + 6, (m_isAnd || m_isUnless), m_isUnless);
// For now, ignoring terms that can't be represented in TB filters
if (rv == NS_ERROR_INVALID_ARG)
{
rv = NS_OK;
m_termNotGroked = true;
}
}
}
else if (!strcmp(pLine, "incoming"))
m_isIncoming = true;
else if (!strncmp(pLine, "transfer ", 9) ||
!strncmp(pLine, "copy ", 5))
{
const char* pMailboxPath = strchr(pLine, ' ') + 1;
bool isTransfer = (*pLine == 't');
rv = AddMailboxAction(pMailboxPath, isTransfer);
if (rv == NS_ERROR_INVALID_ARG)
{
nsAutoString unicodeMailboxPath;
NS_CopyNativeToUnicode(nsCString(pMailboxPath), unicodeMailboxPath);
m_errorLog += NS_LITERAL_STRING("- ");
m_errorLog += name;
m_errorLog += NS_LITERAL_STRING(": ");
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_MAILBOX_MISSING, unicodeMailboxPath.get());
m_errorLog += NS_LITERAL_STRING("\n");
rv = NS_OK;
}
}
// Doing strncmp() here because Win Eudora puts a space after "stop" but Mac Eudora doesn't
else if (!strncmp(pLine, "stop", 4))
m_hasStop = true;
else if (!strncmp(pLine, "forward ", 8))
rv = AddStringAction(nsMsgFilterAction::Forward, pLine + 8);
else if (!strncmp(pLine, "reply ", 6))
rv = AddStringAction(nsMsgFilterAction::Reply, pLine + 6);
else if (!strncmp(pLine, "priority ", 9))
{
// Win Eudora's priority values are 0 (highest) to 4 (lowest)
// Mac Eudora's priority values are 1 (highest) to 5 (lowest)
// Thunderbird's priority values are 6 (highest) to 2 (lowest)
int32_t TBPriority = 6 - atoi(pLine + 9);
#ifdef XP_MACOSX
TBPriority++;
#endif
rv = AddPriorityAction(TBPriority);
}
else if (!strncmp(pLine, "label ", 6))
{
nsAutoCString tagName("$label");
tagName += pLine + 6;
rv = AddStringAction(nsMsgFilterAction::AddTag, tagName.get());
}
// Doing strncmp() here because Win Eudora puts a space after "junk" but Mac Eudora doesn't
else if (!strncmp(pLine, "junk", 4))
rv = AddJunkAction(100);
else if (!strncmp(pLine, "status ", 7))
{
// Win Eudora's read status is 1, whereas Mac Eudora's read status is 2
uint32_t status = atoi(pLine + 7);
#ifdef XP_MACOSX
status--;
#endif
if (status == 1)
rv = AddAction(nsMsgFilterAction::MarkRead);
}
else if (!strncmp(pLine, "serverOpt ", 10))
{
// Win and Mac Eudora have the two bits swapped in the file
uint32_t bits = atoi(pLine + 10);
#if defined(XP_WIN)
bool bFetch = (bits & 1);
bool bDelete = (bits & 2);
#endif
#ifdef XP_MACOSX
bool bFetch = (bits & 2);
bool bDelete = (bits & 1);
#endif
rv = AddAction(bDelete? (nsMsgRuleActionType)nsMsgFilterAction::DeleteFromPop3Server : (nsMsgRuleActionType)nsMsgFilterAction::LeaveOnPop3Server);
if (NS_SUCCEEDED(rv) && bFetch)
rv = AddAction(nsMsgFilterAction::FetchBodyFromPop3Server);
}
else if (strcmp(pLine, "manual") == 0)
;// Just ignore manual as TB handles manual in a different way
else if (strcmp(pLine, "outgoing") == 0)
{
m_errorLog += NS_LITERAL_STRING("- ");
m_errorLog += name;
m_errorLog += NS_LITERAL_STRING(": ");
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_OUTGOING);
m_errorLog += NS_LITERAL_STRING("\n");
}
else
{
nsAutoString unicodeLine;
NS_CopyNativeToUnicode(nsCString(pLine), unicodeLine);
m_errorLog += NS_LITERAL_STRING("- ");
m_errorLog += name;
m_errorLog += NS_LITERAL_STRING(": ");
m_errorLog += nsEudoraStringBundle::FormatString(EUDORAIMPORT_FILTERS_WARN_ACTION, unicodeLine.get());
m_errorLog += NS_LITERAL_STRING("\n");
}
}
}
// Process the last filter
if (!more && NS_SUCCEEDED(rv))
rv = FinalizeFilter();
inputStream->Close();
if (more)
{
IMPORT_LOG0("*** Error reading the filters, didn't reach the end\n");
return false;
}
rv = SaveFilters();
return NS_SUCCEEDED(rv);
}
// Test a message send????
nsresult nsEudoraCompose::SendTheMessage(nsIFile *pMailImportLocation, nsIFile **pMsg)
{
nsresult rv = CreateComponents();
if (NS_FAILED(rv))
return rv;
// IMPORT_LOG0("Outlook Compose created necessary components\n");
nsString bodyType;
nsString charSet;
nsString headerVal;
GetHeaderValue(m_pHeaders, m_headerLen, "From:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetFrom(headerVal);
GetHeaderValue(m_pHeaders, m_headerLen, "To:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetTo(headerVal);
GetHeaderValue(m_pHeaders, m_headerLen, "Subject:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetSubject(headerVal);
GetHeaderValue(m_pHeaders, m_headerLen, "Content-type:", headerVal);
bodyType = headerVal;
ExtractType(bodyType);
ExtractCharset(headerVal);
// Use platform charset as default if the msg doesn't specify one
// (ie, no 'charset' param in the Content-Type: header). As the last
// resort we'll use the mail default charset.
// (ie, no 'charset' param in the Content-Type: header) or if the
// charset parameter fails a length sanity check.
// As the last resort we'll use the mail default charset.
if (headerVal.IsEmpty() || (headerVal.Length() > kContentTypeLengthSanityCheck))
{
headerVal.AssignASCII(nsMsgI18NFileSystemCharset());
if (headerVal.IsEmpty())
{ // last resort
if (m_defCharset.IsEmpty())
{
nsString defaultCharset;
NS_GetLocalizedUnicharPreferenceWithDefault(nullptr, "mailnews.view_default_charset",
NS_LITERAL_STRING("ISO-8859-1"), defaultCharset);
m_defCharset = defaultCharset;
}
headerVal = m_defCharset;
}
}
m_pMsgFields->SetCharacterSet(NS_LossyConvertUTF16toASCII(headerVal).get());
charSet = headerVal;
GetHeaderValue(m_pHeaders, m_headerLen, "CC:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetCc(headerVal);
GetHeaderValue(m_pHeaders, m_headerLen, "Message-ID:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetMessageId(NS_LossyConvertUTF16toASCII(headerVal).get());
GetHeaderValue(m_pHeaders, m_headerLen, "Reply-To:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetReplyTo(headerVal);
// what about all of the other headers?!?!?!?!?!?!
char *pMimeType;
if (!bodyType.IsEmpty())
pMimeType = ToNewCString(NS_LossyConvertUTF16toASCII(bodyType));
else
pMimeType = ToNewCString(m_bodyType);
nsCOMPtr<nsIArray> pAttach;
GetLocalAttachments(getter_AddRefs(pAttach));
nsEudoraEditor eudoraEditor(m_pBody, pMailImportLocation);
nsCOMPtr<nsIArray> embeddedObjects;
if (eudoraEditor.HasEmbeddedContent())
eudoraEditor.GetEmbeddedObjects(getter_AddRefs(embeddedObjects));
nsString uniBody;
NS_CopyNativeToUnicode(nsDependentCString(m_pBody), uniBody);
/*
l10n - I have the body of the message in the system charset,
I need to "encode" it to be the charset for the message
*UNLESS* of course, I don't know what the charset of the message
should be? How do I determine what the charset should
be if it doesn't exist?
*/
nsCString body;
rv = nsMsgI18NConvertFromUnicode(NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
if (NS_FAILED(rv) && !charSet.Equals(m_defCharset)) {
// in this case, if we did not use the default compose
// charset, then try that.
body.Truncate();
rv = nsMsgI18NConvertFromUnicode(NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
}
uniBody.Truncate();
// See if it's a draft msg (ie, no From: or no To: AND no Cc: AND no Bcc:).
// Eudora saves sent and draft msgs in Out folder (ie, mixed) and it does
// store Bcc: header in the msg itself.
nsAutoString from, to, cc, bcc;
rv = m_pMsgFields->GetFrom(from);
rv = m_pMsgFields->GetTo(to);
rv = m_pMsgFields->GetCc(cc);
rv = m_pMsgFields->GetBcc(bcc);
bool createAsDraft = from.IsEmpty() || (to.IsEmpty() && cc.IsEmpty() && bcc.IsEmpty());
nsCOMPtr<nsIImportService> impService(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = impService->CreateRFC822Message(
s_pIdentity, // dummy identity
m_pMsgFields, // message fields
pMimeType, // body type
body, // body pointer
createAsDraft,
pAttach, // local attachments
embeddedObjects,
m_pListener); // listener
EudoraSendListener *pListen = (EudoraSendListener *)m_pListener;
if (NS_FAILED(rv)) {
IMPORT_LOG1("*** Error, CreateAndSendMessage FAILED: 0x%lx\n", rv);
// IMPORT_LOG1("Headers: %80s\n", m_pHeaders);
}
else {
// wait for the listener to get done!
int32_t abortCnt = 0;
int32_t cnt = 0;
int32_t sleepCnt = 1;
while (!pListen->m_done && (abortCnt < kHungAbortCount)) {
PR_Sleep(sleepCnt);
cnt++;
if (cnt > kHungCount) {
abortCnt++;
sleepCnt *= 2;
cnt = 0;
}
}
if (abortCnt >= kHungAbortCount) {
IMPORT_LOG0("**** Create and send message hung\n");
IMPORT_LOG1("Headers: %s\n", m_pHeaders);
IMPORT_LOG1("Body: %s\n", m_pBody);
rv = NS_ERROR_FAILURE;
}
}
if (pMimeType)
NS_Free(pMimeType);
if (pListen->m_location) {
pListen->m_location->Clone(pMsg);
rv = NS_OK;
}
else {
rv = NS_ERROR_FAILURE;
IMPORT_LOG0("*** Error, Outlook compose unsuccessful\n");
}
pListen->Reset();
return rv;
}
void nsOEScanBoxes::ScanMailboxDir( nsIFile * srcDir)
{
if (Scan50MailboxDir( srcDir))
return;
Reset();
MailboxEntry * pEntry;
PRInt32 index = 1;
nsCAutoString pLeaf;
PRUint32 sLen;
PRBool hasMore;
nsCOMPtr<nsISimpleEnumerator> directoryEnumerator;
nsresult rv = srcDir->GetDirectoryEntries(getter_AddRefs(directoryEnumerator));
if (NS_FAILED(rv))
return;
directoryEnumerator->HasMoreElements(&hasMore);
PRBool isFile;
nsCOMPtr<nsIFile> entry;
nsCString fName;
nsCString ext;
nsCString name;
while (hasMore && NS_SUCCEEDED(rv))
{
nsCOMPtr<nsISupports> aSupport;
rv = directoryEnumerator->GetNext(getter_AddRefs(aSupport));
nsCOMPtr<nsILocalFile> entry(do_QueryInterface(aSupport, &rv));
directoryEnumerator->HasMoreElements(&hasMore);
isFile = PR_FALSE;
rv = entry->IsFile( &isFile);
if (NS_SUCCEEDED( rv) && isFile)
{
rv = entry->GetNativeLeafName(pLeaf);
if (NS_SUCCEEDED( rv) && !pLeaf.IsEmpty() &&
((sLen = pLeaf.Length()) > 4) &&
(!PL_strcasecmp( pLeaf.get() + sLen - 3, "mbx")))
{
// This is a *.mbx file in the mail directory
pEntry = new MailboxEntry;
pEntry->index = index;
index++;
pEntry->parent = 0;
pEntry->child = 0;
pEntry->sibling = index;
pEntry->type = -1;
pEntry->fileName = pLeaf;
pLeaf.SetLength(sLen - 4);
NS_CopyNativeToUnicode(pLeaf, pEntry->mailName);
m_entryArray.AppendElement( pEntry);
}
}
}
if (m_entryArray.Count() > 0) {
pEntry = (MailboxEntry *)m_entryArray.ElementAt( m_entryArray.Count() - 1);
pEntry->sibling = -1;
}
}
nsresult nsEudoraWin32::GetAttachmentInfo( const char *pFileName, nsIFile *pFile, nsCString& mimeType, nsCString& aAttachmentName)
{
nsresult rv;
mimeType.Truncate();
nsCOMPtr <nsILocalFile> pLocalFile = do_QueryInterface(pFile, &rv);
NS_ENSURE_SUCCESS(rv, rv);
pLocalFile->InitWithNativePath(nsDependentCString(pFileName));
bool isFile = false;
bool exists = false;
if (NS_FAILED( rv = pFile->Exists( &exists)))
return( rv);
if ( exists && NS_FAILED( rv = pFile->IsFile(&isFile) ) )
return( rv);
if (!exists || !isFile)
{
// Windows Eudora writes the full path to the attachment when the message
// is received, but doesn't update that path if the attachment directory
// changes (e.g. if email directory is moved). When operating on an
// attachment (opening, etc.) Eudora will first check the full path
// and then if the file doesn't exist there Eudora will check the
// current attachment directory for a file with the same name.
//
// Check to see if we have any better luck looking for the attachment
// in the current attachment directory.
nsCAutoString name;
pFile->GetNativeLeafName(name);
if (name.IsEmpty())
return( NS_ERROR_FAILURE);
nsCOMPtr <nsIFile> altFile;
rv = m_mailImportLocation->Clone(getter_AddRefs(altFile));
NS_ENSURE_SUCCESS(rv, rv);
// For now, we'll do that using a hard coded name and location for the
// attachment directory on Windows (the default location) "attach" inside
// of the Eudora mail directory. Once settings from Eudora are imported
// better, we'll want to check where the settings say attachments are stored.
altFile->AppendNative(NS_LITERAL_CSTRING("attach"));
altFile->AppendNative(name);
// Did we come up with a different path or was the original path already
// in the current attachment directory?
bool isSamePath = true;
rv = altFile->Equals(pFile, &isSamePath);
if (NS_SUCCEEDED(rv) && !isSamePath)
{
// We came up with a different path - check the new path.
if (NS_FAILED( rv = altFile->Exists( &exists)))
return( rv);
if ( exists && NS_FAILED( rv = altFile->IsFile( &isFile) ) )
return( rv);
// Keep the new path if it helped us.
if (exists && isFile)
{
nsCString nativePath;
altFile->GetNativePath(nativePath);
pLocalFile->InitWithNativePath(nativePath);
}
}
}
if (exists && isFile)
{
nsCAutoString name;
pFile->GetNativeLeafName(name);
if (name.IsEmpty())
return( NS_ERROR_FAILURE);
if (name.Length() > 4)
{
nsCString ext;
PRInt32 idx = name.RFindChar( '.');
if (idx != -1)
{
ext = Substring(name, idx);
GetMimeTypeFromExtension(ext, mimeType);
}
}
if (mimeType.IsEmpty())
mimeType = "application/octet-stream";
nsAutoString description;
rv = NS_CopyNativeToUnicode(name, description);
if (NS_SUCCEEDED(rv))
aAttachmentName = NS_ConvertUTF16toUTF8(description);
else
aAttachmentName = name;
return( NS_OK);
}
return( NS_ERROR_FAILURE);
}
nsresult MailEwsMsgCompose::SendTheMessage(ews_msg_item * msg_item,
nsIMsgSendListener *pListener)
{
nsresult rv = CreateComponents();
if (NS_FAILED(rv))
return rv;
IMPORT_LOG0("Outlook Compose created necessary components\n");
nsString bodyType;
nsString charSet;
nsString headerVal;
RecipientToString(&msg_item->from, headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetFrom(headerVal);
else {
RecipientToString(&msg_item->sender, headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetFrom(headerVal);
}
RecipientToString2(msg_item->to_recipients,
msg_item->to_recipients_count,
headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetTo(headerVal);
if (msg_item->item.subject) {
char * key = msg_item->item.subject;
uint32_t l = strlen(key);
/* strip "Re: " */
nsCString modifiedSubject;
if (mailews::NS_MsgStripRE((const char **) &key,
&l,
modifiedSubject)) {
mailews::NS_GetLocalizedUnicharPreferenceWithDefault(nullptr,
"mailnews.localizedRe",
EmptyString(),
headerVal);
if (headerVal.IsEmpty()) {
headerVal.AppendLiteral("Re");
}
headerVal.AppendLiteral(": ");
} else {
headerVal.AssignLiteral("");
}
if (modifiedSubject.IsEmpty()) {
headerVal.AppendLiteral(key);
} else {
headerVal.AppendLiteral(modifiedSubject.get());
}
m_pMsgFields->SetSubject(headerVal);
}
if (msg_item->item.body_type == EWS_BODY_TEXT)
bodyType.AssignLiteral("text/plain");
else
bodyType.AssignLiteral("text/html");
headerVal.AssignLiteral("UTF-8");
// Use platform charset as default if the msg doesn't specify one
// (ie, no 'charset' param in the Content-Type: header). As the last
// resort we'll use the mail default charset.
// (ie, no 'charset' param in the Content-Type: header) or if the
// charset parameter fails a length sanity check.
// As the last resort we'll use the mail default charset.
if (headerVal.IsEmpty() || (headerVal.Length() > kContentTypeLengthSanityCheck))
{
headerVal.AssignASCII(mailews::MsgI18NFileSystemCharset());
if (headerVal.IsEmpty())
{ // last resort
if (m_defCharset.IsEmpty())
{
nsString defaultCharset;
mailews::NS_GetLocalizedUnicharPreferenceWithDefault(nullptr, "mailnews.view_default_charset",
NS_LITERAL_STRING("ISO-8859-1"), defaultCharset);
m_defCharset = defaultCharset;
}
headerVal = m_defCharset;
}
}
m_pMsgFields->SetCharacterSet(NS_LossyConvertUTF16toASCII(headerVal).get());
charSet = headerVal;
RecipientToString2(msg_item->cc_recipients,
msg_item->cc_recipients_count,
headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetCc(headerVal);
RecipientToString2(msg_item->bcc_recipients,
msg_item->bcc_recipients_count,
headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetBcc(headerVal);
if (msg_item->internet_message_id)
m_pMsgFields->SetMessageId(msg_item->internet_message_id);
RecipientToString2(msg_item->reply_to,
msg_item->reply_to_count,
headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetReplyTo(headerVal);
if (msg_item->references)
m_pMsgFields->SetReferences(msg_item->references);
// what about all of the other headers?!?!?!?!?!?!
char *pMimeType;
if (!bodyType.IsEmpty())
pMimeType = ToNewCString(NS_LossyConvertUTF16toASCII(bodyType));
else
pMimeType = strdup("text/plain");
nsCOMPtr<nsIArray> pAttach;
GetLocalAttachments(getter_AddRefs(pAttach));
nsString uniBody;
NS_CopyNativeToUnicode(nsDependentCString(msg_item->item.body), uniBody);
/*
l10n - I have the body of the message in the system charset,
I need to "encode" it to be the charset for the message
*UNLESS* of course, I don't know what the charset of the message
should be? How do I determine what the charset should
be if it doesn't exist?
*/
nsCString body;
rv = mailews::MsgI18NConvertFromUnicode(NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
if (NS_FAILED(rv) && !charSet.Equals(m_defCharset)) {
// in this case, if we did not use the default compose
// charset, then try that.
body.Truncate();
rv = mailews::MsgI18NConvertFromUnicode(NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
}
uniBody.Truncate();
// See if it's a draft msg (ie, no From: or no To: AND no Cc: AND no Bcc:).
// MailEws saves sent and draft msgs in Out folder (ie, mixed) and it does
// store Bcc: header in the msg itself.
nsAutoString from, to, cc, bcc;
rv = m_pMsgFields->GetFrom(from);
rv = m_pMsgFields->GetTo(to);
rv = m_pMsgFields->GetCc(cc);
rv = m_pMsgFields->GetBcc(bcc);
bool createAsDraft = from.IsEmpty() || (to.IsEmpty() && cc.IsEmpty() && bcc.IsEmpty());
nsCOMPtr<nsIImportService> impService(do_GetService(NS_IMPORTSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
rv = impService->CreateRFC822Message(
s_pIdentity, // dummy identity
m_pMsgFields, // message fields
pMimeType, // body type
body, // body pointer
createAsDraft,
pAttach, // local attachments
nullptr, //embededObjects
pListener); // listener
if (NS_FAILED(rv)) {
IMPORT_LOG1("*** Error, CreateAndSendMessage FAILED: 0x%lx\n", (int)rv);
}
if (pMimeType)
NS_Free(pMimeType);
return rv;
}
// Test a message send????
nsresult nsEudoraCompose::SendTheMessage(nsIFile *pMailImportLocation, nsIFile **pMsg)
{
nsresult rv = CreateComponents();
if (NS_SUCCEEDED( rv))
rv = CreateIdentity();
if (NS_FAILED( rv))
return( rv);
// IMPORT_LOG0( "Outlook Compose created necessary components\n");
nsString bodyType;
nsString charSet;
nsString headerVal;
GetHeaderValue( m_pHeaders, m_headerLen, "From:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetFrom( headerVal);
GetHeaderValue( m_pHeaders, m_headerLen, "To:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetTo( headerVal);
GetHeaderValue( m_pHeaders, m_headerLen, "Subject:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetSubject( headerVal);
GetHeaderValue( m_pHeaders, m_headerLen, "Content-type:", headerVal);
bodyType = headerVal;
ExtractType( bodyType);
ExtractCharset( headerVal);
// Use platform charset as default if the msg doesn't specify one
// (ie, no 'charset' param in the Content-Type: header). As the last
// resort we'll use the mail default charset.
// (ie, no 'charset' param in the Content-Type: header) or if the
// charset parameter fails a length sanity check.
// As the last resort we'll use the mail default charset.
if ( headerVal.IsEmpty() || (headerVal.Length() > kContentTypeLengthSanityCheck) )
{
CopyASCIItoUTF16(nsMsgI18NFileSystemCharset(), headerVal);
if (headerVal.IsEmpty())
{ // last resort
if (m_defCharset.IsEmpty())
{
nsString defaultCharset;
NS_GetLocalizedUnicharPreferenceWithDefault(nsnull, "mailnews.view_default_charset",
NS_LITERAL_STRING("ISO-8859-1"), defaultCharset);
m_defCharset = defaultCharset;
}
headerVal = m_defCharset;
}
}
m_pMsgFields->SetCharacterSet( NS_LossyConvertUTF16toASCII(headerVal).get() );
charSet = headerVal;
GetHeaderValue( m_pHeaders, m_headerLen, "CC:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetCc( headerVal);
GetHeaderValue( m_pHeaders, m_headerLen, "Message-ID:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetMessageId( NS_LossyConvertUTF16toASCII(headerVal).get() );
GetHeaderValue( m_pHeaders, m_headerLen, "Reply-To:", headerVal);
if (!headerVal.IsEmpty())
m_pMsgFields->SetReplyTo( headerVal);
// what about all of the other headers?!?!?!?!?!?!
char *pMimeType;
if (!bodyType.IsEmpty())
pMimeType = ToNewCString(bodyType);
else
pMimeType = ToNewCString(m_bodyType);
// IMPORT_LOG0( "Outlook compose calling CreateAndSendMessage\n");
nsMsgAttachedFile *pAttach = GetLocalAttachments();
/*
l10n - I have the body of the message in the system charset,
I need to "encode" it to be the charset for the message
*UNLESS* of course, I don't know what the charset of the message
should be? How do I determine what the charset should
be if it doesn't exist?
*/
nsString uniBody;
NS_CopyNativeToUnicode( nsDependentCString(m_pBody), uniBody);
nsCString body;
rv = nsMsgI18NConvertFromUnicode( NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
if (NS_FAILED( rv)) {
// in this case, if we did not use the default compose
// charset, then try that.
if (!charSet.Equals( m_defCharset)) {
body.Truncate();
rv = nsMsgI18NConvertFromUnicode( NS_LossyConvertUTF16toASCII(charSet).get(),
uniBody, body);
}
}
uniBody.Truncate();
// See if it's a draft msg (ie, no From: or no To: AND no Cc: AND no Bcc:).
// Eudora saves sent and draft msgs in Out folder (ie, mixed) and it does
// store Bcc: header in the msg itself.
nsMsgDeliverMode mode = nsIMsgSend::nsMsgDeliverNow;
nsAutoString from, to, cc, bcc;
rv = m_pMsgFields->GetFrom(from);
rv = m_pMsgFields->GetTo(to);
rv = m_pMsgFields->GetCc(cc);
rv = m_pMsgFields->GetBcc(bcc);
if ( from.IsEmpty() || to.IsEmpty() && cc.IsEmpty() && bcc.IsEmpty() )
mode = nsIMsgSend::nsMsgSaveAsDraft;
// We only get the editor interface when there's embedded content.
// Otherwise pEditor remains NULL. That way we only import with the pseudo
// editor when it helps.
nsRefPtr<nsEudoraEditor> pEudoraEditor = new nsEudoraEditor(m_pBody, pMailImportLocation);
nsCOMPtr<nsIEditor> pEditor;
if (pEudoraEditor->HasEmbeddedContent())
// There's embedded content that we need to import, so query for the editor interface
pEudoraEditor->QueryInterface( NS_GET_IID(nsIEditor), getter_AddRefs(pEditor) );
if (NS_FAILED( rv)) {
rv = m_pSendProxy->CreateAndSendMessage(
pEditor.get(), // pseudo editor shell when there's embedded content
s_pIdentity, // dummy identity
nsnull, // account key
m_pMsgFields, // message fields
PR_FALSE, // digest = NO
PR_TRUE, // dont_deliver = YES, make a file
mode, // mode
nsnull, // no message to replace
pMimeType, // body type
m_pBody, // body pointer
m_bodyLen, // body length
nsnull, // remote attachment data
pAttach, // local attachments
nsnull, // related part
nsnull, // parent window
nsnull, // progress listener
m_pListener, // listener
nsnull, // password
EmptyCString(), // originalMsgURI
nsnull); // message compose type
}
else {
rv = m_pSendProxy->CreateAndSendMessage(
pEditor.get(), // pseudo editor shell when there's embedded content
s_pIdentity, // dummy identity
nsnull, // account key
m_pMsgFields, // message fields
PR_FALSE, // digest = NO
PR_TRUE, // dont_deliver = YES, make a file
mode, // mode
nsnull, // no message to replace
pMimeType, // body type
body.get(), // body pointer
body.Length(), // body length
nsnull, // remote attachment data
pAttach, // local attachments
nsnull, // related part
nsnull, // parent window
nsnull, // progress listener
m_pListener, // listener
nsnull, // password
EmptyCString(), // originalMsgURI
nsnull); // message compose type
}
// IMPORT_LOG0( "Returned from CreateAndSendMessage\n");
if (pAttach)
delete [] pAttach;
EudoraSendListener *pListen = (EudoraSendListener *)m_pListener;
if (NS_FAILED( rv)) {
IMPORT_LOG1( "*** Error, CreateAndSendMessage FAILED: 0x%lx\n", rv);
// IMPORT_LOG1( "Headers: %80s\n", m_pHeaders);
}
else {
// wait for the listener to get done!
PRInt32 abortCnt = 0;
PRInt32 cnt = 0;
PRInt32 sleepCnt = 1;
while (!pListen->m_done && (abortCnt < kHungAbortCount)) {
PR_Sleep( sleepCnt);
cnt++;
if (cnt > kHungCount) {
abortCnt++;
sleepCnt *= 2;
cnt = 0;
}
}
if (abortCnt >= kHungAbortCount) {
IMPORT_LOG0( "**** Create and send message hung\n");
IMPORT_LOG1( "Headers: %s\n", m_pHeaders);
IMPORT_LOG1( "Body: %s\n", m_pBody);
rv = NS_ERROR_FAILURE;
}
}
if (pMimeType)
NS_Free( pMimeType);
if (pListen->m_location) {
pListen->m_location->Clone(pMsg);
rv = NS_OK;
}
else {
rv = NS_ERROR_FAILURE;
IMPORT_LOG0( "*** Error, Outlook compose unsuccessful\n");
}
pListen->Reset();
return( rv);
}
/*
This is where the real work happens!
Go through the field map and set the data in a new database row
*/
nsresult nsTextAddress::ProcessLine( const char *pLine, PRInt32 len, nsString& errors)
{
if (!m_fieldMap) {
IMPORT_LOG0( "*** Error, text import needs a field map\n");
return( NS_ERROR_FAILURE);
}
nsresult rv;
// Wait until we get our first non-empty field, then create a new row,
// fill in the data, then add the row to the database.
nsIMdbRow * newRow = nsnull;
nsString uVal;
nsCString fieldVal;
PRInt32 fieldNum;
PRInt32 numFields = 0;
PRBool active;
rv = m_fieldMap->GetMapSize( &numFields);
for (PRInt32 i = 0; (i < numFields) && NS_SUCCEEDED( rv); i++) {
active = PR_FALSE;
rv = m_fieldMap->GetFieldMap( i, &fieldNum);
if (NS_SUCCEEDED( rv))
rv = m_fieldMap->GetFieldActive( i, &active);
if (NS_SUCCEEDED( rv) && active) {
if (GetField( pLine, len, i, fieldVal, m_delim)) {
if (!fieldVal.IsEmpty()) {
if (!newRow) {
rv = m_database->GetNewRow( &newRow);
if (NS_FAILED( rv)) {
IMPORT_LOG0( "*** Error getting new address database row\n");
}
}
if (newRow) {
NS_CopyNativeToUnicode( fieldVal, uVal);
rv = m_fieldMap->SetFieldValue( m_database, newRow, fieldNum, uVal.get());
}
}
}
else
break;
}
else {
if (active) {
IMPORT_LOG1( "*** Error getting field map for index %ld\n", (long) i);
}
}
}
if (NS_SUCCEEDED( rv)) {
if (newRow) {
rv = m_database->AddCardRowToDB( newRow);
// Release newRow????
}
}
else {
// Release newRow??
}
return( rv);
}
void OutlookSettings::SetIdentities(nsIMsgAccountManager *aMgr,
nsIMsgAccount *aAcc,
nsIWindowsRegKey *aKey)
{
// Get the relevant information for an identity
nsAutoString name;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP Display Name"), name);
nsAutoString server;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP Server"), server);
nsAutoString email;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP Email Address"), email);
nsAutoString reply;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP Reply To Email Address"), reply);
nsAutoString userName;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP User Name"), userName);
nsAutoString orgName;
aKey->ReadStringValue(NS_LITERAL_STRING("SMTP Organization Name"), orgName);
nsresult rv;
nsCOMPtr<nsIMsgIdentity> id;
if (!email.IsEmpty() && !name.IsEmpty() && !server.IsEmpty()) {
// The default identity, nor any other identities matched,
// create a new one and add it to the account.
rv = aMgr->CreateIdentity(getter_AddRefs(id));
if (id) {
id->SetFullName(name);
id->SetIdentityName(name);
id->SetOrganization(orgName);
nsCAutoString nativeEmail;
NS_CopyUnicodeToNative(email, nativeEmail);
id->SetEmail(nativeEmail);
if (!reply.IsEmpty()) {
nsCAutoString nativeReply;
NS_CopyUnicodeToNative(reply, nativeReply);
id->SetReplyTo(nativeReply);
}
aAcc->AddIdentity(id);
nsCAutoString nativeName;
NS_CopyUnicodeToNative(name, nativeName);
IMPORT_LOG0("Created identity and added to the account\n");
IMPORT_LOG1("\tname: %s\n", nativeName.get());
IMPORT_LOG1("\temail: %s\n", nativeEmail.get());
}
}
if (userName.IsEmpty()) {
nsCOMPtr<nsIMsgIncomingServer> incomingServer;
rv = aAcc->GetIncomingServer(getter_AddRefs(incomingServer));
if (NS_SUCCEEDED(rv) && incomingServer) {
nsCAutoString nativeUserName;
rv = incomingServer->GetUsername(nativeUserName);
NS_ASSERTION(NS_SUCCEEDED(rv), "Unable to get UserName from incomingServer");
NS_CopyNativeToUnicode(nativeUserName, userName);
}
}
SetSmtpServer(aMgr, aAcc, id, server, userName);
}
int
nsMsgSendPart::Write()
{
int status = 0;
char *separator = nsnull;
PRBool needToWriteCRLFAfterEncodedBody = PR_FALSE;
#define PUSHLEN(str, length) \
do { \
status = mime_write_message_body(m_state, str, length); \
if (status < 0) goto FAIL; \
} while (0) \
#define PUSH(str) PUSHLEN(str, PL_strlen(str))
// rhp: Suppress the output of parts that are empty!
if ( (m_parent) &&
(m_numchildren == 0) &&
( (!m_buffer) || (!*m_buffer) ) &&
(!m_filespec) &&
(!m_mainpart) )
return SKIP_EMPTY_PART;
if (m_mainpart && m_type && PL_strcmp(m_type, TEXT_HTML) == 0)
{
if (m_filespec)
{
// The "insert HTML links" code requires a memory buffer,
// so read the file into memory.
NS_ASSERTION(m_buffer == nsnull, "not-null buffer");
PRInt32 length = 0;
if (m_filespec->Valid())
length = m_filespec->GetFileSize();
m_buffer = (char *) PR_Malloc(sizeof(char) * (length + 1));
if (m_buffer)
{
nsInputFileStream file(*m_filespec);
if (file.is_open())
{
length = file.read(m_buffer, length);
file.close();
m_buffer[length] = '\0';
}
else
PR_Free(m_buffer);
}
}
}
if (m_parent && m_parent->m_type &&
!PL_strcasecmp(m_parent->m_type, MULTIPART_DIGEST) &&
m_type &&
(!PL_strcasecmp(m_type, MESSAGE_RFC822) ||
!PL_strcasecmp(m_type, MESSAGE_NEWS)))
{
// If we're in a multipart/digest, and this document is of type
// message/rfc822, then it's appropriate to emit no headers.
//
}
else
{
char *message_headers = 0;
char *content_headers = 0;
char *content_type_header = 0;
status = divide_content_headers(m_other,
&message_headers,
&content_headers,
&content_type_header);
if (status < 0)
goto FAIL;
/* First, write out all of the headers that refer to the message
itself (From, Subject, MIME-Version, etc.)
*/
if (message_headers)
{
PUSH(message_headers);
PR_Free(message_headers);
message_headers = 0;
}
/* Now allow the crypto library to (potentially) insert some text
(it may want to wrap the body in an envelope.) */
if (!m_parent) {
status = m_state->BeginCryptoEncapsulation();
if (status < 0) goto FAIL;
}
/* Now make sure there's a Content-Type header.
*/
if (!content_type_header)
{
NS_ASSERTION(m_type && *m_type, "null ptr");
PRBool needsCharset = mime_type_needs_charset(m_type ? m_type : TEXT_PLAIN);
if (needsCharset)
{
content_type_header = PR_smprintf("Content-Type: %s; charset=%s" CRLF,
(m_type ? m_type : TEXT_PLAIN), m_charset_name);
}
else
content_type_header = PR_smprintf("Content-Type: %s" CRLF,
(m_type ? m_type : TEXT_PLAIN));
if (!content_type_header)
{
if (content_headers)
PR_Free(content_headers);
status = NS_ERROR_OUT_OF_MEMORY;
goto FAIL;
}
}
/* If this is a compound object, tack a boundary string onto the
Content-Type header. this
*/
if (m_numchildren > 0)
{
int L;
char *ct2;
NS_ASSERTION(m_type, "null ptr");
if (!separator)
{
separator = mime_make_separator("");
if (!separator)
{
status = NS_ERROR_OUT_OF_MEMORY;
goto FAIL;
}
}
L = PL_strlen(content_type_header);
if (content_type_header[L-1] == nsCRT::LF)
content_type_header[--L] = 0;
if (content_type_header[L-1] == nsCRT::CR)
content_type_header[--L] = 0;
ct2 = PR_smprintf("%s;\r\n boundary=\"%s\"" CRLF, content_type_header, separator);
PR_Free(content_type_header);
if (!ct2)
{
if (content_headers)
PR_Free(content_headers);
status = NS_ERROR_OUT_OF_MEMORY;
goto FAIL;
}
content_type_header = ct2;
}
// Now write out the Content-Type header...
NS_ASSERTION(content_type_header && *content_type_header, "null ptr");
PUSH(content_type_header);
PR_Free(content_type_header);
content_type_header = 0;
/* ...followed by all of the other headers that refer to the body of
the message (Content-Transfer-Encoding, Content-Dispositon, etc.)
*/
if (content_headers)
{
PUSH(content_headers);
PR_Free(content_headers);
content_headers = 0;
}
}
PUSH(CRLF); // A blank line, to mark the end of headers.
m_firstBlock = PR_TRUE;
/* only convert if we need to tag charset */
m_needIntlConversion = mime_type_needs_charset(m_type);
if (m_buffer)
{
status = PushBody(m_buffer, PL_strlen(m_buffer));
if (status < 0)
goto FAIL;
}
else if (m_filespec)
{
nsInputFileStream myStream(*m_filespec);
if (!myStream.is_open())
{
// mysteriously disappearing?
nsCOMPtr<nsIMsgSendReport> sendReport;
m_state->GetSendReport(getter_AddRefs(sendReport));
if (sendReport)
{
nsAutoString error_msg;
nsAutoString path;
NS_CopyNativeToUnicode(
nsDependentCString(m_filespec->GetNativePathCString()), path);
nsMsgBuildErrorMessageByID(NS_MSG_UNABLE_TO_OPEN_TMP_FILE, error_msg, &path, nsnull);
sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), PR_FALSE);
}
status = NS_MSG_UNABLE_TO_OPEN_TMP_FILE;
goto FAIL;
}
/* Kludge to avoid having to allocate memory on the toy computers... */
if (!mime_mailto_stream_read_buffer)
{
mime_mailto_stream_read_buffer = (char *) PR_Malloc(MIME_BUFFER_SIZE);
if (!mime_mailto_stream_read_buffer)
{
status = NS_ERROR_OUT_OF_MEMORY;
goto FAIL;
}
}
char *buffer = mime_mailto_stream_read_buffer;
if (m_strip_sensitive_headers)
{
// We are attaching a message, so we should be careful to
// strip out certain sensitive internal header fields.
PRBool skipping = PR_FALSE;
while (1)
{
char *line;
if (myStream.eof())
line = nsnull;
else
{
buffer[0] = '\0';
myStream.readline(buffer, MIME_BUFFER_SIZE-3);
line = buffer;
}
if (!line)
break; /* EOF */
if (skipping) {
if (*line == ' ' || *line == '\t')
continue;
else
skipping = PR_FALSE;
}
int hdrLen = PL_strlen(buffer);
if ((hdrLen < 2) || (buffer[hdrLen-2] != nsCRT::CR)) { // if the line doesn't end with CRLF,
// ... make it end with CRLF.
if ( (hdrLen == 0) || ((buffer[hdrLen-1] != nsCRT::CR) && (buffer[hdrLen-1] != nsCRT::LF)) )
hdrLen++;
buffer[hdrLen-1] = '\015';
buffer[hdrLen] = '\012';
buffer[hdrLen+1] = '\0';
}
if (!PL_strncasecmp(line, "From -", 6) ||
!PL_strncasecmp(line, "BCC:", 4) ||
!PL_strncasecmp(line, "FCC:", 4) ||
!PL_strncasecmp(line, CONTENT_LENGTH ":", CONTENT_LENGTH_LEN+1) ||
!PL_strncasecmp(line, "Lines:", 6) ||
!PL_strncasecmp(line, "Status:", 7) ||
!PL_strncasecmp(line, X_MOZILLA_STATUS ":", X_MOZILLA_STATUS_LEN+1) ||
!PL_strncasecmp(line, X_MOZILLA_STATUS2 ":", X_MOZILLA_STATUS2_LEN+1) ||
!PL_strncasecmp(line, X_MOZILLA_DRAFT_INFO ":", X_MOZILLA_DRAFT_INFO_LEN+1) ||
!PL_strncasecmp(line, X_MOZILLA_NEWSHOST ":", X_MOZILLA_NEWSHOST_LEN+1) ||
!PL_strncasecmp(line, X_UIDL ":", X_UIDL_LEN+1) ||
!PL_strncasecmp(line, "X-VM-", 5)) /* hi Kyle */
{
skipping = PR_TRUE;
continue;
}
PUSH(line);
if (*line == nsCRT::CR || *line == nsCRT::LF) {
break; // Now can do normal reads for the body.
}
}
}
while (!myStream.eof())
{
if ((status = myStream.read(buffer, MIME_BUFFER_SIZE)) < 0)
{
nsCOMPtr<nsIMsgSendReport> sendReport;
m_state->GetSendReport(getter_AddRefs(sendReport));
if (sendReport)
{
nsAutoString error_msg;
nsAutoString path;
NS_CopyNativeToUnicode(nsDependentCString(m_filespec->GetNativePathCString()), path);
nsMsgBuildErrorMessageByID(NS_MSG_UNABLE_TO_OPEN_FILE, error_msg, &path, nsnull);
sendReport->SetMessage(nsIMsgSendReport::process_Current, error_msg.get(), PR_FALSE);
status = NS_MSG_UNABLE_TO_OPEN_FILE;
goto FAIL;
}
}
status = PushBody(buffer, status);
if (status < 0)
goto FAIL;
}
}
if (m_encoder_data)
{
status = MIME_EncoderDestroy(m_encoder_data, PR_FALSE);
m_encoder_data = nsnull;
needToWriteCRLFAfterEncodedBody = !m_parent;
if (status < 0)
goto FAIL;
}
//
// Ok, from here we loop and drive the the output of all children
// for this message.
//
if (m_numchildren > 0)
{
PRBool writeSeparator = PR_TRUE;
for (int i = 0 ; i < m_numchildren ; i ++)
{
if (writeSeparator)
{
PUSH(CRLF);
PUSH("--");
PUSH(separator);
PUSH(CRLF);
}
status = m_children[i]->Write();
if (status < 0)
goto FAIL;
if (status == SKIP_EMPTY_PART)
writeSeparator = PR_FALSE;
else
writeSeparator = PR_TRUE;
}
PUSH(CRLF);
PUSH("--");
PUSH(separator);
PUSH("--");
PUSH(CRLF);
}
else if (needToWriteCRLFAfterEncodedBody)
PUSH(CRLF);
FAIL:
PR_FREEIF(separator);
return status;
}