1439 lines
42 KiB
C++
1439 lines
42 KiB
C++
#include "pch.hxx"
|
|
#include "store.h"
|
|
#include "instance.h"
|
|
#include "msgfldr.h"
|
|
#include "secutil.h"
|
|
#include "storutil.h"
|
|
#include "fldrsync.h"
|
|
#include <conman.h>
|
|
#include "shlwapip.h"
|
|
#include "sync.h"
|
|
|
|
static char c_szFolderSyncWndClass[] = "Outlook Express FolderSync Window Class";
|
|
|
|
static const PFNCOPYFUNC c_rgpfnCopyMsgs[] =
|
|
{
|
|
&CFolderSync::CopyOpen,
|
|
&CFolderSync::CopySave,
|
|
&CFolderSync::CopySave2,
|
|
&CFolderSync::CopyDelete,
|
|
&CFolderSync::CopyDelete2,
|
|
};
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::CFolderSync
|
|
//--------------------------------------------------------------------------
|
|
CFolderSync::CFolderSync(void)
|
|
{
|
|
g_pInstance->DllAddRef();
|
|
m_cRef = 1;
|
|
m_pLocalStore = NULL;
|
|
m_pFldr = NULL;
|
|
m_tyFolder = FOLDER_INVALID;
|
|
m_idFolder = FOLDERID_INVALID;
|
|
m_idServer = FOLDERID_INVALID;
|
|
m_szAcctId[0] = 0;
|
|
m_pServer = NULL;
|
|
m_fConManAdvise = FALSE;
|
|
m_hwnd = NULL;
|
|
m_pCopy = NULL;
|
|
m_fImap = FALSE;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::~CFolderSync
|
|
//--------------------------------------------------------------------------
|
|
CFolderSync::~CFolderSync(void)
|
|
{
|
|
Assert(m_pCopy == NULL);
|
|
|
|
if (m_fConManAdvise && g_pConMan != NULL)
|
|
g_pConMan->Unadvise((IConnectionNotify *)this);
|
|
|
|
if (m_hwnd != NULL)
|
|
{
|
|
if (GetWindowThreadProcessId(m_hwnd, NULL) == GetCurrentThreadId())
|
|
{
|
|
DestroyWindow(m_hwnd);
|
|
}
|
|
else
|
|
{
|
|
SetWindowLongPtr(m_hwnd, GWLP_USERDATA, NULL);
|
|
PostMessage(m_hwnd, WM_CLOSE, 0, 0L);
|
|
}
|
|
}
|
|
|
|
if (m_pServer)
|
|
{
|
|
m_pServer->Close(MSGSVRF_HANDS_OFF_SERVER);
|
|
m_pServer->Release();
|
|
m_pServer = NULL;
|
|
}
|
|
|
|
SafeRelease(m_pLocalStore);
|
|
SafeRelease(m_pFldr);
|
|
|
|
// Release the Dll
|
|
g_pInstance->DllRelease();
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::QueryInterface
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::QueryInterface(REFIID riid, LPVOID *ppv)
|
|
{
|
|
if (IID_IUnknown == riid)
|
|
*ppv = (IMessageFolder *)this;
|
|
else if (IID_IMessageFolder == riid)
|
|
*ppv = (IMessageFolder *)this;
|
|
else if (IID_IDatabase == riid)
|
|
*ppv = (IDatabase *)this;
|
|
else if (IID_IServiceProvider == riid)
|
|
*ppv = (IServiceProvider *)this;
|
|
else
|
|
{
|
|
*ppv = NULL;
|
|
return(E_NOINTERFACE);
|
|
}
|
|
|
|
// AddRef It
|
|
((IUnknown *)*ppv)->AddRef();
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::AddRef
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CFolderSync::AddRef(void)
|
|
{
|
|
return InterlockedIncrement(&m_cRef);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::Release
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP_(ULONG) CFolderSync::Release(void)
|
|
{
|
|
LONG cRef = InterlockedDecrement(&m_cRef);
|
|
if (0 == cRef)
|
|
delete this;
|
|
return (ULONG)cRef;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::Initialize
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::Initialize(IMessageStore *pStore, IMessageServer *pServer,
|
|
OPENFOLDERFLAGS dwFlags, FOLDERID idFolder)
|
|
{
|
|
Assert(FALSE);
|
|
return(E_NOTIMPL);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::SetOwner
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::SetOwner(IStoreCallback *pDefaultCallback)
|
|
{
|
|
HRESULT hrResult;
|
|
|
|
TraceCall("CFolderSync::SetOwner");
|
|
|
|
if (NULL == m_pServer)
|
|
{
|
|
hrResult = E_FAIL;
|
|
goto exit;
|
|
}
|
|
|
|
hrResult = m_pServer->SetIdleCallback(pDefaultCallback);
|
|
if (FAILED(hrResult))
|
|
{
|
|
TraceResult(hrResult);
|
|
goto exit;
|
|
}
|
|
|
|
exit:
|
|
return hrResult;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::Synchronize
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::Synchronize(SYNCFOLDERFLAGS dwFlags, DWORD cHeaders, IStoreCallback *pCallback)
|
|
{
|
|
BOOL fOffline;
|
|
HRESULT hr;
|
|
|
|
// async
|
|
// if online, then synchronize folder
|
|
// if offline, no op (fail)
|
|
|
|
if (m_pServer == NULL)
|
|
{
|
|
// local folders don't sync.
|
|
// NOTE - This isn't failure - there's just nothing to do.
|
|
return (S_FALSE);
|
|
}
|
|
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
if(g_pConMan->IsAccountDisabled((LPSTR)m_szAcctId))
|
|
hr = S_FALSE;
|
|
else
|
|
hr = m_pServer->SynchronizeFolder(dwFlags, cHeaders, pCallback);
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::GetFolderId
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::GetFolderId(LPFOLDERID pidFolder)
|
|
{
|
|
Assert(NULL != pidFolder);
|
|
|
|
// local store operation only
|
|
|
|
*pidFolder = m_idFolder;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::GetMessageFolderId
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::GetMessageFolderId(MESSAGEID idMessage, LPFOLDERID pidFolder)
|
|
{
|
|
return(m_pFldr->GetMessageFolderId(idMessage, pidFolder));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::OpenMessage
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::OpenMessage(MESSAGEID idMessage,
|
|
OPENMESSAGEFLAGS dwFlags, IMimeMessage **ppMessage,
|
|
IStoreCallback *pCallback)
|
|
{
|
|
HRESULT hr;
|
|
BOOL fOffline;
|
|
FILEADDRESS faStart;
|
|
|
|
Assert(NULL != ppMessage);
|
|
|
|
// async
|
|
// if message is already downloaded
|
|
// open message in local store
|
|
// else
|
|
// if online, download message
|
|
// if offline, fail
|
|
|
|
hr = m_pFldr->OpenMessage(idMessage, dwFlags, ppMessage, NULL);
|
|
if (SUCCEEDED(hr))
|
|
return(hr);
|
|
|
|
if (hr == STORE_E_NOBODY && m_pServer != NULL && !ISFLAGSET(dwFlags, OPEN_MESSAGE_CACHEDONLY))
|
|
{
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
hr = m_pServer->GetMessage(idMessage, pCallback);
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::SaveMessage
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::SaveMessage(LPMESSAGEID pidMessage,
|
|
SAVEMESSAGEFLAGS dwOptions, MESSAGEFLAGS dwFlags,
|
|
IStream *pStreamIn, IMimeMessage *pMessage, IStoreCallback *pCallback)
|
|
{
|
|
HRESULT hr;
|
|
IStream *pStream;
|
|
DWORD dwOffline;
|
|
LPFILETIME pftRecv;
|
|
PROPVARIANT rVariant;
|
|
|
|
Assert(NULL != pMessage);
|
|
|
|
// save message to local store
|
|
// if online, upload message
|
|
// if offline, log transaction
|
|
|
|
if (m_pServer == NULL)
|
|
{
|
|
hr = m_pFldr->SaveMessage(pidMessage, dwOptions, dwFlags, pStreamIn, pMessage, NULL);
|
|
return(hr);
|
|
}
|
|
|
|
hr = _Offline(&dwOffline);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (dwOffline == CONN_STATE_NOT_CONNECTED)
|
|
{
|
|
hr = E_NOT_ONLINE;
|
|
}
|
|
else if (dwOffline == CONN_STATE_OFFLINE)
|
|
{
|
|
hr = g_pSync->CreateMessage(m_pFldr, pidMessage, dwOptions, dwFlags, pStreamIn, pMessage);
|
|
}
|
|
else
|
|
{
|
|
Assert(dwOffline == CONN_STATE_CONNECTED);
|
|
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
// the idStream can legally by null in the case of saving a draft
|
|
if (NULL == pStreamIn)
|
|
hr = pMessage->GetMessageSource(&pStream, COMMIT_ONLYIFDIRTY);
|
|
else
|
|
{
|
|
pStream = pStreamIn;
|
|
pStream->AddRef();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
rVariant.vt = VT_FILETIME;
|
|
if (SUCCEEDED(pMessage->GetProp(PIDTOSTR(PID_ATT_RECVTIME), 0, &rVariant)))
|
|
pftRecv = &rVariant.filetime;
|
|
else
|
|
pftRecv = NULL;
|
|
|
|
hr = m_pServer->PutMessage(m_idFolder, dwFlags, pftRecv, pStream, pCallback);
|
|
pStream->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::SetMessageStream
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::SetMessageStream(MESSAGEID idMessage,
|
|
IStream *pStream)
|
|
{
|
|
// pass through to the local store
|
|
Assert (NULL != m_pFldr);
|
|
Assert(NULL != pStream);
|
|
|
|
if (NULL == pStream)
|
|
return E_INVALIDARG;
|
|
|
|
return m_pFldr->SetMessageStream(idMessage, pStream);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::SetMessageFlags
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::SetMessageFlags(LPMESSAGEIDLIST pList,
|
|
LPADJUSTFLAGS pFlags, LPRESULTLIST pResults,
|
|
IStoreCallback *pCallback)
|
|
{
|
|
INewsStore *pNewsStore;
|
|
ADJUSTFLAGS localFlags, svrFlags;
|
|
MESSAGEFLAGS flags;
|
|
DWORD dwOffline;
|
|
HRESULT hr;
|
|
|
|
Assert(NULL != pFlags);
|
|
Assert(NULL == pList || 0 != pList->cMsgs);
|
|
|
|
// async
|
|
// save message flags to local store
|
|
// if online, upload message flags if necessary (some flags are irrelevant to server)
|
|
// if offline, log transaction if necessary
|
|
|
|
if (m_pServer == NULL)
|
|
return(m_pFldr->SetMessageFlags(pList, pFlags, pResults, NULL));
|
|
|
|
hr = _Offline(&dwOffline);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = m_pServer->GetServerMessageFlags(&flags);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
Assert(hr == S_OK || hr == S_FALSE);
|
|
|
|
// hr == S_FALSE
|
|
// this server doesn't have any flags that need to hit the server
|
|
|
|
localFlags = *pFlags;
|
|
|
|
if (hr == S_OK)
|
|
{
|
|
svrFlags = *pFlags;
|
|
svrFlags.dwAdd &= flags;
|
|
svrFlags.dwRemove &= flags;
|
|
|
|
localFlags.dwAdd &= ~flags;
|
|
localFlags.dwRemove &= ~flags;
|
|
|
|
if (0 != svrFlags.dwAdd ||
|
|
0 != svrFlags.dwRemove)
|
|
{
|
|
if (dwOffline == CONN_STATE_NOT_CONNECTED)
|
|
{
|
|
return(E_NOT_ONLINE);
|
|
}
|
|
else if (dwOffline == CONN_STATE_OFFLINE)
|
|
{
|
|
hr = g_pSync->SetMessageFlags(m_pFldr, pList, &svrFlags);
|
|
}
|
|
else
|
|
{
|
|
Assert(dwOffline == CONN_STATE_CONNECTED);
|
|
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
hr = m_pServer->SetMessageFlags(pList, &svrFlags, 0, pCallback);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (0 != localFlags.dwAdd ||
|
|
0 != localFlags.dwRemove)
|
|
{
|
|
hr = m_pFldr->SetMessageFlags(pList, &localFlags, pResults, NULL);
|
|
|
|
// mark news crossposts as read
|
|
if (m_tyFolder == FOLDER_NEWS &&
|
|
(!!(localFlags.dwAdd & ARF_READ) || !!(localFlags.dwRemove & ARF_READ)))
|
|
{
|
|
IServiceProvider *pService;
|
|
|
|
if (SUCCEEDED(m_pServer->QueryInterface(IID_IServiceProvider, (void **)&pService)))
|
|
{
|
|
if (SUCCEEDED(pService->QueryService(SID_MessageServer, IID_INewsStore, (void **)&pNewsStore)))
|
|
{
|
|
pNewsStore->MarkCrossposts(pList, !!(localFlags.dwAdd & ARF_READ));
|
|
|
|
pNewsStore->Release();
|
|
}
|
|
|
|
pService->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::DeleteMessages
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::DeleteMessages(DELETEMESSAGEFLAGS dwOptions,
|
|
LPMESSAGEIDLIST pList, LPRESULTLIST pResults,
|
|
IStoreCallback *pCallback)
|
|
{
|
|
ADJUSTFLAGS afFlags;
|
|
DWORD dwOffline;
|
|
HRESULT hr;
|
|
|
|
Assert(NULL == pList || pList->cMsgs > 0);
|
|
|
|
// if online, delete messages from server and local store
|
|
// if offline, log transaction
|
|
|
|
if (m_pServer == NULL || m_tyFolder == FOLDER_NEWS)
|
|
return(m_pFldr->DeleteMessages(dwOptions, pList, pResults, pCallback));
|
|
|
|
hr = _Offline(&dwOffline);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (dwOffline == CONN_STATE_NOT_CONNECTED)
|
|
{
|
|
hr = E_NOT_ONLINE;
|
|
}
|
|
else if (dwOffline == CONN_STATE_OFFLINE)
|
|
{
|
|
// [PaulHi] 4/8/99 Raid 63339
|
|
// Deleting from an HTTP folder (other than the 'deleted' folder)
|
|
// translates into a message move from the source folder to the
|
|
// 'deleted' folder. If offline we want the message copy to take
|
|
// place and then cache the message 'copy' just as would happen with
|
|
// an offline drag/drop copy operation.
|
|
FOLDERINFO fldrinfo;
|
|
BOOL bHMOffLineCopy = FALSE;
|
|
|
|
hr = m_pLocalStore->GetFolderInfo(m_idFolder, &fldrinfo);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if ( (fldrinfo.tyFolder == FOLDER_HTTPMAIL) && (fldrinfo.tySpecial != FOLDER_DELETED) &&
|
|
(fldrinfo.tySpecial != FOLDER_MSNPROMO) )
|
|
{
|
|
// Code stolen from CFolderSync::CopyMessages
|
|
IMessageFolder * pDeletedItems = NULL;
|
|
IMessageFolder * pDestLocal = NULL;
|
|
IServiceProvider * pService = NULL;
|
|
|
|
hr = g_pStore->OpenSpecialFolder(m_idServer, NULL, FOLDER_DELETED, &pDeletedItems);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pDeletedItems->QueryInterface(IID_IServiceProvider, (void **)&pService);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pService->QueryService(SID_LocalMessageFolder, IID_IMessageFolder, (void **)&pDestLocal);
|
|
pService->Release();
|
|
}
|
|
|
|
pDeletedItems->Release();
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
Assert(pDestLocal != NULL);
|
|
|
|
afFlags.dwAdd = 0;
|
|
afFlags.dwRemove = 0;
|
|
hr = g_pSync->CopyMessages(m_pFldr, pDestLocal, COPY_MESSAGE_MOVE, pList, &afFlags);
|
|
bHMOffLineCopy = TRUE;
|
|
|
|
pDestLocal->Release();
|
|
}
|
|
|
|
m_pLocalStore->FreeRecord(&fldrinfo);
|
|
}
|
|
}
|
|
|
|
// If the HM offline copy didn't occur, for whatever reason, revert to the original
|
|
// off line delete.
|
|
if (!bHMOffLineCopy)
|
|
hr = g_pSync->DeleteMessages(m_pFldr, dwOptions, pList);
|
|
}
|
|
else
|
|
{
|
|
Assert(dwOffline == CONN_STATE_CONNECTED);
|
|
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
hr = m_pServer->DeleteMessages(dwOptions, pList, pCallback);
|
|
}
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT CFolderSync::Initialize(IMessageStore *pStore, IMessageFolder *pLocalFolder,
|
|
IMessageServer *pServer, OPENFOLDERFLAGS dwFlags, FOLDERTYPE tyFolder,
|
|
FOLDERID idFolder, FOLDERID idServer)
|
|
{
|
|
WNDCLASSEX wc;
|
|
HRESULT hr;
|
|
FOLDERINFO info;
|
|
|
|
Assert(NULL != pStore);
|
|
|
|
// Save the Folder Type
|
|
m_tyFolder = tyFolder;
|
|
|
|
// Save the FolderId
|
|
m_idFolder = idFolder;
|
|
|
|
m_idServer = idServer;
|
|
|
|
// Save pStore
|
|
m_pLocalStore = pStore;
|
|
m_pLocalStore->AddRef();
|
|
|
|
if (pServer != NULL)
|
|
{
|
|
hr = m_pLocalStore->GetFolderInfo(m_idServer, &info);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
StrCpyN(m_szAcctId, info.pszAccountId, ARRAYSIZE(m_szAcctId));
|
|
m_fImap = (info.tyFolder == FOLDER_IMAP);
|
|
|
|
m_pLocalStore->FreeRecord(&info);
|
|
|
|
m_pServer = pServer;
|
|
m_pServer->AddRef();
|
|
|
|
hr = g_pConMan->Advise((IConnectionNotify *)this);
|
|
m_fConManAdvise = SUCCEEDED(hr);
|
|
}
|
|
|
|
if (pLocalFolder)
|
|
{
|
|
m_pFldr = pLocalFolder;
|
|
m_pFldr->AddRef();
|
|
}
|
|
else
|
|
{
|
|
hr = m_pLocalStore->OpenFolder(m_idFolder, NULL, dwFlags, &m_pFldr);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
}
|
|
|
|
wc.cbSize = sizeof(WNDCLASSEX);
|
|
if (!GetClassInfoEx(g_hInst, c_szFolderSyncWndClass, &wc))
|
|
{
|
|
wc.style = 0;
|
|
wc.lpfnWndProc = FolderSyncWndProc;
|
|
wc.cbClsExtra = 0;
|
|
wc.cbWndExtra = 0;
|
|
wc.hInstance = g_hInst;
|
|
wc.hIcon = NULL;
|
|
wc.hCursor = NULL;
|
|
wc.hbrBackground = NULL;
|
|
wc.lpszMenuName = NULL;
|
|
wc.lpszClassName = c_szFolderSyncWndClass;
|
|
wc.hIconSm = NULL;
|
|
if (RegisterClassEx(&wc) == 0 && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
|
|
return E_FAIL;
|
|
}
|
|
|
|
m_hwnd = CreateWindowEx(WS_EX_TOPMOST, c_szFolderSyncWndClass,
|
|
c_szFolderSyncWndClass, WS_POPUP, 1, 1, 1, 1, NULL,
|
|
NULL, g_hInst, (LPVOID)this);
|
|
if (m_hwnd == NULL)
|
|
return(E_FAIL);
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::Close()
|
|
{
|
|
HRESULT hr = S_OK;
|
|
if (m_pServer)
|
|
hr = m_pServer->Close(MSGSVRF_HANDS_OFF_SERVER);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFolderSync::_Offline(DWORD *pdwOffline)
|
|
{
|
|
BOOL fOffline;
|
|
HRESULT hr;
|
|
|
|
Assert(pdwOffline != NULL);
|
|
Assert(m_szAcctId[0] != 0);
|
|
|
|
fOffline = g_pConMan->IsGlobalOffline();
|
|
if (fOffline)
|
|
{
|
|
*pdwOffline = CONN_STATE_OFFLINE;
|
|
}
|
|
else
|
|
{
|
|
//Bug# 39337. We just give the operation to the sync object even if we are not connected.
|
|
//The sync object in turn figures out whether it needs to dial or not
|
|
|
|
/*
|
|
hr = g_pConMan->CanConnect(m_szAcctId);
|
|
|
|
*pdwOffline = (hr == S_OK) ? CONN_STATE_CONNECTED : CONN_STATE_NOT_CONNECTED;
|
|
*/
|
|
*pdwOffline = CONN_STATE_CONNECTED;
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::_OfflineServer(FOLDERID idServer, DWORD *pdwOffline)
|
|
{
|
|
HRESULT hr;
|
|
FOLDERINFO info;
|
|
BOOL fOffline;
|
|
|
|
Assert(pdwOffline != NULL);
|
|
|
|
hr = m_pLocalStore->GetFolderInfo(idServer, &info);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
if (info.tyFolder == FOLDER_LOCAL)
|
|
{
|
|
*pdwOffline = CONN_STATE_CONNECTED;
|
|
}
|
|
else
|
|
{
|
|
fOffline = g_pConMan->IsGlobalOffline();
|
|
if (fOffline)
|
|
{
|
|
*pdwOffline = CONN_STATE_OFFLINE;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
hr = g_pConMan->CanConnect(info.pszAccountId);
|
|
|
|
*pdwOffline = (hr == S_OK) ? CONN_STATE_CONNECTED : CONN_STATE_NOT_CONNECTED;
|
|
*/
|
|
*pdwOffline = CONN_STATE_CONNECTED;
|
|
}
|
|
}
|
|
|
|
m_pLocalStore->FreeRecord(&info);
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::QueryService(REFGUID guidService, REFIID riid, LPVOID *ppvObject)
|
|
{
|
|
IServiceProvider *pSP;
|
|
HRESULT hr = E_NOINTERFACE;
|
|
|
|
if (guidService == SID_LocalMessageFolder)
|
|
{
|
|
if (m_pFldr != NULL)
|
|
hr = m_pFldr->QueryInterface(riid, ppvObject);
|
|
}
|
|
else if (m_pServer && m_pServer->QueryInterface(IID_IServiceProvider, (LPVOID *)&pSP)==S_OK)
|
|
{
|
|
hr = pSP->QueryService(guidService, riid, ppvObject);
|
|
pSP->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFolderSync::OnBegin(STOREOPERATIONTYPE tyOperation, STOREOPERATIONINFO *pOpInfo, IOperationCancel *pCancel)
|
|
{
|
|
Assert(m_pCopy->type == SOT_INVALID);
|
|
Assert(m_pCopy->fAsync);
|
|
|
|
m_pCopy->type = tyOperation;
|
|
|
|
if (!m_pCopy->fBegin)
|
|
{
|
|
Assert(m_pCopy->pCallback != NULL);
|
|
m_pCopy->pCallback->OnBegin(SOT_COPYMOVE_MESSAGE, pOpInfo, (IOperationCancel *)this);
|
|
|
|
m_pCopy->fBegin = TRUE;
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::OnProgress(STOREOPERATIONTYPE tyOperation, DWORD dwCurrent, DWORD dwMax, LPCSTR pszStatus)
|
|
{
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::OnTimeout(LPINETSERVER pServer, LPDWORD pdwTimeout, IXPTYPE ixpServerType)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
return(m_pCopy->pCallback->OnTimeout(pServer, pdwTimeout, ixpServerType));
|
|
}
|
|
|
|
HRESULT CFolderSync::CanConnect(LPCSTR pszAccountId, DWORD dwFlags)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
return(m_pCopy->pCallback->CanConnect(pszAccountId, dwFlags));
|
|
}
|
|
|
|
HRESULT CFolderSync::OnLogonPrompt(LPINETSERVER pServer, IXPTYPE ixpServerType)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
return(m_pCopy->pCallback->OnLogonPrompt(pServer, ixpServerType));
|
|
}
|
|
|
|
HRESULT CFolderSync::OnComplete(STOREOPERATIONTYPE tyOperation, HRESULT hrComplete, LPSTOREOPERATIONINFO pOpInfo, LPSTOREERROR pErrorInfo)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
if (m_pCopy->type != tyOperation ||
|
|
m_pCopy->hr != S_FALSE)
|
|
return(S_OK);
|
|
|
|
Assert(hrComplete != S_FALSE);
|
|
|
|
m_pCopy->hr = hrComplete;
|
|
|
|
if (NULL != pErrorInfo)
|
|
{
|
|
BOOL fResult;
|
|
|
|
fResult = MemAlloc((void **)&m_pCopy->pErrorInfo, sizeof(STOREERROR));
|
|
if (FALSE == fResult)
|
|
{
|
|
TraceResult(E_OUTOFMEMORY);
|
|
}
|
|
else
|
|
{
|
|
// Make a copy of the STOREERROR so we can display rich errors to user
|
|
m_pCopy->pErrorInfo->hrResult = pErrorInfo->hrResult;
|
|
m_pCopy->pErrorInfo->uiServerError = pErrorInfo->uiServerError;
|
|
m_pCopy->pErrorInfo->hrServerError = pErrorInfo->hrServerError;
|
|
m_pCopy->pErrorInfo->dwSocketError = pErrorInfo->dwSocketError;
|
|
m_pCopy->pErrorInfo->pszProblem = PszDupA(pErrorInfo->pszProblem);
|
|
m_pCopy->pErrorInfo->pszDetails = PszDupA(pErrorInfo->pszDetails);
|
|
m_pCopy->pErrorInfo->pszAccount = PszDupA(pErrorInfo->pszAccount);
|
|
m_pCopy->pErrorInfo->pszServer = PszDupA(pErrorInfo->pszServer);
|
|
m_pCopy->pErrorInfo->pszFolder = PszDupA(pErrorInfo->pszFolder);
|
|
m_pCopy->pErrorInfo->pszUserName = PszDupA(pErrorInfo->pszUserName);
|
|
m_pCopy->pErrorInfo->pszProtocol = PszDupA(pErrorInfo->pszProtocol);
|
|
m_pCopy->pErrorInfo->ixpType = pErrorInfo->ixpType;
|
|
m_pCopy->pErrorInfo->dwPort = pErrorInfo->dwPort;
|
|
m_pCopy->pErrorInfo->fSSL = pErrorInfo->fSSL;
|
|
m_pCopy->pErrorInfo->dwFlags = pErrorInfo->dwFlags;
|
|
}
|
|
}
|
|
|
|
PostMessage(m_hwnd, WM_USER, 0, 0);
|
|
|
|
m_pCopy->type = SOT_INVALID;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFolderSync::OnPrompt(HRESULT hrError, LPCTSTR pszText, LPCTSTR pszCaption, UINT uType, INT *piUserResponse)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
return(m_pCopy->pCallback->OnPrompt(hrError, pszText, pszCaption, uType, piUserResponse));
|
|
}
|
|
|
|
HRESULT CFolderSync::GetParentWindow(DWORD dwReserved, HWND *phwndParent)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
return(m_pCopy->pCallback->GetParentWindow(dwReserved, phwndParent));
|
|
}
|
|
|
|
HRESULT CFolderSync::Cancel(CANCELTYPE tyCancel)
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
Assert(tyCancel != CT_INVALID);
|
|
|
|
m_pCopy->tyCancel = tyCancel;
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::OnConnectionNotify(CONNNOTIFY nCode, LPVOID pvData, CConnectionManager *pConMan)
|
|
{
|
|
FOLDERINFO info;
|
|
HRESULT hr;
|
|
|
|
Assert(m_pServer != NULL);
|
|
|
|
if (nCode == CONNNOTIFY_CONNECTED)
|
|
{
|
|
|
|
}
|
|
else if (nCode == CONNNOTIFY_WORKOFFLINE && pvData)
|
|
{
|
|
m_pServer->Close(MSGSVRF_DROP_CONNECTION);
|
|
}
|
|
else if (nCode == CONNNOTIFY_DISCONNECTED)
|
|
{
|
|
hr = g_pStore->GetFolderInfo(m_idServer, &info);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
CHAR szAccountId[CCHMAX_ACCOUNT_NAME];
|
|
|
|
if (SUCCEEDED(GetFolderAccountId(&info, szAccountId, ARRAYSIZE(szAccountId))))
|
|
{
|
|
if (!g_pConMan->CanConnect(szAccountId))
|
|
m_pServer->Close(MSGSVRF_DROP_CONNECTION);
|
|
}
|
|
|
|
g_pStore->FreeRecord(&info);
|
|
}
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
void CFolderSync::_FreeCopyInfo()
|
|
{
|
|
Assert(m_pCopy != NULL);
|
|
|
|
if (m_pCopy->pDest != NULL)
|
|
m_pCopy->pDest->Release();
|
|
if (m_pCopy->pDestLocal != NULL)
|
|
m_pCopy->pDestLocal->Release();
|
|
if (m_pCopy->pList != NULL)
|
|
MemFree(m_pCopy->pList);
|
|
|
|
if (m_pCopy->pErrorInfo != NULL)
|
|
{
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszProblem);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszDetails);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszAccount);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszServer);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszFolder);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszUserName);
|
|
SafeMemFree(m_pCopy->pErrorInfo->pszProtocol);
|
|
MemFree(m_pCopy->pErrorInfo);
|
|
}
|
|
|
|
MemFree(m_pCopy);
|
|
m_pCopy = NULL;
|
|
}
|
|
|
|
HRESULT AllBodiesDownloaded(IMessageFolder *pFldr, LPMESSAGEIDLIST pList)
|
|
{
|
|
MESSAGEINFO Message;
|
|
DWORD iMsg;
|
|
HRESULT hr;
|
|
|
|
Assert(pFldr != NULL);
|
|
Assert(pList != NULL);
|
|
|
|
hr = S_OK;
|
|
|
|
for (iMsg = 0; iMsg < pList->cMsgs; iMsg++)
|
|
{
|
|
ZeroMemory(&Message, sizeof(MESSAGEINFO));
|
|
Message.idMessage = pList->prgidMsg[iMsg];
|
|
if (DB_S_FOUND == pFldr->FindRecord(IINDEX_PRIMARY, COLUMNS_ALL, &Message, NULL))
|
|
{
|
|
if (0 == (Message.dwFlags & ARF_HASBODY))
|
|
hr = S_FALSE;
|
|
|
|
pFldr->FreeRecord(&Message);
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
break;
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::CopyMessages
|
|
//--------------------------------------------------------------------------
|
|
STDMETHODIMP CFolderSync::CopyMessages(IMessageFolder *pDest,
|
|
COPYMESSAGEFLAGS dwOptions,
|
|
LPMESSAGEIDLIST pList,
|
|
LPADJUSTFLAGS pFlags,
|
|
LPRESULTLIST pResults,
|
|
IStoreCallback *pCallback)
|
|
{
|
|
HWND hwnd;
|
|
DWORD dwOfflineSrc, dwOfflineDst;
|
|
HRESULT hr;
|
|
IMessageFolder *pDestLocal;
|
|
ADJUSTFLAGS aflags;
|
|
FOLDERID idDst, idServerDst;
|
|
IServiceProvider *pService;
|
|
FOLDERINFO fiSource = {0};
|
|
|
|
Assert(pDest != NULL);
|
|
Assert(pList != NULL);
|
|
|
|
hr = pDest->GetFolderId(&idDst);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
hr = GetFolderServerId(idDst, &idServerDst);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
if (m_pServer == NULL)
|
|
{
|
|
dwOfflineSrc = CONN_STATE_CONNECTED;
|
|
}
|
|
else
|
|
{
|
|
hr = _Offline(&dwOfflineSrc);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
}
|
|
|
|
if (m_tyFolder == FOLDER_IMAP)
|
|
{
|
|
if (pFlags != NULL)
|
|
{
|
|
aflags = *pFlags;
|
|
}
|
|
else
|
|
{
|
|
aflags.dwAdd = 0;
|
|
aflags.dwRemove = 0;
|
|
}
|
|
aflags.dwRemove |= ARF_ENDANGERED;
|
|
pFlags = &aflags;
|
|
}
|
|
|
|
if (m_idServer == idServerDst)
|
|
{
|
|
if (m_pServer == NULL)
|
|
{
|
|
hr = m_pFldr->CopyMessages(pDest, dwOptions, pList, pFlags, pResults, pCallback);
|
|
}
|
|
else if (dwOfflineSrc == CONN_STATE_NOT_CONNECTED)
|
|
{
|
|
hr = E_NOT_ONLINE;
|
|
}
|
|
else if (dwOfflineSrc == CONN_STATE_CONNECTED)
|
|
{
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
hr = m_pServer->CopyMessages(pDest, dwOptions, pList, pFlags, pCallback);
|
|
}
|
|
else
|
|
{
|
|
Assert(dwOfflineSrc == CONN_STATE_OFFLINE);
|
|
|
|
pDestLocal = NULL;
|
|
|
|
hr = pDest->QueryInterface(IID_IServiceProvider, (void **)&pService);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pService->QueryService(SID_LocalMessageFolder, IID_IMessageFolder, (void **)&pDestLocal);
|
|
|
|
pService->Release();
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
Assert(pDestLocal != NULL);
|
|
hr = g_pSync->CopyMessages(m_pFldr, pDestLocal, dwOptions, pList, pFlags);
|
|
|
|
pDestLocal->Release();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
hr = _OfflineServer(idServerDst, &dwOfflineDst);
|
|
if (FAILED(hr))
|
|
return(hr);
|
|
|
|
if (dwOfflineDst == CONN_STATE_NOT_CONNECTED)
|
|
return(E_NOT_ONLINE);
|
|
|
|
Assert(m_pCopy == NULL);
|
|
if (m_pCopy != NULL)
|
|
return(E_FAIL);
|
|
|
|
if (dwOfflineSrc != CONN_STATE_CONNECTED)
|
|
{
|
|
hr = AllBodiesDownloaded(m_pFldr, pList);
|
|
if (FAILED(hr))
|
|
{
|
|
return(hr);
|
|
}
|
|
else if (hr == S_FALSE)
|
|
{
|
|
pCallback->GetParentWindow(0, &hwnd);
|
|
AthMessageBoxW(hwnd, MAKEINTRESOURCEW(idsAthena),
|
|
!!(COPY_MESSAGE_MOVE & dwOptions) ? MAKEINTRESOURCEW(idsCantMoveNotDownloaded) : MAKEINTRESOURCEW(idsCantCopyNotDownloaded),
|
|
0, MB_OK | MB_ICONEXCLAMATION);
|
|
|
|
return(E_NOT_ONLINE);
|
|
}
|
|
}
|
|
|
|
// Bug# 94639
|
|
// If the src and dest servers are not the same, and if the source is Hotmail Deleted Items folder
|
|
// disallow move.
|
|
// For Hotmail accounts Deleted Items folder is managed by the Hotmail servers.
|
|
// So the users cannot manually delete or move messages.
|
|
// Hence, disallow moving from Deleted Items.
|
|
// Instead ask if the user wants to copy the message
|
|
if ((m_idServer != idServerDst) && (FOLDER_HTTPMAIL == m_tyFolder))
|
|
{
|
|
IF_FAILEXIT(hr = m_pLocalStore->GetFolderInfo(m_idFolder, &fiSource));
|
|
if (FOLDER_DELETED == fiSource.tySpecial)
|
|
{
|
|
if (IDNO == AthMessageBoxW(m_hwnd, MAKEINTRESOURCEW(idsAthena),
|
|
MAKEINTRESOURCEW(idsHttpNoMoveCopy), 0, MB_YESNO))
|
|
{
|
|
// Just return S_OK;
|
|
hr = S_OK;
|
|
goto exit;
|
|
}
|
|
else
|
|
{
|
|
// Change the move flags to copy.
|
|
dwOptions = (dwOptions & ~COPY_MESSAGE_MOVE);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!MemAlloc((void **)&m_pCopy, sizeof(COPYINFO)))
|
|
return(E_OUTOFMEMORY);
|
|
|
|
ZeroMemory(m_pCopy, sizeof(COPYINFO));
|
|
m_pCopy->fSrcOffline = (dwOfflineSrc != CONN_STATE_CONNECTED);
|
|
m_pCopy->fDestOffline = (dwOfflineDst != CONN_STATE_CONNECTED);
|
|
m_pCopy->hr = S_OK;
|
|
m_pCopy->pDest = pDest;
|
|
pDest->AddRef();
|
|
m_pCopy->fMove = !!(COPY_MESSAGE_MOVE & dwOptions);
|
|
hr = CloneMessageIDList(pList, &m_pCopy->pList);
|
|
if (FAILED(hr))
|
|
{
|
|
_FreeCopyInfo();
|
|
return(hr);
|
|
}
|
|
|
|
if (m_pCopy->fDestOffline)
|
|
{
|
|
hr = m_pCopy->pDest->QueryInterface(IID_IServiceProvider, (void **)&pService);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pService->QueryService(SID_LocalMessageFolder, IID_IMessageFolder, (void **)&m_pCopy->pDestLocal);
|
|
|
|
pService->Release();
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
_FreeCopyInfo();
|
|
return(E_INVALIDARG);
|
|
}
|
|
}
|
|
|
|
if (pFlags != NULL)
|
|
m_pCopy->AdjustFlags = *pFlags;
|
|
|
|
m_pCopy->pCallback = pCallback;
|
|
|
|
hr = _CopyMessageState();
|
|
|
|
exit:
|
|
m_pLocalStore->FreeRecord(&fiSource);
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT CFolderSync::CopyOpen()
|
|
{
|
|
HRESULT hr;
|
|
MESSAGEINFO mi = {0};
|
|
LPMESSAGEINFO pmi = NULL;
|
|
|
|
if (m_pCopy->iMsg >= m_pCopy->pList->cMsgs)
|
|
{
|
|
m_pCopy->state = COPY_STATE_DONE;
|
|
return(S_OK);
|
|
}
|
|
|
|
Assert(m_pCopy->pStream == NULL);
|
|
|
|
// initialize message info with the message id
|
|
mi.idMessage = m_pCopy->pList->prgidMsg[m_pCopy->iMsg];
|
|
|
|
// find the row
|
|
hr = GetMessageInfo(m_pFldr, m_pCopy->pList->prgidMsg[m_pCopy->iMsg], &mi);
|
|
if (FAILED(hr))
|
|
goto exit;
|
|
|
|
pmi = &mi;
|
|
|
|
if (0 == mi.faStream || !!(mi.dwFlags & ARF_ARTICLE_EXPIRED))
|
|
{
|
|
// if the server is NULL and we don't have a body stream,
|
|
// then something is wrong with the message. we skip the
|
|
// bad message and move onto the next one.
|
|
if (NULL == m_pServer || m_pCopy->fSrcOffline)
|
|
{
|
|
m_pCopy->state = COPY_STATE_DELETE2;
|
|
hr = S_OK;
|
|
}
|
|
else if (!m_pCopy->fSrcRequested)
|
|
{
|
|
Assert(m_pServer != NULL);
|
|
|
|
hr = m_pServer->GetMessage(m_pCopy->pList->prgidMsg[m_pCopy->iMsg], (IStoreCallback *)this);
|
|
if (hr == E_PENDING)
|
|
m_pCopy->fSrcRequested = TRUE;
|
|
Assert(FAILED(hr));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = m_pFldr->OpenStream(ACCESS_READ, mi.faStream, &m_pCopy->pStream);
|
|
if (FAILED(hr))
|
|
goto exit;
|
|
m_pCopy->state = COPY_STATE_SAVE;
|
|
}
|
|
|
|
exit:
|
|
if (NULL != pmi)
|
|
m_pFldr->FreeRecord(pmi);
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT CFolderSync::CopySave()
|
|
{
|
|
DWORD dwFlags;
|
|
HRESULT hr;
|
|
MESSAGEINFO Message;
|
|
MESSAGEID id;
|
|
IMimeMessage *pMessage = NULL;
|
|
|
|
Assert(m_pCopy->pStream != NULL);
|
|
|
|
dwFlags = 0;
|
|
|
|
ZeroMemory(&Message, sizeof(MESSAGEINFO));
|
|
Message.idMessage = m_pCopy->pList->prgidMsg[m_pCopy->iMsg];
|
|
if (DB_S_FOUND == m_pFldr->FindRecord(IINDEX_PRIMARY, COLUMNS_ALL, &Message, NULL))
|
|
{
|
|
dwFlags = Message.dwFlags;
|
|
m_pFldr->FreeRecord(&Message);
|
|
}
|
|
|
|
if (m_pCopy->AdjustFlags.dwRemove != 0)
|
|
dwFlags &= ~m_pCopy->AdjustFlags.dwRemove;
|
|
if (m_pCopy->AdjustFlags.dwAdd != 0)
|
|
dwFlags |= m_pCopy->AdjustFlags.dwAdd;
|
|
|
|
// create a mime message
|
|
hr = m_pFldr->OpenMessage(m_pCopy->pList->prgidMsg[m_pCopy->iMsg], OPEN_MESSAGE_SECURE, &pMessage, NOSTORECALLBACK);
|
|
if (FAILED(hr))
|
|
goto exit;
|
|
|
|
if (m_pCopy->fDestOffline)
|
|
{
|
|
Assert(m_pCopy->pDestLocal != NULL);
|
|
hr = g_pSync->CreateMessage(m_pCopy->pDestLocal, &id, SAVE_MESSAGE_GENID, dwFlags, m_pCopy->pStream, pMessage);
|
|
}
|
|
else
|
|
{
|
|
hr = m_pCopy->pDest->SaveMessage(&id, SAVE_MESSAGE_GENID, dwFlags, m_pCopy->pStream, pMessage, (IStoreCallback *)this);
|
|
}
|
|
|
|
if (hr == E_PENDING || SUCCEEDED(hr))
|
|
m_pCopy->state = COPY_STATE_SAVE2;
|
|
|
|
exit:
|
|
if (NULL != pMessage)
|
|
pMessage->Release();
|
|
|
|
m_pCopy->pStream->Release();
|
|
m_pCopy->pStream = NULL;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT CFolderSync::CopySave2()
|
|
{
|
|
if (m_pCopy->fMove)
|
|
{
|
|
m_pCopy->state = COPY_STATE_DELETE;
|
|
}
|
|
else
|
|
{
|
|
m_pCopy->state = COPY_STATE_OPEN;
|
|
m_pCopy->iMsg++;
|
|
m_pCopy->fSrcRequested = FALSE;
|
|
|
|
m_pCopy->pCallback->OnProgress(SOT_COPYMOVE_MESSAGE, m_pCopy->iMsg, m_pCopy->pList->cMsgs, NULL);
|
|
}
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::CopyDelete()
|
|
{
|
|
MESSAGEIDLIST list;
|
|
HRESULT hr;
|
|
MESSAGEID id;
|
|
ADJUSTFLAGS afFlags;
|
|
|
|
list.cMsgs = 1;
|
|
id = m_pCopy->pList->prgidMsg[m_pCopy->iMsg];
|
|
list.prgidMsg = &id;
|
|
|
|
if (m_pServer != NULL)
|
|
{
|
|
if (m_pCopy->fSrcOffline)
|
|
{
|
|
if (m_fImap)
|
|
{
|
|
afFlags.dwAdd = ARF_ENDANGERED;
|
|
afFlags.dwRemove = 0;
|
|
hr = g_pSync->SetMessageFlags(m_pFldr, &list, &afFlags);
|
|
}
|
|
else
|
|
{
|
|
#ifdef DEAD
|
|
hr = g_pSync->DeleteMessages(m_pFldr, DELETE_MESSAGE_NOTRASHCAN, &list);
|
|
#endif // DEAD
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = m_pServer->DeleteMessages(DELETE_MESSAGE_NOTRASHCAN | DELETE_MESSAGE_NOPROMPT | DELETE_MESSAGE_MAYIGNORENOTRASH, &list, (IStoreCallback *)this);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = m_pFldr->DeleteMessages(DELETE_MESSAGE_NOTRASHCAN | DELETE_MESSAGE_NOPROMPT, &list, NULL, NOSTORECALLBACK);
|
|
}
|
|
|
|
if (hr == E_PENDING || SUCCEEDED(hr))
|
|
m_pCopy->state = COPY_STATE_DELETE2;
|
|
|
|
return(hr);
|
|
}
|
|
|
|
HRESULT CFolderSync::CopyDelete2()
|
|
{
|
|
m_pCopy->state = COPY_STATE_OPEN;
|
|
m_pCopy->iMsg++;
|
|
m_pCopy->fSrcRequested = FALSE;
|
|
|
|
m_pCopy->pCallback->OnProgress(SOT_COPYMOVE_MESSAGE, m_pCopy->iMsg, m_pCopy->pList->cMsgs, NULL);
|
|
|
|
return(S_OK);
|
|
}
|
|
|
|
HRESULT CFolderSync::_CopyMessageState()
|
|
{
|
|
BOOL fBegin;
|
|
HRESULT hr;
|
|
HWND hwnd;
|
|
IStoreCallback *pCallback;
|
|
|
|
Assert(m_pCopy != NULL);
|
|
Assert(m_pCopy->hr != S_FALSE);
|
|
Assert(m_pCopy->hr != E_PENDING);
|
|
|
|
if (FAILED(m_pCopy->hr) && m_pCopy->state == COPY_STATE_OPEN && m_pCopy->fSrcRequested)
|
|
{
|
|
m_pCopy->fDownloadFail = TRUE;
|
|
m_pCopy->hr = S_OK;
|
|
m_pCopy->iMsg++;
|
|
m_pCopy->fSrcRequested = FALSE;
|
|
}
|
|
|
|
if (FAILED(m_pCopy->hr))
|
|
{
|
|
hr = m_pCopy->hr;
|
|
}
|
|
else
|
|
{
|
|
while (TRUE)
|
|
{
|
|
if (m_pCopy->tyCancel != CT_INVALID)
|
|
{
|
|
m_pCopy->state = COPY_STATE_DONE;
|
|
hr = S_FALSE;
|
|
break;
|
|
}
|
|
|
|
hr = (this->*(c_rgpfnCopyMsgs[m_pCopy->state]))();
|
|
|
|
if (FAILED(hr) || m_pCopy->state == COPY_STATE_DONE)
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (hr == E_PENDING)
|
|
{
|
|
Assert(m_pCopy->type == SOT_INVALID);
|
|
m_pCopy->fAsync = TRUE;
|
|
m_pCopy->hr = S_FALSE;
|
|
}
|
|
else if (FAILED(hr) || m_pCopy->state == COPY_STATE_DONE)
|
|
{
|
|
fBegin = m_pCopy->fBegin;
|
|
#ifdef DEBUG
|
|
if (fBegin)
|
|
Assert(m_pCopy->fAsync);
|
|
#endif // DEBUG
|
|
pCallback = m_pCopy->pCallback;
|
|
|
|
if (fBegin)
|
|
{
|
|
if (m_pCopy->fDownloadFail && SUCCEEDED(hr))
|
|
{
|
|
if (SUCCEEDED(pCallback->GetParentWindow(0, &hwnd)))
|
|
{
|
|
AthMessageBoxW(hwnd, MAKEINTRESOURCEW(idsAthena),
|
|
m_pCopy->fMove ? MAKEINTRESOURCEW(idsMoveDownloadFail) : MAKEINTRESOURCEW(idsCopyDownloadFail),
|
|
NULL, MB_ICONEXCLAMATION | MB_OK);
|
|
}
|
|
}
|
|
|
|
pCallback->OnComplete(SOT_COPYMOVE_MESSAGE, hr, NULL, m_pCopy->pErrorInfo);
|
|
}
|
|
|
|
_FreeCopyInfo();
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
LRESULT CALLBACK CFolderSync::FolderSyncWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
HRESULT hr;
|
|
CFolderSync *pThis;
|
|
|
|
pThis = (CFolderSync *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
|
|
if (NULL == pThis && msg != WM_CREATE)
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
|
|
switch(msg)
|
|
{
|
|
case WM_CREATE:
|
|
Assert(pThis == NULL);
|
|
pThis = (CFolderSync *)((CREATESTRUCT *)lParam)->lpCreateParams;
|
|
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);
|
|
break;
|
|
|
|
case WM_USER:
|
|
pThis->_CopyMessageState();
|
|
break;
|
|
}
|
|
|
|
return(DefWindowProc(hwnd, msg, wParam, lParam));
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::ConnectionAddRef
|
|
//
|
|
// Purpose: users of IMessageFolder need to keep alive the underlying server
|
|
// object if they plan of re-using the same server connection as
|
|
// another user of the same IMessageTable. eg. a note and a view window
|
|
// This allows us to not have to re-auth for operations that could
|
|
// be potentially expensive
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CFolderSync::ConnectionAddRef()
|
|
{
|
|
if (m_pServer)
|
|
m_pServer->ConnectionAddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------
|
|
// CFolderSync::ConnectionRelease
|
|
//
|
|
// Purpose: figure it out
|
|
//--------------------------------------------------------------------------
|
|
HRESULT CFolderSync::ConnectionRelease()
|
|
{
|
|
if (m_pServer)
|
|
m_pServer->ConnectionRelease();
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFolderSync::GetAdBarUrl(IStoreCallback *pCallback)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
Assert(pCallback != NULL);
|
|
if (pCallback == NULL)
|
|
return(E_INVALIDARG);
|
|
|
|
if (m_pServer)
|
|
hr = m_pServer->GetAdBarUrl(pCallback);
|
|
|
|
return(hr);
|
|
}
|