From 302bf1b523012e11b60425d6eee1221ebc2724eb Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Sun, 3 Nov 2019 00:17:46 -0400 Subject: Issue #1258 - Part 1: Import mailnews, ldap, and mork from comm-esr52.9.1 --- mailnews/mapi/mapihook/src/Makefile.in | 6 + mailnews/mapi/mapihook/src/Registry.cpp | 291 +++++++++ mailnews/mapi/mapihook/src/Registry.h | 23 + mailnews/mapi/mapihook/src/moz.build | 25 + mailnews/mapi/mapihook/src/msgMapiFactory.cpp | 85 +++ mailnews/mapi/mapihook/src/msgMapiFactory.h | 39 ++ mailnews/mapi/mapihook/src/msgMapiHook.cpp | 829 ++++++++++++++++++++++++ mailnews/mapi/mapihook/src/msgMapiHook.h | 33 + mailnews/mapi/mapihook/src/msgMapiImp.cpp | 878 ++++++++++++++++++++++++++ mailnews/mapi/mapihook/src/msgMapiImp.h | 77 +++ mailnews/mapi/mapihook/src/msgMapiMain.cpp | 306 +++++++++ mailnews/mapi/mapihook/src/msgMapiMain.h | 86 +++ mailnews/mapi/mapihook/src/msgMapiSupport.cpp | 151 +++++ mailnews/mapi/mapihook/src/msgMapiSupport.h | 34 + 14 files changed, 2863 insertions(+) create mode 100644 mailnews/mapi/mapihook/src/Makefile.in create mode 100644 mailnews/mapi/mapihook/src/Registry.cpp create mode 100644 mailnews/mapi/mapihook/src/Registry.h create mode 100644 mailnews/mapi/mapihook/src/moz.build create mode 100644 mailnews/mapi/mapihook/src/msgMapiFactory.cpp create mode 100644 mailnews/mapi/mapihook/src/msgMapiFactory.h create mode 100644 mailnews/mapi/mapihook/src/msgMapiHook.cpp create mode 100644 mailnews/mapi/mapihook/src/msgMapiHook.h create mode 100644 mailnews/mapi/mapihook/src/msgMapiImp.cpp create mode 100644 mailnews/mapi/mapihook/src/msgMapiImp.h create mode 100644 mailnews/mapi/mapihook/src/msgMapiMain.cpp create mode 100644 mailnews/mapi/mapihook/src/msgMapiMain.h create mode 100644 mailnews/mapi/mapihook/src/msgMapiSupport.cpp create mode 100644 mailnews/mapi/mapihook/src/msgMapiSupport.h (limited to 'mailnews/mapi/mapihook/src') diff --git a/mailnews/mapi/mapihook/src/Makefile.in b/mailnews/mapi/mapihook/src/Makefile.in new file mode 100644 index 000000000..10e6172bf --- /dev/null +++ b/mailnews/mapi/mapihook/src/Makefile.in @@ -0,0 +1,6 @@ +# +# 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/. + +CSRCS += ../build/msgMapi_i.c diff --git a/mailnews/mapi/mapihook/src/Registry.cpp b/mailnews/mapi/mapihook/src/Registry.cpp new file mode 100644 index 000000000..31db7520b --- /dev/null +++ b/mailnews/mapi/mapihook/src/Registry.cpp @@ -0,0 +1,291 @@ +/* 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/. */ + +#undef _UNICODE +#undef UNICODE + +#include +#include "nsStringGlue.h" +#include "Registry.h" + +#define MAPI_PROXY_DLL_NAME "MapiProxy.dll" +#define MAPI_STARTUP_ARG " /MAPIStartUp" +#define MAX_SIZE 2048 + +// Size of a CLSID as a string +const int CLSID_STRING_SIZE = 39; + +// Proxy/Stub Dll Routines + +typedef HRESULT (__stdcall ProxyServer)(); + + +// Convert a CLSID to a char string. + +BOOL CLSIDtochar(const CLSID& clsid, char* szCLSID, + int length) +{ + LPOLESTR wszCLSID = NULL; + + // Get CLSID + HRESULT hr = StringFromCLSID(clsid, &wszCLSID); + if (FAILED(hr)) + return FALSE; + + // Covert from wide characters to non-wide. + wcstombs(szCLSID, wszCLSID, length); + + // Free memory. + CoTaskMemFree(wszCLSID); + + return TRUE; +} + +// Create a key and set its value. + +BOOL setKeyAndValue(nsAutoCString keyName, const char* subKey, + const char* theValue) +{ + HKEY hKey; + BOOL retValue = TRUE; + + nsAutoCString theKey(keyName); + if (subKey != NULL) + { + theKey += "\\"; + theKey += subKey; + } + + // Create and open key and subkey. + long lResult = RegCreateKeyEx(HKEY_CLASSES_ROOT, theKey.get(), + 0, NULL, REG_OPTION_NON_VOLATILE, + KEY_ALL_ACCESS, NULL, &hKey, NULL); + if (lResult != ERROR_SUCCESS) + return FALSE ; + + // Set the Value. + if (theValue != NULL) + { + lResult = RegSetValueEx(hKey, NULL, 0, REG_SZ, (BYTE *)theValue, + strlen(theValue)+1); + if (lResult != ERROR_SUCCESS) + retValue = FALSE; + } + + RegCloseKey(hKey); + return TRUE; +} + +// Delete a key and all of its descendents. + +LONG recursiveDeleteKey(HKEY hKeyParent, // Parent of key to delete + const char* lpszKeyChild) // Key to delete +{ + // Open the child. + HKEY hKeyChild ; + LONG lRes = RegOpenKeyEx(hKeyParent, lpszKeyChild, 0, + KEY_ALL_ACCESS, &hKeyChild) ; + if (lRes != ERROR_SUCCESS) + { + return lRes ; + } + + // Enumerate all of the decendents of this child. + FILETIME time ; + char szBuffer[MAX_SIZE] ; + DWORD dwSize = MAX_SIZE ; + while (RegEnumKeyEx(hKeyChild, 0, szBuffer, &dwSize, NULL, + NULL, NULL, &time) == S_OK) + { + // Delete the decendents of this child. + lRes = recursiveDeleteKey(hKeyChild, szBuffer) ; + if (lRes != ERROR_SUCCESS) + { + // Cleanup before exiting. + RegCloseKey(hKeyChild) ; + return lRes; + } + dwSize = MAX_SIZE; + } + + // Close the child. + RegCloseKey(hKeyChild) ; + + // Delete this child. + return RegDeleteKey(hKeyParent, lpszKeyChild) ; +} + +void RegisterProxy() +{ + HINSTANCE h = NULL; + ProxyServer *RegisterFunc = NULL; + + char szModule[MAX_SIZE]; + char *pTemp = NULL; + + HMODULE hModule = GetModuleHandle(NULL); + DWORD dwResult = ::GetModuleFileName(hModule, szModule, + sizeof(szModule)/sizeof(char)); + if (dwResult == 0) + return; + + pTemp = strrchr(szModule, '\\'); + if (pTemp == NULL) + return; + + *pTemp = '\0'; + nsAutoCString proxyPath(szModule); + + proxyPath += "\\"; + proxyPath += MAPI_PROXY_DLL_NAME; + + h = LoadLibrary(proxyPath.get()); + if (h == NULL) + return; + + RegisterFunc = (ProxyServer *) GetProcAddress(h, "DllRegisterServer"); + if (RegisterFunc) + RegisterFunc(); + + FreeLibrary(h); +} + +void UnRegisterProxy() +{ + HINSTANCE h = NULL; + ProxyServer *UnRegisterFunc = NULL; + + char szModule[MAX_SIZE]; + char *pTemp = NULL; + + HMODULE hModule = GetModuleHandle(NULL); + DWORD dwResult = ::GetModuleFileName(hModule, szModule, + sizeof(szModule)/sizeof(char)); + if (dwResult == 0) + return; + + pTemp = strrchr(szModule, '\\'); + if (pTemp == NULL) + return; + + *pTemp = '\0'; + nsAutoCString proxyPath(szModule); + + proxyPath += "\\"; + proxyPath += MAPI_PROXY_DLL_NAME; + + h = LoadLibrary(proxyPath.get()); + if (h == NULL) + return; + + UnRegisterFunc = (ProxyServer *) GetProcAddress(h, "DllUnregisterServer"); + if (UnRegisterFunc) + UnRegisterFunc(); + + FreeLibrary(h); +} + +// Register the component in the registry. + +HRESULT RegisterServer(const CLSID& clsid, // Class ID + const char* szFriendlyName, // Friendly Name + const char* szVerIndProgID, // Programmatic + const char* szProgID) // IDs +{ + HMODULE hModule = GetModuleHandle(NULL); + char szModuleName[MAX_SIZE]; + char szCLSID[CLSID_STRING_SIZE]; + + nsAutoCString independentProgId(szVerIndProgID); + nsAutoCString progId(szProgID); + + DWORD dwResult = ::GetModuleFileName(hModule, szModuleName, + sizeof(szModuleName)/sizeof(char)); + + if (dwResult == 0) + return S_FALSE; + + nsAutoCString moduleName(szModuleName); + nsAutoCString registryKey("CLSID\\"); + + moduleName += MAPI_STARTUP_ARG; + + // Convert the CLSID into a char. + + if (!CLSIDtochar(clsid, szCLSID, sizeof(szCLSID))) + return S_FALSE; + registryKey += szCLSID; + + // Add the CLSID to the registry. + if (!setKeyAndValue(registryKey, NULL, szFriendlyName)) + return S_FALSE; + + if (!setKeyAndValue(registryKey, "LocalServer32", moduleName.get())) + return S_FALSE; + + // Add the ProgID subkey under the CLSID key. + if (!setKeyAndValue(registryKey, "ProgID", szProgID)) + return S_FALSE; + + // Add the version-independent ProgID subkey under CLSID key. + if (!setKeyAndValue(registryKey, "VersionIndependentProgID", szVerIndProgID)) + return S_FALSE; + + // Add the version-independent ProgID subkey under HKEY_CLASSES_ROOT. + if (!setKeyAndValue(independentProgId, NULL, szFriendlyName)) + return S_FALSE; + if (!setKeyAndValue(independentProgId, "CLSID", szCLSID)) + return S_FALSE; + if (!setKeyAndValue(independentProgId, "CurVer", szProgID)) + return S_FALSE; + + // Add the versioned ProgID subkey under HKEY_CLASSES_ROOT. + if (!setKeyAndValue(progId, NULL, szFriendlyName)) + return S_FALSE; + if (!setKeyAndValue(progId, "CLSID", szCLSID)) + return S_FALSE; + + RegisterProxy(); + + return S_OK; +} + +LONG UnregisterServer(const CLSID& clsid, // Class ID + const char* szVerIndProgID, // Programmatic + const char* szProgID) // IDs +{ + LONG lResult = S_OK; + + // Convert the CLSID into a char. + + char szCLSID[CLSID_STRING_SIZE]; + if (!CLSIDtochar(clsid, szCLSID, sizeof(szCLSID))) + return S_FALSE; + + UnRegisterProxy(); + + nsAutoCString registryKey("CLSID\\"); + registryKey += szCLSID; + + lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, registryKey.get()); + if (lResult == ERROR_SUCCESS || lResult == ERROR_FILE_NOT_FOUND) + return lResult; + + registryKey += "\\LocalServer32"; + + // Delete only the path for this server. + + lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, registryKey.get()); + if (lResult != ERROR_SUCCESS && lResult != ERROR_FILE_NOT_FOUND) + return lResult; + + // Delete the version-independent ProgID Key. + lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szVerIndProgID); + if (lResult != ERROR_SUCCESS && lResult != ERROR_FILE_NOT_FOUND) + return lResult; + + lResult = recursiveDeleteKey(HKEY_CLASSES_ROOT, szProgID); + + return lResult; +} diff --git a/mailnews/mapi/mapihook/src/Registry.h b/mailnews/mapi/mapihook/src/Registry.h new file mode 100644 index 000000000..34a4efca7 --- /dev/null +++ b/mailnews/mapi/mapihook/src/Registry.h @@ -0,0 +1,23 @@ +/* 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/. */ + +#ifndef _REGISTRY_H_ +#define _REGISTRY_H_ + +#include + +// This function will register a component in the Registry. + +HRESULT RegisterServer(const CLSID& clsid, + const char* szFriendlyName, + const char* szVerIndProgID, + const char* szProgID) ; + +// This function will unregister a component. + +HRESULT UnregisterServer(const CLSID& clsid, + const char* szVerIndProgID, + const char* szProgID) ; + +#endif diff --git a/mailnews/mapi/mapihook/src/moz.build b/mailnews/mapi/mapihook/src/moz.build new file mode 100644 index 000000000..3e8cd3450 --- /dev/null +++ b/mailnews/mapi/mapihook/src/moz.build @@ -0,0 +1,25 @@ +# vim: set filetype=python: +# 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/. + +SOURCES += [ + 'msgMapiFactory.cpp', + 'msgMapiHook.cpp', + 'msgMapiImp.cpp', + 'msgMapiMain.cpp', + 'msgMapiSupport.cpp', + 'Registry.cpp', +] + +if CONFIG['MOZ_INCOMPLETE_EXTERNAL_LINKAGE']: + XPCOMBinaryComponent('msgMapi') +else: + FINAL_LIBRARY = 'xul' + +OS_LIBS += [ + 'ole32', +] + +DEFINES['UNICODE'] = True +DEFINES['_UNICODE'] = True diff --git a/mailnews/mapi/mapihook/src/msgMapiFactory.cpp b/mailnews/mapi/mapihook/src/msgMapiFactory.cpp new file mode 100644 index 000000000..829279f62 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiFactory.cpp @@ -0,0 +1,85 @@ +/* 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/. */ + +#undef UNICODE +#undef _UNICODE + +#include "msgMapiFactory.h" +#include "msgMapiImp.h" +#include "msgMapi.h" + +CMapiFactory ::CMapiFactory() +: m_cRef(1) +{ +} + +CMapiFactory::~CMapiFactory() +{ +} + +STDMETHODIMP CMapiFactory::QueryInterface(const IID& aIid, void** aPpv) +{ + if ((aIid == IID_IUnknown) || (aIid == IID_IClassFactory)) + { + *aPpv = static_cast(this); + } + else + { + *aPpv = nullptr; + return E_NOINTERFACE; + } + reinterpret_cast(*aPpv)->AddRef(); + return S_OK; +} + +STDMETHODIMP_(ULONG) CMapiFactory::AddRef() +{ + return ++m_cRef; +} + +STDMETHODIMP_(ULONG) CMapiFactory::Release() +{ + int32_t temp = --m_cRef; + if (m_cRef == 0) + { + delete this; + return 0; + } + + return temp; +} + +STDMETHODIMP CMapiFactory::CreateInstance(IUnknown* aUnknownOuter, + const IID& aIid, + void** aPpv) +{ + // Cannot aggregate. + + if (aUnknownOuter != nullptr) + { + return CLASS_E_NOAGGREGATION ; + } + + // Create component. + + CMapiImp* pImp = new CMapiImp(); + if (pImp == nullptr) + { + return E_OUTOFMEMORY ; + } + + // Get the requested interface. + HRESULT hr = pImp->QueryInterface(aIid, aPpv); + + // Release the IUnknown pointer. + // (If QueryInterface failed, component will delete itself.) + + pImp->Release(); + return hr; +} + +STDMETHODIMP CMapiFactory::LockServer(BOOL aLock) +{ + return S_OK ; +} diff --git a/mailnews/mapi/mapihook/src/msgMapiFactory.h b/mailnews/mapi/mapihook/src/msgMapiFactory.h new file mode 100644 index 000000000..7ae2f2ed3 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiFactory.h @@ -0,0 +1,39 @@ +/* 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/. */ + +#ifndef MSG_MAPI_FACTORY_H +#define MSG_MAPI_FACTORY_H + +#include +#include +#include "nspr.h" +#include "nsISupportsImpl.h" // ThreadSafeAutoRefCnt +#include + + +class CMapiFactory : public IClassFactory +{ +public : + + // IUnknown + + STDMETHODIMP QueryInterface (REFIID aIid, void** aPpv); + STDMETHODIMP_(ULONG) AddRef(void); + STDMETHODIMP_(ULONG) Release(void); + + // IClassFactory + + STDMETHODIMP CreateInstance (LPUNKNOWN aUnkOuter, REFIID aIid, void **aPpv); + STDMETHODIMP LockServer (BOOL aLock); + + CMapiFactory (); + +private: + mozilla::ThreadSafeAutoRefCnt m_cRef; + + ~CMapiFactory (); +}; + +#endif // MSG_MAPI_FACTORY_H + diff --git a/mailnews/mapi/mapihook/src/msgMapiHook.cpp b/mailnews/mapi/mapihook/src/msgMapiHook.cpp new file mode 100644 index 000000000..02696fe94 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiHook.cpp @@ -0,0 +1,829 @@ +/* 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/. */ + +#define MAPI_STARTUP_ARG "/MAPIStartUp" + +#include +#include +#include +#include +#include "nsCOMPtr.h" +#include "nsIComponentManager.h" +#include "nsIServiceManager.h" +#include "nsISupports.h" +#include "nsIPromptService.h" +#include "nsIAppStartup.h" +#include "nsIAppShellService.h" +#include "mozIDOMWindow.h" +#include "nsINativeAppSupport.h" +#include "nsIMsgAccountManager.h" +#include "nsMsgBaseCID.h" +#include "nsIStringBundle.h" +#include "nsIPrefService.h" +#include "nsIPrefBranch.h" +#include "nsStringGlue.h" +#include "nsUnicharUtils.h" +#include "nsIMsgAttachment.h" +#include "nsIMsgCompFields.h" +#include "nsIMsgComposeParams.h" +#include "nsIMsgCompose.h" +#include "nsMsgCompCID.h" +#include "nsIMsgSend.h" +#include "nsIMsgComposeService.h" +#include "nsDirectoryServiceDefs.h" +#include "nsIDirectoryService.h" +#include "nsMsgI18N.h" +#include "msgMapi.h" +#include "msgMapiHook.h" +#include "msgMapiSupport.h" +#include "msgMapiMain.h" +#include "nsThreadUtils.h" +#include "nsMsgUtils.h" +#include "nsNetUtil.h" +#include "mozilla/Services.h" +#include "nsIArray.h" +#include "nsArrayUtils.h" +#include "nsEmbedCID.h" +#include "mozilla/Logging.h" + +extern PRLogModuleInfo *MAPI; + +class nsMAPISendListener : public nsIMsgSendListener +{ +public: + + // nsISupports interface + NS_DECL_THREADSAFE_ISUPPORTS + + /* void OnStartSending (in string aMsgID, in uint32_t aMsgSize); */ + NS_IMETHOD OnStartSending(const char *aMsgID, uint32_t aMsgSize) { return NS_OK; } + + /* void OnProgress (in string aMsgID, in uint32_t aProgress, in uint32_t aProgressMax); */ + NS_IMETHOD OnProgress(const char *aMsgID, uint32_t aProgress, uint32_t aProgressMax) { return NS_OK;} + + /* void OnStatus (in string aMsgID, in wstring aMsg); */ + NS_IMETHOD OnStatus(const char *aMsgID, const char16_t *aMsg) { return NS_OK;} + + /* void OnStopSending (in string aMsgID, in nsresult aStatus, in wstring aMsg, in nsIFile returnFile); */ + NS_IMETHOD OnStopSending(const char *aMsgID, nsresult aStatus, const char16_t *aMsg, + nsIFile *returnFile) { + PR_CEnterMonitor(this); + PR_CNotifyAll(this); + m_done = true; + PR_CExitMonitor(this); + return NS_OK ; + } + + /* void OnSendNotPerformed */ + NS_IMETHOD OnSendNotPerformed(const char *aMsgID, nsresult aStatus) + { + return OnStopSending(aMsgID, aStatus, nullptr, nullptr) ; + } + + /* void OnGetDraftFolderURI (); */ + NS_IMETHOD OnGetDraftFolderURI(const char *aFolderURI) {return NS_OK;} + + static nsresult CreateMAPISendListener( nsIMsgSendListener **ppListener); + + bool IsDone() { return m_done ; } + +protected : + nsMAPISendListener() { + m_done = false; + } + + bool m_done; +private: + virtual ~nsMAPISendListener() { } + +}; + + +NS_IMPL_ISUPPORTS(nsMAPISendListener, nsIMsgSendListener) + +nsresult nsMAPISendListener::CreateMAPISendListener( nsIMsgSendListener **ppListener) +{ + NS_ENSURE_ARG_POINTER(ppListener) ; + + *ppListener = new nsMAPISendListener(); + if (! *ppListener) + return NS_ERROR_OUT_OF_MEMORY; + + NS_ADDREF(*ppListener); + return NS_OK; +} + +bool nsMapiHook::isMapiService = false; + +void nsMapiHook::CleanUp() +{ + // This routine will be fully implemented in future + // to cleanup mapi related stuff inside mozilla code. +} + +bool nsMapiHook::DisplayLoginDialog(bool aLogin, char16_t **aUsername, + char16_t **aPassword) +{ + nsresult rv; + bool btnResult = false; + + nsCOMPtr dlgService(do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv)); + if (NS_SUCCEEDED(rv) && dlgService) + { + nsCOMPtr bundleService = + mozilla::services::GetStringBundleService(); + if (!bundleService) return false; + + nsCOMPtr bundle; + rv = bundleService->CreateBundle(MAPI_PROPERTIES_CHROME, getter_AddRefs(bundle)); + if (NS_FAILED(rv) || !bundle) return false; + + nsCOMPtr brandBundle; + rv = bundleService->CreateBundle( + "chrome://branding/locale/brand.properties", + getter_AddRefs(brandBundle)); + if (NS_FAILED(rv)) return false; + + nsString brandName; + rv = brandBundle->GetStringFromName( + u"brandFullName", + getter_Copies(brandName)); + if (NS_FAILED(rv)) return false; + + nsString loginTitle; + const char16_t *brandStrings[] = { brandName.get() }; + NS_NAMED_LITERAL_STRING(loginTitlePropertyTag, "loginTitle"); + const char16_t *dTitlePropertyTag = loginTitlePropertyTag.get(); + rv = bundle->FormatStringFromName(dTitlePropertyTag, brandStrings, 1, + getter_Copies(loginTitle)); + if (NS_FAILED(rv)) return false; + + if (aLogin) + { + nsString loginText; + rv = bundle->GetStringFromName(u"loginTextwithName", + getter_Copies(loginText)); + if (NS_FAILED(rv) || loginText.IsEmpty()) return false; + + bool dummyValue = false; + rv = dlgService->PromptUsernameAndPassword(nullptr, loginTitle.get(), + loginText.get(), aUsername, aPassword, + nullptr, &dummyValue, &btnResult); + } + else + { + //nsString loginString; + nsString loginText; + const char16_t *userNameStrings[] = { *aUsername }; + + NS_NAMED_LITERAL_STRING(loginTextPropertyTag, "loginText"); + const char16_t *dpropertyTag = loginTextPropertyTag.get(); + rv = bundle->FormatStringFromName(dpropertyTag, userNameStrings, 1, + getter_Copies(loginText)); + if (NS_FAILED(rv)) return false; + + bool dummyValue = false; + rv = dlgService->PromptPassword(nullptr, loginTitle.get(), loginText.get(), + aPassword, nullptr, &dummyValue, &btnResult); + } + } + + return btnResult; +} + +bool nsMapiHook::VerifyUserName(const nsString& aUsername, nsCString& aIdKey) +{ + nsresult rv; + + if (aUsername.IsEmpty()) + return false; + + nsCOMPtr accountManager(do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv)); + if (NS_FAILED(rv)) return false; + nsCOMPtr identities; + rv = accountManager->GetAllIdentities(getter_AddRefs(identities)); + if (NS_FAILED(rv)) return false; + + uint32_t numIndentities = 0; + identities->GetLength(&numIndentities); + + for (uint32_t i = 0; i < numIndentities; i++) + { + nsCOMPtr thisIdentity(do_QueryElementAt(identities, i, &rv)); + if (NS_SUCCEEDED(rv) && thisIdentity) + { + nsCString email; + rv = thisIdentity->GetEmail(email); + if (NS_FAILED(rv)) continue; + + // get the username from the email and compare with the username + int32_t index = email.FindChar('@'); + if (index != -1) + email.SetLength(index); + + if (aUsername.Equals(NS_ConvertASCIItoUTF16(email))) + return NS_SUCCEEDED(thisIdentity->GetKey(aIdKey)); + } + } + + return false; +} + +bool +nsMapiHook::IsBlindSendAllowed() +{ + bool enabled = false; + bool warn = true; + nsCOMPtr prefBranch = do_GetService(NS_PREFSERVICE_CONTRACTID); + if (prefBranch) { + prefBranch->GetBoolPref(PREF_MAPI_WARN_PRIOR_TO_BLIND_SEND, &warn); + prefBranch->GetBoolPref(PREF_MAPI_BLIND_SEND_ENABLED, &enabled); + } + if (!enabled) + return false; + + if (!warn) + return true; // Everything is okay. + + nsresult rv; + nsCOMPtr bundleService = + mozilla::services::GetStringBundleService(); + if (!bundleService) return false; + + nsCOMPtr bundle; + rv = bundleService->CreateBundle(MAPI_PROPERTIES_CHROME, getter_AddRefs(bundle)); + if (NS_FAILED(rv) || !bundle) return false; + + nsString warningMsg; + rv = bundle->GetStringFromName(u"mapiBlindSendWarning", + getter_Copies(warningMsg)); + if (NS_FAILED(rv)) return false; + + nsString dontShowAgainMessage; + rv = bundle->GetStringFromName(u"mapiBlindSendDontShowAgain", + getter_Copies(dontShowAgainMessage)); + if (NS_FAILED(rv)) return false; + + nsCOMPtr dlgService(do_GetService(NS_PROMPTSERVICE_CONTRACTID, &rv)); + if (NS_FAILED(rv) || !dlgService) return false; + + bool continueToWarn = true; + bool okayToContinue = false; + dlgService->ConfirmCheck(nullptr, nullptr, warningMsg.get(), dontShowAgainMessage.get(), &continueToWarn, &okayToContinue); + + if (!continueToWarn && okayToContinue && prefBranch) + prefBranch->SetBoolPref(PREF_MAPI_WARN_PRIOR_TO_BLIND_SEND, false); + + return okayToContinue; +} + +// this is used for Send without UI +nsresult nsMapiHook::BlindSendMail (unsigned long aSession, nsIMsgCompFields * aCompFields) +{ + nsresult rv = NS_OK ; + + if (!IsBlindSendAllowed()) + return NS_ERROR_FAILURE; + + /** create nsIMsgComposeParams obj and other fields to populate it **/ + + nsCOMPtr hiddenWindow; + // get parent window + nsCOMPtr appService = do_GetService( "@mozilla.org/appshell/appShellService;1", &rv); + if (NS_FAILED(rv)|| (!appService) ) return rv ; + + rv = appService->GetHiddenDOMWindow(getter_AddRefs(hiddenWindow)); + if ( NS_FAILED(rv) ) return rv ; + // smtp password and Logged in used IdKey from MapiConfig (session obj) + nsMAPIConfiguration * pMapiConfig = nsMAPIConfiguration::GetMAPIConfiguration() ; + if (!pMapiConfig) return NS_ERROR_FAILURE ; // get the singelton obj + char16_t * password = pMapiConfig->GetPassword(aSession) ; + // password + nsAutoCString smtpPassword; + LossyCopyUTF16toASCII(password, smtpPassword); + + // Id key + nsCString MsgIdKey; + pMapiConfig->GetIdKey(aSession, MsgIdKey); + + // get the MsgIdentity for the above key using AccountManager + nsCOMPtr accountManager = do_GetService (NS_MSGACCOUNTMANAGER_CONTRACTID) ; + if (NS_FAILED(rv) || (!accountManager) ) return rv ; + + nsCOMPtr pMsgId ; + rv = accountManager->GetIdentity (MsgIdKey, getter_AddRefs(pMsgId)) ; + if (NS_FAILED(rv) ) return rv ; + + // create a send listener to get back the send status + nsCOMPtr sendListener ; + rv = nsMAPISendListener::CreateMAPISendListener(getter_AddRefs(sendListener)) ; + if (NS_FAILED(rv) || (!sendListener) ) return rv; + + // create the compose params object + nsCOMPtr pMsgComposeParams (do_CreateInstance(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv)); + if (NS_FAILED(rv) || (!pMsgComposeParams) ) return rv ; + + // populate the compose params + bool forcePlainText; + aCompFields->GetForcePlainText(&forcePlainText); + pMsgComposeParams->SetType(nsIMsgCompType::New); + pMsgComposeParams->SetFormat(forcePlainText ? nsIMsgCompFormat::PlainText : nsIMsgCompFormat::HTML); + pMsgComposeParams->SetIdentity(pMsgId); + pMsgComposeParams->SetComposeFields(aCompFields); + pMsgComposeParams->SetSendListener(sendListener) ; + pMsgComposeParams->SetSmtpPassword(smtpPassword.get()); + + // create the nsIMsgCompose object to send the object + nsCOMPtr pMsgCompose (do_CreateInstance(NS_MSGCOMPOSE_CONTRACTID, &rv)); + if (NS_FAILED(rv) || (!pMsgCompose) ) return rv ; + + /** initialize nsIMsgCompose, Send the message, wait for send completion response **/ + + rv = pMsgCompose->Initialize(pMsgComposeParams, hiddenWindow, nullptr); + if (NS_FAILED(rv)) return rv ; + + // If we're in offline mode, we'll need to queue it for later. No point in trying to send it. + return pMsgCompose->SendMsg(WeAreOffline() ? nsIMsgSend::nsMsgQueueForLater : nsIMsgSend::nsMsgDeliverNow, + pMsgId, nullptr, nullptr, nullptr); + if (NS_FAILED(rv)) return rv ; + + // assign to interface pointer from nsCOMPtr to facilitate typecast below + nsIMsgSendListener * pSendListener = sendListener ; + + // we need to wait here to make sure that we return only after send is completed + // so we will have a event loop here which will process the events till the Send IsDone. + nsCOMPtr thread(do_GetCurrentThread()); + while ( !((nsMAPISendListener *) pSendListener)->IsDone() ) + { + PR_CEnterMonitor(pSendListener); + PR_CWait(pSendListener, PR_MicrosecondsToInterval(1000UL)); + PR_CExitMonitor(pSendListener); + NS_ProcessPendingEvents(thread); + } + + return rv ; +} + +// this is used to populate comp fields with Unicode data +nsresult nsMapiHook::PopulateCompFields(lpnsMapiMessage aMessage, + nsIMsgCompFields * aCompFields) +{ + nsresult rv = NS_OK ; + + if (aMessage->lpOriginator) + aCompFields->SetFrom (NS_ConvertASCIItoUTF16((char *) aMessage->lpOriginator->lpszAddress)); + + nsAutoString To ; + nsAutoString Cc ; + nsAutoString Bcc ; + + NS_NAMED_LITERAL_STRING(Comma, ","); + + if (aMessage->lpRecips) + { + for (int i=0 ; i < (int) aMessage->nRecipCount ; i++) + { + if (aMessage->lpRecips[i].lpszAddress || aMessage->lpRecips[i].lpszName) + { + const char *addressWithoutType = (aMessage->lpRecips[i].lpszAddress) + ? aMessage->lpRecips[i].lpszAddress : aMessage->lpRecips[i].lpszName; + if (!PL_strncasecmp(addressWithoutType, "SMTP:", 5)) + addressWithoutType += 5; + switch (aMessage->lpRecips[i].ulRecipClass) + { + case MAPI_TO : + if (!To.IsEmpty()) + To += Comma; + To.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break; + + case MAPI_CC : + if (!Cc.IsEmpty()) + Cc += Comma; + Cc.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break; + + case MAPI_BCC : + if (!Bcc.IsEmpty()) + Bcc += Comma; + Bcc.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break; + } + } + } + } + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("to: %s cc: %s bcc: %s \n", NS_ConvertUTF16toUTF8(To).get(), NS_ConvertUTF16toUTF8(Cc).get(), NS_ConvertUTF16toUTF8(Bcc).get())); + // set To, Cc, Bcc + aCompFields->SetTo (To) ; + aCompFields->SetCc (Cc) ; + aCompFields->SetBcc (Bcc) ; + + // set subject + if (aMessage->lpszSubject) + aCompFields->SetSubject(NS_ConvertASCIItoUTF16(aMessage->lpszSubject)); + + // handle attachments as File URL + rv = HandleAttachments (aCompFields, aMessage->nFileCount, aMessage->lpFiles, true) ; + if (NS_FAILED(rv)) return rv ; + + // set body + if (aMessage->lpszNoteText) + { + nsString Body; + CopyASCIItoUTF16(aMessage->lpszNoteText, Body); + if (Body.IsEmpty() || Body.Last() != '\n') + Body.AppendLiteral(CRLF); + + // This is needed when Simple MAPI is used without a compose window. + // See bug 1366196. + if (Body.Find("") == kNotFound) + aCompFields->SetForcePlainText(true); + + rv = aCompFields->SetBody(Body) ; + } + return rv ; +} + +nsresult nsMapiHook::HandleAttachments (nsIMsgCompFields * aCompFields, int32_t aFileCount, + lpnsMapiFileDesc aFiles, BOOL aIsUnicode) +{ + nsresult rv = NS_OK ; + + nsAutoCString Attachments ; + nsAutoCString TempFiles ; + + nsCOMPtr pFile = do_CreateInstance (NS_LOCAL_FILE_CONTRACTID, &rv) ; + if (NS_FAILED(rv) || (!pFile) ) return rv ; + nsCOMPtr pTempDir = do_CreateInstance (NS_LOCAL_FILE_CONTRACTID, &rv) ; + if (NS_FAILED(rv) || (!pTempDir) ) return rv ; + + for (int i=0 ; i < aFileCount ; i++) + { + if (aFiles[i].lpszPathName) + { + // check if attachment exists + if (aIsUnicode) + pFile->InitWithPath (nsDependentString(aFiles[i].lpszPathName)); + else + pFile->InitWithNativePath (nsDependentCString((const char*)aFiles[i].lpszPathName)); + + bool bExist ; + rv = pFile->Exists(&bExist) ; + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("nsMapiHook::HandleAttachments: filename: %s path: %s exists = %s \n", (const char*)aFiles[i].lpszFileName, (const char*)aFiles[i].lpszPathName, bExist ? "true" : "false")); + if (NS_FAILED(rv) || (!bExist) ) return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST ; + + //Temp Directory + nsCOMPtr pTempDir; + NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(pTempDir)); + + // create a new sub directory called moz_mapi underneath the temp directory + pTempDir->AppendRelativePath(NS_LITERAL_STRING("moz_mapi")); + pTempDir->Exists (&bExist) ; + if (!bExist) + { + rv = pTempDir->Create(nsIFile::DIRECTORY_TYPE, 777) ; + if (NS_FAILED(rv)) return rv ; + } + + // rename or copy the existing temp file with the real file name + + nsAutoString leafName ; + // convert to Unicode using Platform charset + // leafName already contains a unicode leafName from lpszPathName. If we were given + // a value for lpszFileName, use it. Otherwise stick with leafName + if (aFiles[i].lpszFileName) + { + nsAutoString wholeFileName; + if (aIsUnicode) + wholeFileName.Assign(aFiles[i].lpszFileName); + else + ConvertToUnicode(nsMsgI18NFileSystemCharset(), (char *) aFiles[i].lpszFileName, wholeFileName); + // need to find the last '\' and find the leafname from that. + int32_t lastSlash = wholeFileName.RFindChar(char16_t('\\')); + if (lastSlash != kNotFound) + leafName.Assign(Substring(wholeFileName, lastSlash + 1)); + else + leafName.Assign(wholeFileName); + } + else + pFile->GetLeafName (leafName); + + nsCOMPtr attachment = do_CreateInstance(NS_MSGATTACHMENT_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + attachment->SetName(leafName); + + nsCOMPtr pTempFile; + rv = pTempDir->Clone(getter_AddRefs(pTempFile)); + if (NS_FAILED(rv) || !pTempFile) + return rv; + + pTempFile->Append(leafName); + pTempFile->Exists(&bExist); + if (bExist) + { + rv = pTempFile->CreateUnique(nsIFile::NORMAL_FILE_TYPE, 0777); + NS_ENSURE_SUCCESS(rv, rv); + pTempFile->Remove(false); // remove so we can copy over it. + pTempFile->GetLeafName(leafName); + } + // copy the file to its new location and file name + pFile->CopyTo(pTempDir, leafName); + // point pFile to the new location of the attachment + pFile->InitWithFile(pTempDir); + pFile->Append(leafName); + + // create MsgCompose attachment object + attachment->SetTemporary(true); // this one is a temp file so set the flag for MsgCompose + + // now set the attachment object + nsAutoCString pURL ; + NS_GetURLSpecFromFile(pFile, pURL); + attachment->SetUrl(pURL); + + // set the file size + int64_t fileSize; + pFile->GetFileSize(&fileSize); + attachment->SetSize(fileSize); + + // add the attachment + rv = aCompFields->AddAttachment (attachment); + if (NS_FAILED(rv)) + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("nsMapiHook::HandleAttachments: AddAttachment rv = %lx\n", rv)); + } + } + return rv ; +} + + +// this is used to convert non Unicode data and then populate comp fields +nsresult nsMapiHook::PopulateCompFieldsWithConversion(lpnsMapiMessage aMessage, + nsIMsgCompFields * aCompFields) +{ + nsresult rv = NS_OK; + + if (aMessage->lpOriginator) + { + nsAutoString From; + From.Append(NS_ConvertASCIItoUTF16((char *) aMessage->lpOriginator->lpszAddress)); + aCompFields->SetFrom (From); + } + + nsAutoString To; + nsAutoString Cc; + nsAutoString Bcc; + NS_NAMED_LITERAL_STRING(Comma, ","); + if (aMessage->lpRecips) + { + for (int i=0 ; i < (int) aMessage->nRecipCount ; i++) + { + if (aMessage->lpRecips[i].lpszAddress || aMessage->lpRecips[i].lpszName) + { + const char *addressWithoutType = (aMessage->lpRecips[i].lpszAddress) + ? aMessage->lpRecips[i].lpszAddress : aMessage->lpRecips[i].lpszName; + if (!PL_strncasecmp(addressWithoutType, "SMTP:", 5)) + addressWithoutType += 5; + + switch (aMessage->lpRecips[i].ulRecipClass) + { + case MAPI_TO : + if (!To.IsEmpty()) + To += Comma ; + To.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break ; + + case MAPI_CC : + if (!Cc.IsEmpty()) + Cc += Comma ; + Cc.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break ; + + case MAPI_BCC : + if (!Bcc.IsEmpty()) + Bcc += Comma ; + Bcc.Append(NS_ConvertASCIItoUTF16(addressWithoutType)); + break ; + } + } + } + } + + // set To, Cc, Bcc + aCompFields->SetTo (To) ; + aCompFields->SetCc (Cc) ; + aCompFields->SetBcc (Bcc) ; + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("to: %s cc: %s bcc: %s \n", NS_ConvertUTF16toUTF8(To).get(), NS_ConvertUTF16toUTF8(Cc).get(), NS_ConvertUTF16toUTF8(Bcc).get())); + + nsAutoCString platformCharSet; + // set subject + if (aMessage->lpszSubject) + { + nsAutoString Subject ; + if (platformCharSet.IsEmpty()) + platformCharSet.Assign(nsMsgI18NFileSystemCharset()); + rv = ConvertToUnicode(platformCharSet.get(), (char *) aMessage->lpszSubject, Subject); + if (NS_FAILED(rv)) return rv; + aCompFields->SetSubject(Subject); + } + + // handle attachments as File URL + rv = HandleAttachments (aCompFields, aMessage->nFileCount, aMessage->lpFiles, false) ; + if (NS_FAILED(rv)) return rv ; + + // set body + if (aMessage->lpszNoteText) + { + nsAutoString Body ; + if (platformCharSet.IsEmpty()) + platformCharSet.Assign(nsMsgI18NFileSystemCharset()); + rv = ConvertToUnicode(platformCharSet.get(), (char *) aMessage->lpszNoteText, Body); + if (NS_FAILED(rv)) return rv ; + if (Body.IsEmpty() || Body.Last() != '\n') + Body.AppendLiteral(CRLF); + + // This is needed when Simple MAPI is used without a compose window. + // See bug 1366196. + if (Body.Find("") == kNotFound) + aCompFields->SetForcePlainText(true); + + rv = aCompFields->SetBody(Body) ; + } + +#ifdef RAJIV_DEBUG + // testing what all was set in CompFields + printf ("To : %S \n", To.get()) ; + printf ("CC : %S \n", Cc.get() ) ; + printf ("BCC : %S \n", Bcc.get() ) ; +#endif + + return rv ; +} + +// this is used to populate the docs as attachments in the Comp fields for Send Documents +nsresult nsMapiHook::PopulateCompFieldsForSendDocs(nsIMsgCompFields * aCompFields, ULONG aFlags, + LPTSTR aDelimChar, LPTSTR aFilePaths) +{ + nsAutoString strDelimChars ; + nsString strFilePaths; + nsresult rv = NS_OK ; + bool bExist ; + + if (aDelimChar) + strDelimChars.Assign(aDelimChar); + if (aFilePaths) + strFilePaths.Assign(aFilePaths); + + // check for comma in filename + if (strDelimChars.FindChar(',') == kNotFound) // if comma is not in the delimiter specified by user + { + if (strFilePaths.FindChar(',') != kNotFound) // if comma found in filenames return error + return NS_ERROR_FILE_INVALID_PATH; + } + + nsCString Attachments ; + + // only 1 file is to be sent, no delim specified + if (strDelimChars.IsEmpty()) + strDelimChars.AssignLiteral(";"); + + int32_t offset = 0 ; + int32_t FilePathsLen = strFilePaths.Length() ; + if (FilePathsLen) + { + nsAutoString Subject ; + + // multiple files to be sent, delim specified + nsCOMPtr pFile = do_CreateInstance (NS_LOCAL_FILE_CONTRACTID, &rv) ; + if (NS_FAILED(rv) || (!pFile) ) return rv ; + + char16_t * newFilePaths = (char16_t *) strFilePaths.get() ; + while (offset != kNotFound) + { + //Temp Directory + nsCOMPtr pTempDir; + NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(pTempDir)); + + // if not already existing, create another temp dir for mapi within Win temp dir + // this is windows only so we can do "\\" + pTempDir->AppendRelativePath (NS_LITERAL_STRING("moz_mapi")); + pTempDir->Exists(&bExist) ; + if (!bExist) + { + rv = pTempDir->Create(nsIFile::DIRECTORY_TYPE, 777) ; + if (NS_FAILED(rv)) return rv ; + } + + nsString RemainingPaths ; + RemainingPaths.Assign(newFilePaths) ; + offset = RemainingPaths.Find (strDelimChars) ; + if (offset != kNotFound) + { + RemainingPaths.SetLength (offset) ; + if ((offset + (int32_t)strDelimChars.Length()) < FilePathsLen) + newFilePaths += offset + strDelimChars.Length() ; + else + offset = kNotFound; + FilePathsLen -= offset + strDelimChars.Length(); + } + + if (RemainingPaths[1] != ':' && RemainingPaths[1] != '\\') + { + char cwd[MAX_PATH]; + if (_getdcwd(_getdrive(), cwd, MAX_PATH)) + { + nsAutoString cwdStr; + CopyASCIItoUTF16(cwd, cwdStr); + cwdStr.Append('\\'); + RemainingPaths.Insert(cwdStr, 0); + } + } + + pFile->InitWithPath (RemainingPaths) ; + + rv = pFile->Exists(&bExist) ; + if (NS_FAILED(rv) || (!bExist) ) return NS_ERROR_FILE_TARGET_DOES_NOT_EXIST ; + + // filename of the file attachment + nsAutoString leafName ; + pFile->GetLeafName (leafName) ; + if(NS_FAILED(rv) || leafName.IsEmpty()) return rv ; + + if (!Subject.IsEmpty()) + Subject.AppendLiteral(", "); + Subject += leafName; + + // create MsgCompose attachment object + nsCOMPtr attachment = do_CreateInstance(NS_MSGATTACHMENT_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, rv); + + nsDependentString fileNameNative(leafName.get()); + rv = pFile->CopyTo(pTempDir, fileNameNative); + if (NS_FAILED(rv)) return rv; + + // now turn pTempDir into a full file path to the temp file + pTempDir->Append(fileNameNative); + + // this one is a temp file so set the flag for MsgCompose + attachment->SetTemporary(true); + + // now set the attachment object + nsAutoCString pURL; + NS_GetURLSpecFromFile(pTempDir, pURL); + attachment->SetUrl(pURL); + + // set the file size + int64_t fileSize; + pFile->GetFileSize(&fileSize); + attachment->SetSize(fileSize); + + // add the attachment + rv = aCompFields->AddAttachment (attachment); + if (NS_FAILED(rv)) return rv; + } + + rv = aCompFields->SetBody(Subject) ; + } + + return rv ; +} + +// this used for Send with UI +nsresult nsMapiHook::ShowComposerWindow (unsigned long aSession, nsIMsgCompFields * aCompFields) +{ + nsresult rv = NS_OK ; + + // create a send listener to get back the send status + nsCOMPtr sendListener ; + rv = nsMAPISendListener::CreateMAPISendListener(getter_AddRefs(sendListener)) ; + if (NS_FAILED(rv) || (!sendListener) ) return rv ; + + // create the compose params object + nsCOMPtr pMsgComposeParams (do_CreateInstance(NS_MSGCOMPOSEPARAMS_CONTRACTID, &rv)); + if (NS_FAILED(rv) || (!pMsgComposeParams) ) return rv ; + + // If we found HTML, compose in HTML. + bool forcePlainText; + aCompFields->GetForcePlainText(&forcePlainText); + pMsgComposeParams->SetFormat(forcePlainText ? nsIMsgCompFormat::Default : nsIMsgCompFormat::HTML); + + // populate the compose params + pMsgComposeParams->SetType(nsIMsgCompType::New); + + // Never force to plain text, the default format will take care of that. + // Undo the forcing that happened in PopulateCompFields/PopulateCompFieldsWithConversion. + // See bug 1095629 and bug 1366196. + aCompFields->SetForcePlainText(false); + pMsgComposeParams->SetComposeFields(aCompFields); + pMsgComposeParams->SetSendListener(sendListener); + + /** get the nsIMsgComposeService object to open the compose window **/ + nsCOMPtr compService = do_GetService (NS_MSGCOMPOSESERVICE_CONTRACTID) ; + if (NS_FAILED(rv)|| (!compService) ) return rv ; + + rv = compService->OpenComposeWindowWithParams(nullptr, pMsgComposeParams) ; + if (NS_FAILED(rv)) return rv ; + + return rv ; +} diff --git a/mailnews/mapi/mapihook/src/msgMapiHook.h b/mailnews/mapi/mapihook/src/msgMapiHook.h new file mode 100644 index 000000000..8860d5227 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiHook.h @@ -0,0 +1,33 @@ +/* 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/. */ + +#ifndef MSG_MAPI_HOOK_H_ +#define MSG_MAPI_HOOK_H_ + +#include "prtypes.h" + +class nsMapiHook +{ + public : + + static bool DisplayLoginDialog(bool aLogin, char16_t **aUsername, + char16_t **aPassword); + static bool VerifyUserName(const nsString& aUsername, nsCString& aIdKey); + + static bool IsBlindSendAllowed () ; + static nsresult BlindSendMail (unsigned long aSession, nsIMsgCompFields * aCompFields) ; + static nsresult ShowComposerWindow (unsigned long aSession, nsIMsgCompFields * aCompFields) ; + static nsresult PopulateCompFields(lpnsMapiMessage aMessage, nsIMsgCompFields * aCompFields) ; + static nsresult PopulateCompFieldsWithConversion(lpnsMapiMessage aMessage, + nsIMsgCompFields * aCompFields) ; + static nsresult PopulateCompFieldsForSendDocs(nsIMsgCompFields * aCompFields, + ULONG aFlags, LPTSTR aDelimChar, LPTSTR aFilePaths) ; + static nsresult HandleAttachments (nsIMsgCompFields * aCompFields, int32_t aFileCount, + lpnsMapiFileDesc aFiles, BOOL aIsUnicode) ; + static void CleanUp(); + + static bool isMapiService; +}; + +#endif // MSG_MAPI_HOOK_H_ diff --git a/mailnews/mapi/mapihook/src/msgMapiImp.cpp b/mailnews/mapi/mapihook/src/msgMapiImp.cpp new file mode 100644 index 000000000..9139d68c6 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiImp.cpp @@ -0,0 +1,878 @@ +/* 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 +#include +#include "msgMapi.h" +#include "msgMapiImp.h" +#include "msgMapiFactory.h" +#include "msgMapiMain.h" + +#include "nsIMsgCompFields.h" +#include "msgMapiHook.h" +#include "nsStringGlue.h" +#include "nsCOMPtr.h" +#include "nsISupports.h" +#include "nsMsgCompCID.h" +#include "nsIMsgDatabase.h" +#include "nsMsgFolderFlags.h" +#include "nsIMsgHdr.h" +#include "MailNewsTypes.h" +#include "nsMsgBaseCID.h" +#include "nsIMsgAccountManager.h" +#include "nsIMsgFolder.h" +#include "nsIMsgImapMailFolder.h" +#include +#include "nsIInputStream.h" +#include "nsILineInputStream.h" +#include "nsISeekableStream.h" +#include "nsIFile.h" +#include "nsIFileStreams.h" +#include "nsNetCID.h" +#include "nsMsgMessageFlags.h" +#include "mozilla/mailnews/MimeHeaderParser.h" +#include "mozilla/Logging.h" + +using namespace mozilla::mailnews; + +PRLogModuleInfo *MAPI; + +CMapiImp::CMapiImp() +: m_cRef(1) +{ + m_Lock = PR_NewLock(); + if (!MAPI) + MAPI = PR_NewLogModule("MAPI"); +} + +CMapiImp::~CMapiImp() +{ + if (m_Lock) + PR_DestroyLock(m_Lock); +} + +STDMETHODIMP CMapiImp::QueryInterface(const IID& aIid, void** aPpv) +{ + if (aIid == IID_IUnknown) + { + *aPpv = static_cast(this); + } + else if (aIid == IID_nsIMapi) + { + *aPpv = static_cast(this); + } + else + { + *aPpv = nullptr; + return E_NOINTERFACE; + } + + reinterpret_cast(*aPpv)->AddRef(); + return S_OK; +} + +STDMETHODIMP_(ULONG) CMapiImp::AddRef() +{ + return ++m_cRef; +} + +STDMETHODIMP_(ULONG) CMapiImp::Release() +{ + int32_t temp = --m_cRef; + if (m_cRef == 0) + { + delete this; + return 0; + } + + return temp; +} + +STDMETHODIMP CMapiImp::IsValid() +{ + return S_OK; +} + +STDMETHODIMP CMapiImp::IsValidSession(unsigned long aSession) +{ + nsMAPIConfiguration *pConfig = nsMAPIConfiguration::GetMAPIConfiguration(); + if (pConfig && pConfig->IsSessionValid(aSession)) + return S_OK; + + return E_FAIL; +} + +STDMETHODIMP CMapiImp::Initialize() +{ + HRESULT hr = E_FAIL; + + if (!m_Lock) + return E_FAIL; + + PR_Lock(m_Lock); + + // Initialize MAPI Configuration + + nsMAPIConfiguration *pConfig = nsMAPIConfiguration::GetMAPIConfiguration(); + if (pConfig != nullptr) + hr = S_OK; + + PR_Unlock(m_Lock); + + return hr; +} + +STDMETHODIMP CMapiImp::Login(unsigned long aUIArg, LOGIN_PW_TYPE aLogin, LOGIN_PW_TYPE aPassWord, + unsigned long aFlags, unsigned long *aSessionId) +{ + HRESULT hr = E_FAIL; + bool bNewSession = false; + nsCString id_key; + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::Login using flags %d\n", aFlags)); + if (aFlags & MAPI_NEW_SESSION) + bNewSession = true; + + // Check For Profile Name + if (aLogin != nullptr && aLogin[0] != '\0') + { + if (!nsMapiHook::VerifyUserName(nsString(aLogin), id_key)) + { + *aSessionId = MAPI_E_LOGIN_FAILURE; + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::Login failed for username %s\n", aLogin)); + NS_ASSERTION(false, "failed verifying user name"); + return hr; + } + } + else + { + // get default account + nsresult rv; + nsCOMPtr accountManager = + do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv,MAPI_E_LOGIN_FAILURE); + nsCOMPtr account; + nsCOMPtr identity; + rv = accountManager->GetDefaultAccount(getter_AddRefs(account)); + NS_ENSURE_SUCCESS(rv,MAPI_E_LOGIN_FAILURE); + rv = account->GetDefaultIdentity(getter_AddRefs(identity)); + NS_ENSURE_SUCCESS(rv,MAPI_E_LOGIN_FAILURE); + if (!identity) + return MAPI_E_LOGIN_FAILURE; + identity->GetKey(id_key); + } + + // finally register(create) the session. + uint32_t nSession_Id; + int16_t nResult = 0; + + nsMAPIConfiguration *pConfig = nsMAPIConfiguration::GetMAPIConfiguration(); + if (pConfig != nullptr) + nResult = pConfig->RegisterSession(aUIArg, wwc(aLogin), wwc(aPassWord), + (aFlags & MAPI_FORCE_DOWNLOAD), bNewSession, + &nSession_Id, id_key.get()); + switch (nResult) + { + case -1 : + { + *aSessionId = MAPI_E_TOO_MANY_SESSIONS; + return hr; + } + case 0 : + { + *aSessionId = MAPI_E_INSUFFICIENT_MEMORY; + return hr; + } + default : + { + *aSessionId = nSession_Id; + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::Login succeeded\n")); + break; + } + } + + return S_OK; +} + +STDMETHODIMP CMapiImp::SendMail( unsigned long aSession, lpnsMapiMessage aMessage, + short aRecipCount, lpnsMapiRecipDesc aRecips , short aFileCount, lpnsMapiFileDesc aFiles , + unsigned long aFlags, unsigned long aReserved) +{ + nsresult rv = NS_OK ; + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::SendMail using flags %d\n", aFlags)); + // Assign the pointers in the aMessage struct to the array of Recips and Files + // received here from MS COM. These are used in BlindSendMail and ShowCompWin fns + aMessage->lpRecips = aRecips ; + aMessage->lpFiles = aFiles ; + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::SendMail flags=%x subject: %s sender: %s\n", + aFlags, (char *) aMessage->lpszSubject, (aMessage->lpOriginator) ? aMessage->lpOriginator->lpszAddress : "")); + + /** create nsIMsgCompFields obj and populate it **/ + nsCOMPtr pCompFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv) ; + if (NS_FAILED(rv) || (!pCompFields) ) return MAPI_E_INSUFFICIENT_MEMORY ; + + if (aFlags & MAPI_UNICODE) + rv = nsMapiHook::PopulateCompFields(aMessage, pCompFields) ; + else + rv = nsMapiHook::PopulateCompFieldsWithConversion(aMessage, pCompFields) ; + + if (NS_SUCCEEDED (rv)) + { + // see flag to see if UI needs to be brought up + if (!(aFlags & MAPI_DIALOG)) + { + rv = nsMapiHook::BlindSendMail(aSession, pCompFields); + } + else + { + rv = nsMapiHook::ShowComposerWindow(aSession, pCompFields); + } + } + + return nsMAPIConfiguration::GetMAPIErrorFromNSError (rv) ; +} + + +STDMETHODIMP CMapiImp::SendDocuments( unsigned long aSession, LPTSTR aDelimChar, + LPTSTR aFilePaths, LPTSTR aFileNames, ULONG aFlags) +{ + nsresult rv = NS_OK ; + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::SendDocument using flags %d\n", aFlags)); + /** create nsIMsgCompFields obj and populate it **/ + nsCOMPtr pCompFields = do_CreateInstance(NS_MSGCOMPFIELDS_CONTRACTID, &rv) ; + if (NS_FAILED(rv) || (!pCompFields) ) return MAPI_E_INSUFFICIENT_MEMORY ; + + if (aFilePaths) + { + rv = nsMapiHook::PopulateCompFieldsForSendDocs(pCompFields, aFlags, aDelimChar, aFilePaths) ; + } + + if (NS_SUCCEEDED (rv)) + rv = nsMapiHook::ShowComposerWindow(aSession, pCompFields); + else + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::SendDocument error rv = %lx, paths = %s names = %s\n", rv, aFilePaths, aFileNames)); + + return nsMAPIConfiguration::GetMAPIErrorFromNSError (rv) ; +} + +nsresult CMapiImp::GetDefaultInbox(nsIMsgFolder **inboxFolder) +{ + // get default account + nsresult rv; + nsCOMPtr accountManager = + do_GetService(NS_MSGACCOUNTMANAGER_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv,rv); + + nsCOMPtr account; + rv = accountManager->GetDefaultAccount(getter_AddRefs(account)); + NS_ENSURE_SUCCESS(rv,rv); + + // get incoming server + nsCOMPtr server; + rv = account->GetIncomingServer(getter_AddRefs(server)); + NS_ENSURE_SUCCESS(rv,rv); + + nsCString type; + rv = server->GetType(type); + NS_ENSURE_SUCCESS(rv,rv); + + // we only care about imap and pop3 + if (type.EqualsLiteral("imap") || type.EqualsLiteral("pop3")) + { + // imap and pop3 account should have an Inbox + nsCOMPtr rootMsgFolder; + rv = server->GetRootMsgFolder(getter_AddRefs(rootMsgFolder)); + NS_ENSURE_SUCCESS(rv,rv); + + if (!rootMsgFolder) + return NS_ERROR_FAILURE; + + rootMsgFolder->GetFolderWithFlags(nsMsgFolderFlags::Inbox, inboxFolder); + if (!*inboxFolder) + return NS_ERROR_FAILURE; + + } + return NS_OK; +} + +//***************************************************************************** +// Encapsulate the XP DB stuff required to enumerate messages + +class MsgMapiListContext +{ +public: + MsgMapiListContext () {} + ~MsgMapiListContext (); + + nsresult OpenDatabase (nsIMsgFolder *folder); + + nsMsgKey GetNext (); + nsresult MarkRead (nsMsgKey key, bool read); + + lpnsMapiMessage GetMessage (nsMsgKey, unsigned long flFlags); + bool IsIMAPHost(void); + bool DeleteMessage(nsMsgKey key); + +protected: + + char *ConvertDateToMapiFormat (time_t); + char *ConvertBodyToMapiFormat (nsIMsgDBHdr *hdr); + void ConvertRecipientsToMapiFormat(const nsCOMArray &ourRecips, + lpnsMapiRecipDesc mapiRecips, + int mapiRecipClass); + + nsCOMPtr m_folder; + nsCOMPtr m_db; + nsCOMPtr m_msgEnumerator; +}; + + +LONG CMapiImp::InitContext(unsigned long session, MsgMapiListContext **listContext) +{ + nsMAPIConfiguration * pMapiConfig = nsMAPIConfiguration::GetMAPIConfiguration() ; + if (!pMapiConfig) + return MAPI_E_FAILURE ; // get the singelton obj + *listContext = (MsgMapiListContext *) pMapiConfig->GetMapiListContext(session); + // This is the first message + if (!*listContext) + { + nsCOMPtr inboxFolder; + nsresult rv = GetDefaultInbox(getter_AddRefs(inboxFolder)); + if (NS_FAILED(rv)) + { + NS_ASSERTION(false, "in init context, no inbox"); + return(MAPI_E_NO_MESSAGES); + } + + *listContext = new MsgMapiListContext; + if (!*listContext) + return MAPI_E_INSUFFICIENT_MEMORY; + + rv = (*listContext)->OpenDatabase(inboxFolder); + if (NS_FAILED(rv)) + { + pMapiConfig->SetMapiListContext(session, NULL); + delete *listContext; + NS_ASSERTION(false, "in init context, unable to open db"); + return MAPI_E_NO_MESSAGES; + } + else + pMapiConfig->SetMapiListContext(session, *listContext); + } + return SUCCESS_SUCCESS; +} + +STDMETHODIMP CMapiImp::FindNext(unsigned long aSession, unsigned long ulUIParam, LPTSTR lpszMessageType, + LPTSTR lpszSeedMessageID, unsigned long flFlags, unsigned long ulReserved, + unsigned char lpszMessageID[64]) + +{ + // + // If this is true, then this is the first call to this FindNext function + // and we should start the enumeration operation. + // + + *lpszMessageID = '\0'; + nsMAPIConfiguration * pMapiConfig = nsMAPIConfiguration::GetMAPIConfiguration() ; + if (!pMapiConfig) + { + NS_ASSERTION(false, "failed to get config in findnext"); + return MAPI_E_FAILURE ; // get the singelton obj + } + MsgMapiListContext *listContext; + LONG ret = InitContext(aSession, &listContext); + if (ret != SUCCESS_SUCCESS) + { + NS_ASSERTION(false, "init context failed"); + return ret; + } + NS_ASSERTION(listContext, "initContext returned null context"); + if (listContext) + { +// NS_ASSERTION(false, "find next init context succeeded"); + nsMsgKey nextKey = listContext->GetNext(); + if (nextKey == nsMsgKey_None) + { + pMapiConfig->SetMapiListContext(aSession, NULL); + delete listContext; + return(MAPI_E_NO_MESSAGES); + } + +// TRACE("MAPI: ProcessMAPIFindNext() Found message id = %d\n", nextKey); + + sprintf((char *) lpszMessageID, "%d", nextKey); + } + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::FindNext returning key %s\n", (char *) lpszMessageID)); + return(SUCCESS_SUCCESS); +} + +STDMETHODIMP CMapiImp::ReadMail(unsigned long aSession, unsigned long ulUIParam, LPTSTR lpszMessageID, + unsigned long flFlags, unsigned long ulReserved, lpnsMapiMessage *lppMessage) +{ + nsresult irv; + nsAutoCString keyString((char *) lpszMessageID); + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("CMapiImp::ReadMail asking for key %s\n", (char *) lpszMessageID)); + nsMsgKey msgKey = keyString.ToInteger(&irv); + if (NS_FAILED(irv)) + { + NS_ASSERTION(false, "invalid lpszMessageID"); + return MAPI_E_INVALID_MESSAGE; + } + MsgMapiListContext *listContext; + LONG ret = InitContext(aSession, &listContext); + if (ret != SUCCESS_SUCCESS) + { + NS_ASSERTION(false, "init context failed in ReadMail"); + return ret; + } + *lppMessage = listContext->GetMessage (msgKey, flFlags); + NS_ASSERTION(*lppMessage, "get message failed"); + + return (*lppMessage) ? SUCCESS_SUCCESS : E_FAIL; +} + + +STDMETHODIMP CMapiImp::DeleteMail(unsigned long aSession, unsigned long ulUIParam, LPTSTR lpszMessageID, + unsigned long flFlags, unsigned long ulReserved) +{ + nsresult irv; + nsAutoCString keyString((char *) lpszMessageID); + nsMsgKey msgKey = keyString.ToInteger(&irv); + // XXX Why do we return success on failure? + if (NS_FAILED(irv)) + return SUCCESS_SUCCESS; + MsgMapiListContext *listContext; + LONG ret = InitContext(aSession, &listContext); + if (ret != SUCCESS_SUCCESS) + return ret; + return (listContext->DeleteMessage(msgKey)) ? SUCCESS_SUCCESS : MAPI_E_INVALID_MESSAGE; +} + +STDMETHODIMP CMapiImp::SaveMail(unsigned long aSession, unsigned long ulUIParam, lpnsMapiMessage lppMessage, + unsigned long flFlags, unsigned long ulReserved, LPTSTR lpszMessageID) +{ + MsgMapiListContext *listContext; + LONG ret = InitContext(aSession, &listContext); + if (ret != SUCCESS_SUCCESS) + return ret; + return S_OK; +} + + +STDMETHODIMP CMapiImp::Logoff (unsigned long aSession) +{ + nsMAPIConfiguration *pConfig = nsMAPIConfiguration::GetMAPIConfiguration(); + + if (pConfig->UnRegisterSession((uint32_t)aSession)) + return S_OK; + + return E_FAIL; +} + +STDMETHODIMP CMapiImp::CleanUp() +{ + nsMapiHook::CleanUp(); + return S_OK; +} + + +#define MAX_NAME_LEN 256 + + +MsgMapiListContext::~MsgMapiListContext () +{ + if (m_db) + m_db->Close(false); +} + + +nsresult MsgMapiListContext::OpenDatabase (nsIMsgFolder *folder) +{ + nsresult dbErr = NS_ERROR_FAILURE; + if (folder) + { + m_folder = folder; + dbErr = folder->GetMsgDatabase(getter_AddRefs(m_db)); + if (m_db) + dbErr = m_db->EnumerateMessages(getter_AddRefs(m_msgEnumerator)); + } + return dbErr; +} + +bool +MsgMapiListContext::IsIMAPHost(void) +{ + if (!m_folder) + return FALSE; + nsCOMPtr imapFolder = do_QueryInterface(m_folder); + + return imapFolder != nullptr; +} + +nsMsgKey MsgMapiListContext::GetNext () +{ + nsMsgKey key = nsMsgKey_None; + bool keepTrying = TRUE; + +// NS_ASSERTION (m_msgEnumerator && m_db, "need enumerator and db"); + if (m_msgEnumerator && m_db) + { + + do + { + keepTrying = FALSE; + nsCOMPtr hdrISupports; + nsCOMPtr msgHdr; + if (NS_SUCCEEDED(m_msgEnumerator->GetNext(getter_AddRefs(hdrISupports))) && hdrISupports) + { + msgHdr = do_QueryInterface(hdrISupports); + msgHdr->GetMessageKey(&key); + + // Check here for IMAP message...if not, just return... + if (!IsIMAPHost()) + return key; + + // If this is an IMAP message, we have to make sure we have a valid + // body to work with. + uint32_t flags = 0; + + (void) msgHdr->GetFlags(&flags); + if (flags & nsMsgMessageFlags::Offline) + return key; + + // Ok, if we get here, we have an IMAP message without a body! + // We need to keep trying by calling the GetNext member recursively... + keepTrying = TRUE; + } + } while (keepTrying); + } + + return key; +} + + +nsresult MsgMapiListContext::MarkRead (nsMsgKey key, bool read) +{ + nsresult err = NS_ERROR_FAILURE; + NS_ASSERTION(m_db, "no db"); + if (m_db) + err = m_db->MarkRead (key, read, nullptr); + return err; +} + + +lpnsMapiMessage MsgMapiListContext::GetMessage (nsMsgKey key, unsigned long flFlags) +{ + lpnsMapiMessage message = (lpnsMapiMessage) CoTaskMemAlloc (sizeof(nsMapiMessage)); + memset(message, 0, sizeof(nsMapiMessage)); + if (message) + { + nsCString subject; + nsCString author; + nsCOMPtr msgHdr; + + nsresult rv = m_db->GetMsgHdrForKey (key, getter_AddRefs(msgHdr)); + if (msgHdr) + { + msgHdr->GetSubject (getter_Copies(subject)); + message->lpszSubject = (char *) CoTaskMemAlloc(subject.Length() + 1); + strcpy((char *) message->lpszSubject, subject.get()); + uint32_t date; + (void) msgHdr->GetDateInSeconds(&date); + message->lpszDateReceived = ConvertDateToMapiFormat (date); + + // Pull out the flags info + // anything to do with MAPI_SENT? Since we're only reading the Inbox, I guess not + uint32_t ourFlags; + (void) msgHdr->GetFlags(&ourFlags); + if (!(ourFlags & nsMsgMessageFlags::Read)) + message->flFlags |= MAPI_UNREAD; + if (ourFlags & (nsMsgMessageFlags::MDNReportNeeded | nsMsgMessageFlags::MDNReportSent)) + message->flFlags |= MAPI_RECEIPT_REQUESTED; + + // Pull out the author/originator info + message->lpOriginator = (lpnsMapiRecipDesc) CoTaskMemAlloc (sizeof(nsMapiRecipDesc)); + memset(message->lpOriginator, 0, sizeof(nsMapiRecipDesc)); + if (message->lpOriginator) + { + msgHdr->GetAuthor (getter_Copies(author)); + ConvertRecipientsToMapiFormat(EncodedHeader(author), + message->lpOriginator, MAPI_ORIG); + } + // Pull out the To/CC info + nsCString recipients, ccList; + msgHdr->GetRecipients(getter_Copies(recipients)); + msgHdr->GetCcList(getter_Copies(ccList)); + + nsCOMArray parsedToRecips = EncodedHeader(recipients); + nsCOMArray parsedCCRecips = EncodedHeader(ccList); + uint32_t numToRecips = parsedToRecips.Length(); + uint32_t numCCRecips = parsedCCRecips.Length(); + + message->lpRecips = (lpnsMapiRecipDesc) CoTaskMemAlloc ((numToRecips + numCCRecips) * sizeof(MapiRecipDesc)); + memset(message->lpRecips, 0, (numToRecips + numCCRecips) * sizeof(MapiRecipDesc)); + if (message->lpRecips) + { + ConvertRecipientsToMapiFormat(parsedToRecips, message->lpRecips, + MAPI_TO); + ConvertRecipientsToMapiFormat(parsedCCRecips, + &message->lpRecips[numToRecips], MAPI_CC); + } + + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("MsgMapiListContext::GetMessage flags=%x subject %s date %s sender %s\n", + flFlags, (char *) message->lpszSubject,(char *) message->lpszDateReceived, author.get()) ); + + // Convert any body text that we have locally + if (!(flFlags & MAPI_ENVELOPE_ONLY)) + message->lpszNoteText = (char *) ConvertBodyToMapiFormat (msgHdr); + + } + if (! (flFlags & (MAPI_PEEK | MAPI_ENVELOPE_ONLY))) + m_db->MarkRead(key, true, nullptr); + } + return message; +} + + +char *MsgMapiListContext::ConvertDateToMapiFormat (time_t ourTime) +{ + char *date = (char*) CoTaskMemAlloc(32); + if (date) + { + // MAPI time format is YYYY/MM/DD HH:MM + // Note that we're not using XP_StrfTime because that localizes the time format, + // and the way I read the MAPI spec is that their format is canonical, not localized. + struct tm *local = localtime (&ourTime); + if (local) + strftime (date, 32, "%Y/%m/%d %I:%M", local); //use %H if hours should be 24 hour format + } + return date; +} + + +void MsgMapiListContext::ConvertRecipientsToMapiFormat( + const nsCOMArray &recipients, + lpnsMapiRecipDesc mapiRecips, int mapiRecipClass) +{ + nsTArray names, addresses; + ExtractAllAddresses(recipients, UTF16ArrayAdapter<>(names), + UTF16ArrayAdapter<>(addresses)); + + size_t numAddresses = names.Length(); + for (size_t i = 0; i < numAddresses; i++) + { + if (!names[i].IsEmpty()) + { + mapiRecips[i].lpszName = (char *) CoTaskMemAlloc(names[i].Length() + 1); + if (mapiRecips[i].lpszName) + strcpy((char *)mapiRecips[i].lpszName, names[i].get()); + } + if (!addresses[i].IsEmpty()) + { + mapiRecips[i].lpszName = (char *) CoTaskMemAlloc(addresses[i].Length() + 1); + if (mapiRecips[i].lpszName) + strcpy((char *)mapiRecips[i].lpszName, addresses[i].get()); + } + mapiRecips[i].ulRecipClass = mapiRecipClass; + } +} + + +char *MsgMapiListContext::ConvertBodyToMapiFormat (nsIMsgDBHdr *hdr) +{ + const int kBufLen = 64000; // I guess we only return the first 64K of a message. +#define EMPTY_MESSAGE_LINE(buf) (buf[0] == '\r' || buf[0] == '\n' || buf[0] == '\0') + + nsCOMPtr folder; + hdr->GetFolder(getter_AddRefs(folder)); + if (!folder) + return nullptr; + + nsCOMPtr inputStream; + nsCOMPtr localFile; + folder->GetFilePath(getter_AddRefs(localFile)); + + nsresult rv; + nsCOMPtr fileStream = do_CreateInstance(NS_LOCALFILEINPUTSTREAM_CONTRACTID, &rv); + NS_ENSURE_SUCCESS(rv, nullptr); + + rv = fileStream->Init(localFile, PR_RDONLY, 0664, false); //just have to read the messages + inputStream = do_QueryInterface(fileStream); + + if (inputStream) + { + nsCOMPtr fileLineStream = do_QueryInterface(inputStream); + if (!fileLineStream) + return nullptr; + // ### really want to skip past headers... + uint64_t messageOffset; + uint32_t lineCount; + hdr->GetMessageOffset(&messageOffset); + hdr->GetLineCount(&lineCount); + nsCOMPtr seekableStream = do_QueryInterface(inputStream); + seekableStream->Seek(PR_SEEK_SET, messageOffset); + bool hasMore = true; + nsAutoCString curLine; + nsresult rv = NS_OK; + while (hasMore) // advance past message headers + { + nsresult rv = fileLineStream->ReadLine(curLine, &hasMore); + if (NS_FAILED(rv) || EMPTY_MESSAGE_LINE(curLine)) + break; + } + uint32_t msgSize; + hdr->GetMessageSize(&msgSize); + if (msgSize > kBufLen) + msgSize = kBufLen - 1; + // this is too big, since it includes the msg hdr size...oh well + char *body = (char*) CoTaskMemAlloc (msgSize + 1); + + if (!body) + return nullptr; + int32_t bytesCopied = 0; + for (hasMore = TRUE; lineCount > 0 && hasMore && NS_SUCCEEDED(rv); lineCount--) + { + rv = fileLineStream->ReadLine(curLine, &hasMore); + if (NS_FAILED(rv)) + break; + curLine.Append(CRLF); + // make sure we have room left + if (bytesCopied + curLine.Length() < msgSize) + { + strcpy(body + bytesCopied, curLine.get()); + bytesCopied += curLine.Length(); + } + } + MOZ_LOG(MAPI, mozilla::LogLevel::Debug, ("ConvertBodyToMapiFormat size=%x allocated size %x body = %100.100s\n", + bytesCopied, msgSize + 1, (char *) body) ); + body[bytesCopied] = '\0'; // rhp - fix last line garbage... + return body; + } + return nullptr; +} + + +//***************************************************************************** +// MSGMAPI API implementation + + + +static void msg_FreeMAPIFile(lpMapiFileDesc f) +{ + if (f) + { + CoTaskMemFree(f->lpszPathName); + CoTaskMemFree(f->lpszFileName); + } +} + +static void msg_FreeMAPIRecipient(lpMapiRecipDesc rd) +{ + if (rd) + { + if (rd->lpszName) + CoTaskMemFree(rd->lpszName); + if (rd->lpszAddress) + CoTaskMemFree(rd->lpszAddress); + // CoTaskMemFree(rd->lpEntryID); + } +} + +extern "C" void MSG_FreeMapiMessage (lpMapiMessage msg) +{ + ULONG i; + + if (msg) + { + CoTaskMemFree(msg->lpszSubject); + CoTaskMemFree(msg->lpszNoteText); + CoTaskMemFree(msg->lpszMessageType); + CoTaskMemFree(msg->lpszDateReceived); + CoTaskMemFree(msg->lpszConversationID); + + if (msg->lpOriginator) + msg_FreeMAPIRecipient(msg->lpOriginator); + + for (i=0; inRecipCount; i++) + if (&(msg->lpRecips[i]) != nullptr) + msg_FreeMAPIRecipient(&(msg->lpRecips[i])); + + CoTaskMemFree(msg->lpRecips); + + for (i=0; inFileCount; i++) + if (&(msg->lpFiles[i]) != nullptr) + msg_FreeMAPIFile(&(msg->lpFiles[i])); + + CoTaskMemFree(msg->lpFiles); + + CoTaskMemFree(msg); + } +} + + +extern "C" bool MsgMarkMapiMessageRead (nsIMsgFolder *folder, nsMsgKey key, bool read) +{ + bool success = FALSE; + MsgMapiListContext *context = new MsgMapiListContext(); + if (context) + { + if (NS_SUCCEEDED(context->OpenDatabase(folder))) + { + if (NS_SUCCEEDED(context->MarkRead (key, read))) + success = TRUE; + } + delete context; + } + return success; +} + +bool +MsgMapiListContext::DeleteMessage(nsMsgKey key) +{ + if (!m_db) + return FALSE; + + if ( !IsIMAPHost() ) + { + return NS_SUCCEEDED((m_db->DeleteMessages(1, &key, nullptr))); + } +#if 0 + else if ( m_folder->GetIMAPFolderInfoMail() ) + { + AutoTArray messageKeys; + messageKeys.AppendElement(key); + + (m_folder->GetIMAPFolderInfoMail())->DeleteSpecifiedMessages(pane, messageKeys, nsMsgKey_None); + m_db->DeleteMessage(key, nullptr, FALSE); + return TRUE; + } +#endif + else + { + return FALSE; + } +} + +/* Return TRUE on success, FALSE on failure */ +extern "C" bool MSG_DeleteMapiMessage(nsIMsgFolder *folder, nsMsgKey key) +{ + bool success = FALSE; + MsgMapiListContext *context = new MsgMapiListContext(); + if (context) + { + if (NS_SUCCEEDED(context->OpenDatabase(folder))) + { + success = context->DeleteMessage(key); + } + + delete context; + } + + return success; +} + diff --git a/mailnews/mapi/mapihook/src/msgMapiImp.h b/mailnews/mapi/mapihook/src/msgMapiImp.h new file mode 100644 index 000000000..875e9c6cf --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiImp.h @@ -0,0 +1,77 @@ +/* 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/. */ + +#ifndef MSG_MAPI_IMP_H +#define MSG_MAPI_IMP_H + +#include +#include +#include "msgMapi.h" +#include "nspr.h" +#include "nscore.h" +#include "nsISupportsImpl.h" // ThreadSafeAutoRefCnt + +class nsIMsgFolder; +class MsgMapiListContext; + +const CLSID CLSID_CMapiImp = {0x29f458be, 0x8866, 0x11d5, {0xa3, 0xdd, 0x0, 0xb0, 0xd0, 0xf3, 0xba, 0xa7}}; + +// this class implements the MS COM interface nsIMapi that provides the methods +// called by mapi32.dll to perform the mail operations as specified by MAPI. +// These class methods in turn use the Mozilla Mail XPCOM interfaces to do so. +class CMapiImp : public nsIMapi +{ + +public : + + // IUnknown + + STDMETHODIMP QueryInterface(const IID& aIid, void** aPpv); + STDMETHODIMP_(ULONG) AddRef(); + STDMETHODIMP_(ULONG) Release(); + + // Interface INsMapi + + STDMETHODIMP Login(unsigned long aUIArg, LOGIN_PW_TYPE aLogin, + LOGIN_PW_TYPE aPassWord, unsigned long aFlags, + unsigned long *aSessionId); + + STDMETHODIMP SendMail( unsigned long aSession, lpnsMapiMessage aMessage, + short aRecipCount, lpnsMapiRecipDesc aRecips , + short aFileCount, lpnsMapiFileDesc aFiles , + unsigned long aFlags, unsigned long aReserved) ; + + STDMETHODIMP SendDocuments( unsigned long aSession, LPTSTR aDelimChar, + LPTSTR aFilePaths, LPTSTR aFileNames, ULONG aFlags); + + STDMETHODIMP FindNext( unsigned long aSession, unsigned long ulUIParam, LPTSTR lpszMessageType, + LPTSTR lpszSeedMessageID, unsigned long flFlags, unsigned long ulReserved, + unsigned char lpszMessageID[64] ); + + STDMETHODIMP ReadMail(unsigned long lhSession, unsigned long ulUIParam, LPTSTR lpszMessageID, + unsigned long flFlags, unsigned long ulReserved, lpnsMapiMessage *lppMessage); + STDMETHODIMP DeleteMail(unsigned long lhSession, unsigned long ulUIParam, LPTSTR lpszMessageID, + unsigned long flFlags, unsigned long ulReserved); + STDMETHODIMP SaveMail(unsigned long lhSession, unsigned long ulUIParam, lpnsMapiMessage lppMessage, + unsigned long flFlags, unsigned long ulReserved, LPTSTR lpszMessageID); + + STDMETHODIMP Initialize(); + STDMETHODIMP IsValid(); + STDMETHODIMP IsValidSession(unsigned long aSession); + + STDMETHODIMP Logoff (unsigned long aSession); + STDMETHODIMP CleanUp(); + + CMapiImp(); + ~CMapiImp(); + + LONG InitContext(unsigned long session, MsgMapiListContext **listContext); + nsresult GetDefaultInbox(nsIMsgFolder **inboxFolder); + +private : + PRLock *m_Lock; + mozilla::ThreadSafeAutoRefCnt m_cRef; +}; + +#endif // MSG_MAPI_IMP_H diff --git a/mailnews/mapi/mapihook/src/msgMapiMain.cpp b/mailnews/mapi/mapihook/src/msgMapiMain.cpp new file mode 100644 index 000000000..adb5cc14c --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiMain.cpp @@ -0,0 +1,306 @@ +/* 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 +#include + +#include "msgCore.h" +#include "nsComposeStrings.h" +#include "msgMapiMain.h" +#include "nsIServiceManager.h" +#include "nsCOMPtr.h" + +nsMAPIConfiguration *nsMAPIConfiguration::m_pSelfRef = nullptr; +uint32_t nsMAPIConfiguration::session_generator = 0; +uint32_t nsMAPIConfiguration::sessionCount = 0; + +nsMAPIConfiguration *nsMAPIConfiguration::GetMAPIConfiguration() +{ + if (m_pSelfRef == nullptr) + m_pSelfRef = new nsMAPIConfiguration(); + + return m_pSelfRef; +} + +nsMAPIConfiguration::nsMAPIConfiguration() +: m_nMaxSessions(MAX_SESSIONS) +{ + m_Lock = PR_NewLock(); +} + +nsMAPIConfiguration::~nsMAPIConfiguration() +{ + if (m_Lock) + PR_DestroyLock(m_Lock); +} + +void nsMAPIConfiguration::OpenConfiguration() +{ + // No. of max. sessions is set to MAX_SESSIONS. In future + // if it is decided to have configuration (registry) + // parameter, this function can be used to set the + // max sessions; + + return; +} + +int16_t nsMAPIConfiguration::RegisterSession(uint32_t aHwnd, + const char16_t *aUserName, const char16_t *aPassword, + bool aForceDownLoad, bool aNewSession, + uint32_t *aSession, const char *aIdKey) +{ + int16_t nResult = 0; + uint32_t n_SessionId = 0; + + PR_Lock(m_Lock); + + // Check whether max sessions is exceeded + + if (sessionCount >= m_nMaxSessions) + { + PR_Unlock(m_Lock); + return -1; + } + + if (aUserName != nullptr && aUserName[0] != '\0') + m_ProfileMap.Get(nsDependentString(aUserName), &n_SessionId); + + // try to share a session; if not create a session + if (n_SessionId > 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(n_SessionId, &pTemp); + if (pTemp != nullptr) + { + pTemp->IncrementSession(); + *aSession = n_SessionId; + nResult = 1; + } + } + else if (aNewSession || n_SessionId == 0) // checking for n_SessionId is a concession + { + // create a new session; if new session is specified OR there is no session + nsMAPISession *pTemp = nullptr; + pTemp = new nsMAPISession(aHwnd, aUserName, + aPassword, aForceDownLoad, aIdKey); + + if (pTemp != nullptr) + { + session_generator++; + + // I don't think there will be (2 power 32) sessions alive + // in a cycle. This is an assumption + + if (session_generator == 0) + session_generator++; + m_SessionMap.Put(session_generator, pTemp); + if (aUserName != nullptr && aUserName[0] != '\0') + m_ProfileMap.Put(nsDependentString(aUserName), session_generator); + *aSession = session_generator; + sessionCount++; + nResult = 1; + } + } + + PR_Unlock(m_Lock); + return nResult; +} + +bool nsMAPIConfiguration::UnRegisterSession(uint32_t aSessionID) +{ + bool bResult = false; + + PR_Lock(m_Lock); + + if (aSessionID != 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(aSessionID, &pTemp); + + if (pTemp != nullptr) + { + if (pTemp->DecrementSession() == 0) + { + if (pTemp->m_pProfileName.get() != nullptr) + m_ProfileMap.Remove(pTemp->m_pProfileName); + m_SessionMap.Remove(aSessionID); + sessionCount--; + bResult = true; + } + } + } + + PR_Unlock(m_Lock); + return bResult; +} + +bool nsMAPIConfiguration::IsSessionValid(uint32_t aSessionID) +{ + if (aSessionID == 0) + return false; + bool retValue = false; + PR_Lock(m_Lock); + retValue = m_SessionMap.Get(aSessionID, NULL); + PR_Unlock(m_Lock); + return retValue; +} + +char16_t *nsMAPIConfiguration::GetPassword(uint32_t aSessionID) +{ + char16_t *pResult = nullptr; + + PR_Lock(m_Lock); + + if (aSessionID != 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(aSessionID, &pTemp); + + if (pTemp) + pResult = pTemp->GetPassword(); + } + PR_Unlock(m_Lock); + return pResult; +} + +void *nsMAPIConfiguration::GetMapiListContext(uint32_t aSessionID) +{ + void *pResult = nullptr; + + PR_Lock(m_Lock); + + if (aSessionID != 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(aSessionID, &pTemp); + if (pTemp) + pResult = pTemp->GetMapiListContext(); + } + + PR_Unlock(m_Lock); + return pResult; +} + +void nsMAPIConfiguration::SetMapiListContext(uint32_t aSessionID, void *mapiListContext) +{ + PR_Lock(m_Lock); + + if (aSessionID != 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(aSessionID, &pTemp); + if (pTemp) + pTemp->SetMapiListContext(mapiListContext); + } + + PR_Unlock(m_Lock); +} + +void nsMAPIConfiguration::GetIdKey(uint32_t aSessionID, nsCString& aKey) +{ + PR_Lock(m_Lock); + if (aSessionID != 0) + { + nsMAPISession *pTemp = nullptr; + m_SessionMap.Get(aSessionID, &pTemp); + if (pTemp) + pTemp->GetIdKey(aKey); + } + PR_Unlock(m_Lock); + return; +} + +// util func +HRESULT nsMAPIConfiguration::GetMAPIErrorFromNSError (nsresult res) +{ + HRESULT hr = SUCCESS_SUCCESS; + + if (NS_SUCCEEDED (res)) return hr; + + // if failure return the related MAPI failure code + switch (res) + { + case NS_MSG_NO_RECIPIENTS : + hr = MAPI_E_BAD_RECIPTYPE; + break; + case NS_ERROR_COULD_NOT_GET_USERS_MAIL_ADDRESS : + hr = MAPI_E_INVALID_RECIPS; + break; + case NS_ERROR_SMTP_AUTH_FAILURE : + case NS_ERROR_SMTP_AUTH_GSSAPI : + case NS_ERROR_SMTP_AUTH_MECH_NOT_SUPPORTED : + case NS_ERROR_SMTP_AUTH_NOT_SUPPORTED : + case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_NO_SSL : + case NS_ERROR_SMTP_AUTH_CHANGE_ENCRYPT_TO_PLAIN_SSL : + case NS_ERROR_SMTP_AUTH_CHANGE_PLAIN_TO_ENCRYPT : + hr = MAPI_E_LOGIN_FAILURE; + break; + case NS_MSG_UNABLE_TO_OPEN_FILE : + case NS_MSG_UNABLE_TO_OPEN_TMP_FILE : + case NS_MSG_COULDNT_OPEN_FCC_FOLDER : + case NS_ERROR_FILE_INVALID_PATH : + hr = MAPI_E_ATTACHMENT_OPEN_FAILURE; + break; + case NS_ERROR_FILE_TARGET_DOES_NOT_EXIST : + hr = MAPI_E_ATTACHMENT_NOT_FOUND; + break; + case NS_MSG_CANCELLING : + hr = MAPI_E_USER_ABORT; + break; + case NS_MSG_ERROR_WRITING_FILE : + case NS_MSG_UNABLE_TO_SAVE_TEMPLATE : + case NS_MSG_UNABLE_TO_SAVE_DRAFT : + hr = MAPI_E_ATTACHMENT_WRITE_FAILURE; + break; + default: + hr = MAPI_E_FAILURE; + break; + } + + return hr; +} + + +nsMAPISession::nsMAPISession(uint32_t aHwnd, const char16_t *aUserName, + const char16_t *aPassword, + bool aForceDownLoad, const char *aKey) +: m_bIsForcedDownLoad(aForceDownLoad), + m_hAppHandle(aHwnd), + m_nShared(1), + m_pIdKey(aKey) +{ + m_listContext = NULL; + m_pProfileName.Assign(aUserName); + m_pPassword.Assign(aPassword); +} + +nsMAPISession::~nsMAPISession() +{ +} + +uint32_t nsMAPISession::IncrementSession() +{ + return ++m_nShared; +} + +uint32_t nsMAPISession::DecrementSession() +{ + return --m_nShared; +} + +uint32_t nsMAPISession::GetSessionCount() +{ + return m_nShared; +} + +char16_t *nsMAPISession::GetPassword() +{ + return (char16_t *)m_pPassword.get(); +} + +void nsMAPISession::GetIdKey(nsCString& aKey) +{ + aKey = m_pIdKey; + return; +} diff --git a/mailnews/mapi/mapihook/src/msgMapiMain.h b/mailnews/mapi/mapihook/src/msgMapiMain.h new file mode 100644 index 000000000..be74c5db1 --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiMain.h @@ -0,0 +1,86 @@ +/* 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/. */ + +#ifndef MSG_MAPI_MAIN_H_ +#define NSG_MAPI_MAIN_H_ + +#define MAX_NAME_LEN 256 +#define MAX_PW_LEN 256 +#define MAX_SESSIONS 50 +#define MAPI_SENDCOMPLETE_EVENT "SendCompletionEvent" + +#define MAPI_PROPERTIES_CHROME "chrome://messenger-mapi/locale/mapi.properties" +#define PREF_MAPI_WARN_PRIOR_TO_BLIND_SEND "mapi.blind-send.warn" +#define PREF_MAPI_BLIND_SEND_ENABLED "mapi.blind-send.enabled" + +#include "nspr.h" +#include "nsDataHashtable.h" +#include "nsClassHashtable.h" +#include "nsStringGlue.h" + +class nsMAPISession; + +class nsMAPIConfiguration +{ +private : + + static uint32_t session_generator; + static uint32_t sessionCount; + static nsMAPIConfiguration *m_pSelfRef; + PRLock *m_Lock; + uint32_t m_nMaxSessions; + + nsDataHashtable m_ProfileMap; + nsClassHashtable m_SessionMap; + nsMAPIConfiguration(); + ~nsMAPIConfiguration(); + +public : + static nsMAPIConfiguration *GetMAPIConfiguration(); + void OpenConfiguration(); + int16_t RegisterSession(uint32_t aHwnd, const char16_t *aUserName, \ + const char16_t *aPassword, bool aForceDownLoad, \ + bool aNewSession, uint32_t *aSession, const char *aIdKey); + bool IsSessionValid(uint32_t aSessionID); + bool UnRegisterSession(uint32_t aSessionID); + char16_t *GetPassword(uint32_t aSessionID); + void GetIdKey(uint32_t aSessionID, nsCString& aKey); + void *GetMapiListContext(uint32_t aSessionID); + void SetMapiListContext(uint32_t aSessionID, void *mapiListContext); + + // a util func + static HRESULT GetMAPIErrorFromNSError (nsresult res) ; +}; + +class nsMAPISession +{ + friend class nsMAPIConfiguration; + + private : + bool m_bIsForcedDownLoad; + bool m_bApp_or_Service; + uint32_t m_hAppHandle; + uint32_t m_nShared; + nsCString m_pIdKey; + nsString m_pProfileName; + nsString m_pPassword; + int32_t m_messageIndex; + void *m_listContext; // used by findNext + + public : + nsMAPISession(uint32_t aHwnd, const char16_t *aUserName, \ + const char16_t *aPassword, \ + bool aForceDownLoad, const char *aKey); + uint32_t IncrementSession(); + uint32_t DecrementSession(); + uint32_t GetSessionCount(); + char16_t *nsMAPISession::GetPassword(); + void GetIdKey(nsCString& aKey); + ~nsMAPISession(); + // For enumerating Messages... + void SetMapiListContext( void *listContext) { m_listContext = listContext; } + void *GetMapiListContext( ) { return m_listContext; } +}; + +#endif // MSG_MAPI_MAIN_H_ diff --git a/mailnews/mapi/mapihook/src/msgMapiSupport.cpp b/mailnews/mapi/mapihook/src/msgMapiSupport.cpp new file mode 100644 index 000000000..5c57f087d --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiSupport.cpp @@ -0,0 +1,151 @@ +/* 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 "nsCOMPtr.h" +#include "objbase.h" +#include "nsISupports.h" + +#include "mozilla/ModuleUtils.h" +#include "mozilla/Services.h" +#include "nsIObserverService.h" +#include "nsIAppStartupNotifier.h" +#include "nsIServiceManager.h" +#include "nsIComponentManager.h" +#include "nsICategoryManager.h" +#include "Registry.h" +#include "msgMapiSupport.h" + +#include "msgMapiImp.h" + +/** Implementation of the nsIMapiSupport interface. + * Use standard implementation of nsISupports stuff. + */ + +NS_IMPL_ISUPPORTS(nsMapiSupport, nsIMapiSupport, nsIObserver) + +NS_IMETHODIMP +nsMapiSupport::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) +{ + nsresult rv = NS_OK ; + + if (!strcmp(aTopic, "profile-after-change")) + return InitializeMAPISupport(); + + if (!strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) + return ShutdownMAPISupport(); + + nsCOMPtr observerService = + mozilla::services::GetObserverService(); + NS_ENSURE_TRUE(observerService, NS_ERROR_UNEXPECTED); + + rv = observerService->AddObserver(this,"profile-after-change", false); + if (NS_FAILED(rv)) return rv; + + rv = observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, false); + if (NS_FAILED(rv)) return rv; + + return rv; +} + + +nsMapiSupport::nsMapiSupport() +: m_dwRegister(0), + m_nsMapiFactory(nullptr) +{ +} + +nsMapiSupport::~nsMapiSupport() +{ +} + +NS_IMETHODIMP +nsMapiSupport::InitializeMAPISupport() +{ + ::OleInitialize(nullptr) ; + + if (m_nsMapiFactory == nullptr) // No Registering if already done. Sanity Check!! + { + m_nsMapiFactory = new CMapiFactory(); + + if (m_nsMapiFactory != nullptr) + { + HRESULT hr = ::CoRegisterClassObject(CLSID_CMapiImp, \ + m_nsMapiFactory, \ + CLSCTX_LOCAL_SERVER, \ + REGCLS_MULTIPLEUSE, \ + &m_dwRegister); + + if (FAILED(hr)) + { + m_nsMapiFactory->Release() ; + m_nsMapiFactory = nullptr; + return NS_ERROR_FAILURE; + } + } + } + + return NS_OK; +} + +NS_IMETHODIMP +nsMapiSupport::ShutdownMAPISupport() +{ + if (m_dwRegister != 0) + ::CoRevokeClassObject(m_dwRegister); + + if (m_nsMapiFactory != nullptr) + { + m_nsMapiFactory->Release(); + m_nsMapiFactory = nullptr; + } + + ::OleUninitialize(); + + return NS_OK ; +} + +NS_IMETHODIMP +nsMapiSupport::RegisterServer() +{ + // TODO: Figure out what kind of error propogation to pass back + ::RegisterServer(CLSID_CMapiImp, "Mozilla MAPI", "MozillaMapi", "MozillaMapi.1"); + return NS_OK; +} + +NS_IMETHODIMP +nsMapiSupport::UnRegisterServer() +{ + // TODO: Figure out what kind of error propogation to pass back + ::UnregisterServer(CLSID_CMapiImp, "MozillaMapi", "MozillaMapi.1"); + return NS_OK; +} + +NS_DEFINE_NAMED_CID(NS_IMAPISUPPORT_CID); + +NS_GENERIC_FACTORY_CONSTRUCTOR(nsMapiSupport) + +static const mozilla::Module::CategoryEntry kMAPICategories[] = { + { APPSTARTUP_CATEGORY, "Mapi Support", "service," NS_IMAPISUPPORT_CONTRACTID, }, + { NULL } +}; + +const mozilla::Module::CIDEntry kMAPICIDs[] = { + { &kNS_IMAPISUPPORT_CID, false, NULL, nsMapiSupportConstructor }, + { NULL } +}; + +const mozilla::Module::ContractIDEntry kMAPIContracts[] = { + { NS_IMAPISUPPORT_CONTRACTID, &kNS_IMAPISUPPORT_CID }, + { NULL } +}; + +static const mozilla::Module kMAPIModule = { + mozilla::Module::kVersion, + kMAPICIDs, + kMAPIContracts, + kMAPICategories +}; + +NSMODULE_DEFN(msgMapiModule) = &kMAPIModule; + + diff --git a/mailnews/mapi/mapihook/src/msgMapiSupport.h b/mailnews/mapi/mapihook/src/msgMapiSupport.h new file mode 100644 index 000000000..ff7ffca9f --- /dev/null +++ b/mailnews/mapi/mapihook/src/msgMapiSupport.h @@ -0,0 +1,34 @@ +/* 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/. */ + +#ifndef MSG_MAPI_SUPPORT_H_ +#define MSG_MAPI_SUPPORT_H_ + +#include "nsIObserver.h" +#include "nsIMapiSupport.h" +#include "msgMapiFactory.h" + +#define NS_IMAPISUPPORT_CID \ + {0x8967fed2, 0xc8bb, 0x11d5, \ + { 0xa3, 0xe9, 0x00, 0xb0, 0xd0, 0xf3, 0xba, 0xa7 }} + +class nsMapiSupport : public nsIMapiSupport, + public nsIObserver +{ + public : + nsMapiSupport(); + + // Declare all interface methods we must implement. + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSIMAPISUPPORT + + private : + ~nsMapiSupport(); + + DWORD m_dwRegister; + CMapiFactory *m_nsMapiFactory; +}; + +#endif // MSG_MAPI_SUPPORT_H_ -- cgit v1.2.3