windows-xp/Source/XPSP1/NT/com/mobile/syncmgr/test/outhndlr/handler.cpp

// implementation for app specific data
#include <objbase.h>

#include <Mapi.h>
#include <Mapix.h>
#include "MAPIDEFS.H"
#include "EDKMDB.H"
#include "mapispi.h"
#include "mapiform.h"
#include "mdbuix.h"

#pragma data_seg(".text")
#define INITGUID
#include <initguid.h>
#include <objbase.h>
#include "SyncHndl.h"
#include "priv.h"
#include "base.h"
#include "handler.h"
#pragma data_seg()

TCHAR szCLSIDDescription[] = TEXT("Outlook OneStop Handler");

typedef struct _tagProfileItem
{
struct _tagProfileItem *pNextProfileItem;
char *profileName; // pointer to profile name, only valid for lifetime of thread
DWORD dwThreadId; // thread that owns the profile.
} ProfileItem;

// global list of Profile items so mail knows what profile it has already done.
ProfileItem *g_pProfileItem = NULL; // pointer to first profile item

extern HINSTANCE g_hmodThisDll; // Handle to this DLL itself.
BOOL g_InCall = FALSE;

// general routine for creating a working thread to make calls on.

DWORD WINAPI WorkerThread( LPVOID lpArg );

// thread creation for PrepareForSync and synchronize, 
// for simplification in Initialize we spin a worker thread and then 
// post all incoming requests to it so don't have to working about
// api we are calling handling multiple threads.

typedef struct _tagWorkerThreadArgs
{
HANDLE hEvent; // Event to wait on for new thread to be created.
HRESULT hr; // return code of thread.
CMailHandler *pThis;
}  WorkerThreadArgs;


HRESULT CreateWorkerThread(DWORD *pdwThreadID,HANDLE *phThread,
			   CMailHandler *pThis)
{
HRESULT hr = E_FAIL;
HANDLE hNewThread = NULL;
WorkerThreadArgs ThreadArgs;


    *phThread = NULL;

    ThreadArgs.hEvent = CreateEvent(NULL,FALSE,FALSE,NULL);
    ThreadArgs.pThis = pThis;

    if (ThreadArgs.hEvent)
    {
	hNewThread = CreateThread(NULL,0,WorkerThread,&ThreadArgs,0,pdwThreadID);

	if (hNewThread)
	{
	   WaitForSingleObject(ThreadArgs.hEvent,INFINITE);
	   if (NOERROR == ThreadArgs.hr)
	   {
		*phThread = hNewThread;
		hr = NOERROR;
	   }
	   else
	   {
		CloseHandle(hNewThread); 
		hr = ThreadArgs.hr;
	   }

	}
	else
	{
	    hr = GetLastError();
	}

	CloseHandle(ThreadArgs.hEvent);
    }

    return hr;
}

typedef struct _tagArgs
{




} METHODARGS; // list of possible member for calling ThreadWndProc

// definitions for handler messages
#define WM_WORKERMSG_PREPFORSYNC (WM_USER+1)
#define WM_WORKERMSG_SYNCHRONIZE  (WM_USER+2)

#define DWL_THREADWNDPROCCLASS 0 // window long offset to MsgService Hwnd this ptr.

// WndProc for Worker thread
LRESULT CALLBACK  MsgThreadWndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
CMailHandler *pThis = (CMailHandler *) GetWindowLong(hWnd, DWL_THREADWNDPROCCLASS);

    switch (msg)
    {
	case WM_CREATE :
	    {
	    CREATESTRUCT *pCreateStruct = (CREATESTRUCT *) lParam;

	    SetWindowLong(hWnd, DWL_THREADWNDPROCCLASS,(LONG) pCreateStruct->lpCreateParams );
	    pThis = (CMailHandler *) pCreateStruct->lpCreateParams ;
	    }
	    break;
	case WM_DESTROY:
	    PostQuitMessage(0); // shut down this thread.
	    break;
	case WM_WORKERMSG_PREPFORSYNC:
	    pThis->PrepareForSyncCall();
	    break;
	case WM_WORKERMSG_SYNCHRONIZE:
	    pThis->SynchronizeCall();
	    break;
	default:
	    break;
    }

    return DefWindowProc(hWnd, msg, wParam, lParam);
}


DWORD WINAPI WorkerThread( LPVOID lpArg )
{
MSG msg;
HRESULT hr;
HRESULT hrCoInitialize;
WorkerThreadArgs *pThreadArgs = (WorkerThreadArgs *) lpArg;

				
   pThreadArgs->hr = NOERROR;

   hrCoInitialize = CoInitialize(NULL);

   // need to do a PeekMessage and then set an event to make sure
   // a message loop is created before the first PostMessage is sent.

   PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);

   // initialize the dialog box before returning to main thread.
   if (FAILED(hrCoInitialize) )
   {
	pThreadArgs->hr = E_OUTOFMEMORY;
   }
   else
   {
    ATOM aWndClass;
    WNDCLASS        xClass;


	// Register windows class.we need for handling thread communication
	xClass.style         = 0;
	xClass.lpfnWndProc   = MsgThreadWndProc;
	xClass.cbClsExtra    = 0;

	xClass.cbWndExtra    = sizeof(DWORD); // room for class this ptr
	xClass.hInstance     = g_hmodThisDll;
	xClass.hIcon         = NULL;
	xClass.hCursor       = NULL;
	xClass.hbrBackground = (HBRUSH) (COLOR_BACKGROUND + 1);
	xClass.lpszMenuName  = NULL;
	xClass.lpszClassName = "OutlookHandlerClass";

	aWndClass = RegisterClass( &xClass );


	pThreadArgs->pThis->m_hwnd = CreateWindowEx(0,
			  "OutlookHandlerClass",
			  TEXT(""),
			  // must use WS_POPUP so the window does not get
			  // assigned a hot key by user.
			  (WS_DISABLED | WS_POPUP),
			  CW_USEDEFAULT,
			  CW_USEDEFAULT,
			  CW_USEDEFAULT,
			  CW_USEDEFAULT,
			  NULL, // REVIEW, can we give it a parent to not show up.
			  NULL,
			  g_hmodThisDll,
			  pThreadArgs->pThis);

	pThreadArgs->hr =  pThreadArgs->pThis->m_hwnd ? NOERROR : E_UNEXPECTED;
    }

   hr = pThreadArgs->hr;

   // let the caller know the thread is done initializing.
   if (pThreadArgs->hEvent)
     SetEvent(pThreadArgs->hEvent);




   if (NOERROR == hr)
   {
       // sit in loop receiving messages.
       while (GetMessage(&msg, NULL, 0, 0)) 
       {
	     TranslateMessage(&msg);
	     DispatchMessage(&msg);
	}
   }

   if (SUCCEEDED(hrCoInitialize))
       CoUninitialize();

   return 0;
}





COneStopHandler* CreateHandlerObject()
{
    g_InCall = FALSE;
    return new CMailHandler();
}


STDMETHODIMP CMailHandler::DestroyHandler()
{
    
    if (g_InCall)
    {
	// MessageBox(NULL,"UNINIT","",1);
    }

    if (m_fMapiInitialized)
    {
	m_fMapiInitialized = FALSE;
	MAPIUninitialize();
    }

    delete this;
    return NOERROR;
}


CMailHandler::CMailHandler()
{
    m_fMapiInitialized = FALSE;
    m_dwSyncFlags = 0;
    m_hwnd = FALSE;

    m_fInPrepareForSync = FALSE;
    m_fInSynchronize = FALSE;
    m_pCurHandlerItem = NULL;
}

CMailHandler::~CMailHandler()
{

}


STDMETHODIMP CMailHandler::Initialize(DWORD dwReserved,DWORD dwSyncFlags,
					DWORD cbCookie,const BYTE *lpCooke)
{
HRESULT hr = NOERROR; // if already initialized just return NOERROR;
DWORD pThreadID;
HANDLE phThread;

    m_dwSyncFlags = dwSyncFlags;
    InitializeCriticalSection(&m_CriticalSection);

    // create workerthread
    if (hr = (NOERROR == CreateWorkerThread(&pThreadID,&phThread,
		       this))) 
    {

	if (FALSE == m_fMapiInitialized)
	{
	MAPIINIT_0 mapiInit;

		mapiInit.ulVersion  = MAPI_INIT_VERSION;
		mapiInit.ulFlags  = MAPI_MULTITHREAD_NOTIFICATIONS;

		if (NOERROR == (hr = MAPIInitialize( 0 /* &mapiInit) */) ) )
		{
			m_fMapiInitialized = TRUE;

			// if mapi was initialized, go ahead and get profile stuff.
			hr = GetProfileInformation();
		}
	}
    

    }


    return hr;
}

STDMETHODIMP CMailHandler::GetHandlerInfo(LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo)
{
    
    return E_NOTIMPL;
}

HRESULT CMailHandler::GetProfileInformation()
{
DWORD dwProfileCount = 0;
LPSYNCMGRHANDLERITEMS pOfflineItemsHolder;
LPHANDLERITEM pOfflineItem;
HRESULT hr;
LPPROFADMIN pProfAdmin;

    hr = MAPIAdminProfiles(0,&pProfAdmin);

    if (NOERROR == hr)
    {
    LPMAPITABLE pMapiTable;
    
	if (NOERROR == pProfAdmin->GetProfileTable(0,&pMapiTable))
	{
	LPSRowSet pRows;

	     SizedSPropTagArray(1, taga) = { 1, { PR_DISPLAY_NAME } };

	     if (NOERROR == pMapiTable->SetColumns((LPSPropTagArray)&taga, TBL_BATCH) )
	     {

		 while (NOERROR == pMapiTable->QueryRows(1,0,&pRows)
				&& (pRows->cRows > 0) )
		 {

			if (NULL == (pOfflineItemsHolder = GetOfflineItemsHolder()) )
			{  // if first item, set up the enumerator.
				pOfflineItemsHolder = CreateOfflineHandlerItemsList();

				// if still NULL, break out of loop
				if (NULL == pOfflineItemsHolder)
					break;

				SetOfflineItemsHolder(pOfflineItemsHolder);
			}

			// add the item to the list.
			if (pOfflineItem = (LPHANDLERITEM) AddOfflineItemToList(pOfflineItemsHolder,sizeof(HANDLERITEM) ))
			{
			char *pszProfileName = pRows->aRow[0].lpProps[0].Value.lpszA;
			SYNCMGRITEMID offType;

				pOfflineItem->pmdbx = NULL;
				pOfflineItem->lpSession = NULL;
				pOfflineItem->fItemCompleted = FALSE;
				memcpy(pOfflineItem->szProfileName,pszProfileName,
						strlen(pszProfileName) + 1);
				
				// add outlook specific data
				pOfflineItem->baseItem.offlineItem.cbSize = sizeof(SYNCMGRITEM);

				// review, for now just generate a new guid
				CoCreateGuid(&offType);


				pOfflineItem->baseItem.offlineItem.ItemID = offType;
//				pOfflineItem->baseItem.offlineItem.dwItemID = dwProfileCount + 1;
				pOfflineItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_CHECKED;
			
				pOfflineItem->baseItem.offlineItem.hIcon = 
							LoadIcon(g_hmodThisDll,MAKEINTRESOURCE(IDI_IOUTLOOK));
				pOfflineItem->baseItem.offlineItem.dwFlags = 0L;

				// for now, just use the path as the description
				// need to change this.

				// if we are not already unicode, have to convert now
				#ifndef UNICODE
					MultiByteToWideChar(CP_ACP,0,pszProfileName,-1,
								pOfflineItem->baseItem.offlineItem.wszItemName,MAX_SYNCMGRITEMNAME);
				#else

					// bug, can overrun buffer big time.
					// already unicode, just copy it in.
					memcpy(pOfflineItem->baseItem.offlineItem.wszItemName,
							pszProfileName,strlen(pszProfileName) + 1); 


				#endif // UNICODE

				GetItemIdForHandlerItem(CLSID_OneStopHandler,pOfflineItem->baseItem.offlineItem.wszItemName,
					    &pOfflineItem->baseItem.offlineItem.ItemID,TRUE);

				// don't do anything on the status for now.
				// pOfflineItem->offlineItem.wszStatus = NULL;

				++dwProfileCount; // increment the briefcase count.
			}

			MAPIFreeBuffer(pRows);

		     }
	     }

		pMapiTable->Release();
	}

	pProfAdmin->Release();
    }


    return dwProfileCount ? S_OK : S_FALSE; 
}


STDMETHODIMP CMailHandler::PrepareForSync(ULONG cbNumItems,SYNCMGRITEMID *pItemIDs,
							HWND hWndParent,DWORD dwReserved)

{
LPMAPITABLE     ptbl    = NULL;
LPSRowSet	prs	= NULL;
LPMDB		pmdb	= NULL;
LPSPropValue	pval	= NULL;
LPHANDLERITEM	pHandlerItem;

HRESULT hr = E_FAIL;
LPSYNCMGRSYNCHRONIZECALLBACK pOfflineSynchronizeCallback = GetOfflineSynchronizeCallback();
SYNCMGRPROGRESSITEM progItem;

	pHandlerItem = (LPHANDLERITEM) GetOfflineItemsHolder()->pFirstOfflineItem;
	
	if (m_fMapiInitialized)
	{
	    // loop through items setting state based on PrepareForSyncSettings

	    for ( ; pHandlerItem; pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem)
	    {
	    ULONG NumItemsCount = cbNumItems;
	    SYNCMGRITEMID *pCurItemID = pItemIDs;


		// see if item has been specified to sync, if not, update the state
		// to reflect this else go ahead and prepare.
		
		pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_UNCHECKED;

		while (NumItemsCount--)
		{
		    if (IsEqualGUID(*pCurItemID,pHandlerItem->baseItem.offlineItem.ItemID))
		    {
			pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_CHECKED;
			break;
		    }

		    ++pCurItemID;
		}
	    }

	    // we have now set the information. Call worker function
	    // on second thread to do the actual work.

	    m_hwndParent = hWndParent;
	    m_fInPrepareForSync = TRUE;

            //  should really be posting message so can return from call immediately
	     PrepareForSyncCall();

	}
	else
	{
	    progItem.mask = SYNCMGRPROGRESSITEM_STATUSTEXT | SYNCMGRPROGRESSITEM_STATUSTYPE ;	    progItem.lpcStatusText = L"Connecting to Server";

	    progItem.dwStatusType = SYNCMGRSTATUS_FAILED;
	    progItem.lpcStatusText = L"Could Not Initialize MAPI";


	    // applies to all items

	    while (pHandlerItem)
	    {
		if (pOfflineSynchronizeCallback)
		{
			pOfflineSynchronizeCallback->Progress(
			    (pHandlerItem->baseItem.offlineItem.ItemID)
								,&progItem);
		}

		pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem;

	    }

	    return E_FAIL;
	}

    return NOERROR;
}

// called on worker thread
void CMailHandler::PrepareForSyncCall()
{
LPMAPITABLE     ptbl    = NULL;
LPSRowSet	prs	= NULL;
LPMDB		pmdb	= NULL;
SRestriction	res;
SPropValue	val;
LPSPropValue	pval	= NULL;
LPHANDLERITEM	pHandlerItem;
SYNCMGRITEMID ItemID;

HRESULT hr = E_FAIL;
LPSYNCMGRSYNCHRONIZECALLBACK pOfflineSynchronizeCallback = GetOfflineSynchronizeCallback();
SYNCMGRPROGRESSITEM progItem;

// take critical section except for when calling MapiLogon
// if a setitemStatus comes in can wait for this to complete
// or kill handler after so long.

    EnterCriticalSection(&m_CriticalSection);

    pHandlerItem = (LPHANDLERITEM) GetOfflineItemsHolder()->pFirstOfflineItem;

    for ( ; pHandlerItem; pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem)
    {
    char *pname = pHandlerItem->szProfileName;

	if (pHandlerItem->baseItem.offlineItem.dwItemState == SYNCMGRITEMSTATE_CHECKED)
	{
	ProfileItem *pCurItem;
	BOOL fFoundMatch = FALSE;
	DWORD dwLogonFlags;
	    
	    // if item is already in the list then continue, else
	    // add the profile name to the list

	    pCurItem = g_pProfileItem;
	    while (pCurItem)
	    {
		if (0 == strcmp(pCurItem->profileName,pHandlerItem->szProfileName))
		{
		    fFoundMatch = TRUE;
		    break;
		}

		pCurItem = pCurItem->pNextProfileItem;
	    }
	    
	    if (fFoundMatch)
		continue;

	    // didn't find a match so go ahead and add this one.
	    pCurItem = (ProfileItem*) CoTaskMemAlloc(sizeof(ProfileItem));

	    if (pCurItem)
	    {	
		pCurItem->profileName = pHandlerItem->szProfileName;
		pCurItem->dwThreadId = GetCurrentThreadId();

		pCurItem->pNextProfileItem = g_pProfileItem;
		g_pProfileItem = pCurItem;
	    }

	
	    pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_CHECKED;

	    ItemID = pHandlerItem->baseItem.offlineItem.ItemID;
	    progItem.mask = SYNCMGRPROGRESSITEM_STATUSTEXT | SYNCMGRPROGRESSITEM_STATUSTYPE ;
	    progItem.lpcStatusText = L"Connecting to Server";
		progItem.dwStatusType = SYNCMGRSTATUS_PENDING;
		
	    if (pOfflineSynchronizeCallback)
		    pOfflineSynchronizeCallback->Progress(ItemID,&progItem); 

	    dwLogonFlags = MAPI_EXTENDED | MAPI_TIMEOUT_SHORT 
			    | MAPI_NEW_SESSION | MAPI_NO_MAIL;

	    if (SYNCMGRFLAG_MAYBOTHERUSER & m_dwSyncFlags)
	    {
		   dwLogonFlags |= MAPI_LOGON_UI;
	    }

	    m_pCurHandlerItem = pHandlerItem; // set handler item
	    LPMAPISESSION lpSession; // mapi logon session for this item.

	    LeaveCriticalSection(&m_CriticalSection);

	    if (NOERROR != (hr =  MAPILogonEx( (DWORD) m_hwndParent,
				    pname,NULL,
					     dwLogonFlags ,&lpSession)) )
	    {
		    
		    EnterCriticalSection(&m_CriticalSection); 

		    // if a SetItemStatus came in while logon then don't
		    // change the progress.

		    if (!pHandlerItem->fItemCompleted)
		    {
			progItem.mask |= SYNCMGRPROGRESSITEM_PROGVALUE
					    | SYNCMGRPROGRESSITEM_MAXVALUE;

			progItem.iProgValue = 1;
			progItem.iMaxValue = 1;
			progItem.lpcStatusText = L"Unable to Logon to Server";
			progItem.dwStatusType = SYNCMGRSTATUS_FAILED;
			    
			if (pOfflineSynchronizeCallback)
				pOfflineSynchronizeCallback->Progress(ItemID,&progItem);
		    }

		    continue;
	    }

	    
	    EnterCriticalSection(&m_CriticalSection); 

	    // if setitemstate came in during logon just release session
	    if (pHandlerItem->fItemCompleted)
	    {
		if (lpSession)
		    lpSession->Release();
		continue;
	    }

	    pHandlerItem->lpSession = lpSession;

	    // now make sure that there is a valid message store and we
	    // are connected to a remote server.
	    // Find the MessageStore
	    SizedSPropTagArray(2, taga) = { 2, { PR_ENTRYID, PR_MDB_PROVIDER } };

	    hr = pHandlerItem->lpSession->GetMsgStoresTable(0, &ptbl);
	    if (HR_FAILED(hr))
	    {
		    ptbl->Release();
		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;
		    continue;
	    }

	    hr = ptbl->SetColumns((LPSPropTagArray)&taga, TBL_BATCH);
	    if (HR_FAILED(hr))
	    {
		    ptbl->Release();
		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;
		    continue;
	    }

	    res.rt				= RES_PROPERTY;
	    res.res.resProperty.relop	= RELOP_EQ;
	    res.res.resProperty.lpProp	= &val;
	    res.res.resProperty.ulPropTag	= PR_MDB_PROVIDER;
	    val.ulPropTag			= PR_MDB_PROVIDER;
	    val.Value.bin.cb		= sizeof(MAPIUID);
	    val.Value.bin.lpb		= (LPBYTE)pbExchangeProviderPrimaryUserGuid;

	    hr = ptbl->FindRow(&res, BOOKMARK_BEGINNING, 0);
	    if (HR_FAILED(hr))
	    {
		    ptbl->Release();
		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;

		    continue;
	    }

	    hr = ptbl->QueryRows(1, 0, &prs);

	    ptbl->Release(); // All done with MapiTable Object.
	    ptbl = NULL;

	    if (HR_FAILED(hr))
	    {
		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;

		    continue;
	    }

	    if (prs->cRows == 0)
	    {
		    hr = ResultFromScode(MAPI_E_NOT_FOUND);

		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;

		    continue;
	    }


	    hr = pHandlerItem->lpSession->OpenMsgStore(0, prs->aRow[0].lpProps[0].Value.bin.cb,
			    (LPENTRYID)prs->aRow[0].lpProps[0].Value.bin.lpb, NULL,
			    MAPI_DEFERRED_ERRORS | MDB_TEMPORARY | MDB_NO_MAIL | MDB_WRITE,
			    &pmdb);

	    if (HR_FAILED(hr))
	    {
		pHandlerItem->lpSession->Release();
		pHandlerItem->lpSession = NULL;
		continue;;
	    }


	    // If offline then don't try to sync anything.
	    hr = HrGetOneProp((LPMAPIPROP) pmdb, PR_STATUS_CODE, &pval);

	    // Review - this returns a success code but indicates couldn't
	    //    get all the information.
	    if (HR_FAILED(hr))
	    {
		    pmdb->Release();

		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;

		    continue;
	    }

	    ULONG ulStatus = pval->Value.ul;
	    MAPIFreeBuffer(pval);

	    if (ulStatus & STATUS_OFFLINE)
	    {

		    progItem.mask |= SYNCMGRPROGRESSITEM_PROGVALUE
					| SYNCMGRPROGRESSITEM_MAXVALUE;

		    progItem.iProgValue = 1;
		    progItem.iMaxValue = 1;
		    progItem.lpcStatusText = L"Mail is Offline";
		    progItem.dwStatusType = SYNCMGRSTATUS_FAILED;

		    if (pOfflineSynchronizeCallback)
			    pOfflineSynchronizeCallback->Progress(ItemID,&progItem);


		    pmdb->Release();

		    pHandlerItem->lpSession->Release();
		    pHandlerItem->lpSession = NULL;

		    continue;
	    }


	    hr = pmdb->QueryInterface(IID_IMDBX, (LPVOID *)&pHandlerItem->pmdbx);

	    pmdb->Release(); 
	    pmdb = NULL; 

	    if (FAILED(hr))
	    {
		pHandlerItem->lpSession->Release();
		pHandlerItem->lpSession = NULL;
		pHandlerItem->pmdbx = NULL;
		continue;	
	    }

	    progItem.lpcStatusText = L"Connected to Server";

	    if (pOfflineSynchronizeCallback)
		    pOfflineSynchronizeCallback->Progress(ItemID,&progItem);
	}

    }

    m_fInPrepareForSync = FALSE;
    m_pCurHandlerItem = NULL;

    LeaveCriticalSection(&m_CriticalSection);

    // let caller know we are done preparing.
    if (pOfflineSynchronizeCallback)
	    pOfflineSynchronizeCallback->PrepareForSyncCompleted(NOERROR);

}

STDMETHODIMP CMailHandler::Synchronize(HWND hwnd)
{
    // set up hwnd then call syncrhonize on the worker thread
    m_hwndParent = hwnd;
    m_fInSynchronize = TRUE;
    m_pCurHandlerItem = NULL;

    // should be posting this so can return immediately but seem to be some mapi problems switching thread?
   // PostMessage(m_hwnd,WM_WORKERMSG_SYNCHRONIZE,0,0);

   SynchronizeCall();

    return NOERROR;
}

// called on worker thread
void CMailHandler::SynchronizeCall()
{
STDPROG			stdprog;
ULONG			ulFlags;
HRESULT			hr;
LPHANDLERITEM		pHandlerItem;
SYNCMGRITEMID		ItemID;
LPSYNCMGRSYNCHRONIZECALLBACK pOfflineSynchronizeCallback = GetOfflineSynchronizeCallback();


// stay in critical section except in synchronize out call.

    EnterCriticalSection(&m_CriticalSection);

    pHandlerItem = (LPHANDLERITEM) GetOfflineItemsHolder()->pFirstOfflineItem;

    for ( ; pHandlerItem; pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem)
    {

	ItemID = pHandlerItem->baseItem.offlineItem.ItemID;

	if (NULL == pHandlerItem->pmdbx 
		    || SYNCMGRITEMSTATE_UNCHECKED == pHandlerItem->baseItem.offlineItem.dwItemState)
	{
	     if (pHandlerItem->lpSession)
	     {
		pHandlerItem->lpSession->Release();
		pHandlerItem->lpSession = NULL;
	     }

	     continue;

	}

	// point to folder if only want to synchronize a single folder.
	ULONG cbEntryID = 0;
	LPENTRYID lpEntryID = 0;
	
	ulFlags = SYNC_OUTGOING_MAIL |
			SYNC_UPLOAD_HIERARCHY | SYNC_DOWNLOAD_HIERARCHY |
			SYNC_UPLOAD_FAVORITES | SYNC_DOWNLOAD_FAVORITES |
			SYNC_UPLOAD_VIEWS	  | SYNC_DOWNLOAD_VIEWS |
			SYNC_UPLOAD_CONTENTS  | SYNC_DOWNLOAD_CONTENTS 
			| SYNC_FORMS ;

	stdprog.hwndParent = NULL;
	stdprog.nProgCur = 0;
	stdprog.nProgMax = 100;
	stdprog.idAVI = 0;
	stdprog.szCaption = NULL;
	stdprog.ulFlags = 0;

	stdprog.hwndDlg = NULL;
	stdprog.fCancelled = FALSE;
	
	stdprog.dwStartTime = GetTickCount();
	stdprog.dwShowTime = 0;
	stdprog.hcursor = (HCURSOR) &ItemID; // overload teh hCursor with the itemID
	stdprog.wndprocCancel = (WNDPROC) GetOfflineSynchronizeCallback(); // overload wndprocCancel for Progress

	LPMAPISESSION lpSession = pHandlerItem->lpSession;

	m_fInSynchronize = FALSE;
	m_pCurHandlerItem = pHandlerItem;

	LeaveCriticalSection(&m_CriticalSection);

	hr = pHandlerItem->pmdbx->Synchronize(ulFlags,lpSession, 
			cbEntryID, lpEntryID, &stdprog,
			ProgressUpdate,
			(GETFORMMSGPROC)FormGetFormMessage);

	EnterCriticalSection(&m_CriticalSection);

	// Update the Progress Bar to complete status.
	if (NOERROR == hr)
	{
	SYNCMGRPROGRESSITEM progItem;

		progItem.mask = SYNCMGRPROGRESSITEM_STATUSTEXT
							    | SYNCMGRPROGRESSITEM_STATUSTYPE
							| SYNCMGRPROGRESSITEM_PROGVALUE
							| SYNCMGRPROGRESSITEM_MAXVALUE;

		progItem.iProgValue  = stdprog.nProgCur;
		progItem.iMaxValue = stdprog.nProgMax;

		if (stdprog.fCancelled == FALSE)
		{
			    progItem.dwStatusType = SYNCMGRSTATUS_SUCCEEDED;
			progItem.lpcStatusText = L"Update Completed Successfully";

			GetOfflineSynchronizeCallback()->Progress(ItemID,&progItem);
		}
		else
		{	progItem.dwStatusType =  SYNCMGRSTATUS_SKIPPED;
			progItem.lpcStatusText = L"";
			GetOfflineSynchronizeCallback()->Progress(ItemID,&progItem);
		}
	}
	else
	{
		    SYNCMGRPROGRESSITEM progItem;

		progItem.mask = SYNCMGRPROGRESSITEM_STATUSTEXT
							    | SYNCMGRPROGRESSITEM_STATUSTYPE
							| SYNCMGRPROGRESSITEM_PROGVALUE
							| SYNCMGRPROGRESSITEM_MAXVALUE;

		progItem.iProgValue  = stdprog.nProgCur;
		progItem.iMaxValue = stdprog.nProgMax;

		if (stdprog.fCancelled == FALSE)
		{
		    progItem.dwStatusType =  SYNCMGRSTATUS_FAILED;				
			progItem.lpcStatusText = L"Errors Occured";

		    GetOfflineSynchronizeCallback()->Progress(ItemID,&progItem);

		    //Log Errors
		    SYNCMGRLOGERRORINFO errorItem;
		    errorItem.mask = NULL;

		    //Log warning: One without more info
		    GetOfflineSynchronizeCallback()->LogError(SYNCMGRLOGLEVEL_WARNING,
							    L"Outlook had a warning occur.",
                                                            &errorItem);

		    errorItem.mask |= SYNCMGRLOGERROR_ERRORFLAGS;
		    errorItem.dwSyncMgrErrorFlags = SYNCMGRERRORFLAG_ENABLEJUMPTEXT ;

		    errorItem.mask |= SYNCMGRLOGERROR_ERRORID;
		    errorItem.ErrorID = CLSID_OneStopHandler ;

		    //Log error: One with more info
		    GetOfflineSynchronizeCallback()->LogError(SYNCMGRLOGLEVEL_ERROR,
							    L"Outlook had an error occur.",
							    &errorItem);

		    errorItem.ErrorID = IID_IMDBX;
		    //Log information: One with more info
		    GetOfflineSynchronizeCallback()->LogError(SYNCMGRLOGLEVEL_INFORMATION,
							    L"Outlook had lengthy informational log entry that was quite verbose and wordy, chalk full of needless verbage and diatribe, that the user will never spend any time reading because it was simply too long.",
							    &errorItem);

                    // now delete thsm
                    //GetOfflineSynchronizeCallback()->DeleteLogError(CLSID_OneStopHandler,0);
		}
	}

	pHandlerItem->fItemCompleted = TRUE;

	if (pHandlerItem->pmdbx)
	{
	    pHandlerItem->pmdbx->Release();
	    pHandlerItem->pmdbx = NULL; 
	}

	if (pHandlerItem->lpSession)
	{
	    pHandlerItem->lpSession->Release(); 
	    pHandlerItem->lpSession = NULL;
	}

	// when the synchronize is done it is okay to open a new session
	// to the same profile

	ProfileItem *pCurItem;
	ProfileItem profItemDummy;
	BOOL fFoundMatch = FALSE;
		
	// if item is already in the list then continue, else
	// add the profile name to the list

	profItemDummy.pNextProfileItem = g_pProfileItem;
	pCurItem = &profItemDummy;

	while (pCurItem->pNextProfileItem)
	{
	    if (0 == strcmp(pCurItem->pNextProfileItem->profileName,pHandlerItem->szProfileName))
	    {
	    ProfileItem *pMatch;

		pMatch = pCurItem->pNextProfileItem;
		pCurItem->pNextProfileItem = pMatch->pNextProfileItem;

		g_pProfileItem = profItemDummy.pNextProfileItem;
		CoTaskMemFree(pMatch);
		break;
	    }

	    pCurItem = pCurItem->pNextProfileItem;
	}
	


    }


    m_fInSynchronize = FALSE;
    m_pCurHandlerItem = NULL;

    LeaveCriticalSection(&m_CriticalSection);

    if (pOfflineSynchronizeCallback)
    {
	pOfflineSynchronizeCallback->SynchronizeCompleted(NOERROR);
    }



}




STDMETHODIMP CMailHandler::SetItemStatus(REFSYNCMGRITEMID ItemID,DWORD dwSyncMgrStatus)
{
LPHANDLERITEM pHandlerItem;
LPSYNCMGRSYNCHRONIZECALLBACK pOfflineSynchronizeCallback = GetOfflineSynchronizeCallback();
SYNCMGRPROGRESSITEM progItem;

    // m_pCurHandlerItem

    // either called before start PrepareForSync
    // in PrepareForsync
    // BetweenPrepareForSync and Synchronize
    // in synchronize
    // after synchronize.

    // 	pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_UNCHECKED;

    progItem.mask = SYNCMGRPROGRESSITEM_STATUSTYPE
					| SYNCMGRPROGRESSITEM_PROGVALUE
					| SYNCMGRPROGRESSITEM_MAXVALUE;

    progItem.iProgValue  = 10;
    progItem.iMaxValue = 10;
    progItem.dwStatusType = SYNCMGRSTATUS_SKIPPED;


    EnterCriticalSection(&m_CriticalSection);

    // find the HandlerItem associated with the ItemID.
    pHandlerItem = (LPHANDLERITEM) GetOfflineItemsHolder()->pFirstOfflineItem;
	
    for ( ; pHandlerItem; pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem)
    {
	if (IsEqualGUID(ItemID,(pHandlerItem->baseItem.offlineItem.ItemID)))
	{
	    break;
	}

    }

    // if item isn't complete try to stop it.
    if (pHandlerItem && !pHandlerItem->fItemCompleted)
    {

	// if the curItem isn't set then nothing is currently going on
	// with this item. If this is the case then just clean
	// it up and set the progress accordingly

	if (pHandlerItem != m_pCurHandlerItem)
	{
	    pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_UNCHECKED;

	    if (pHandlerItem->pmdbx)
	    {
		pHandlerItem->pmdbx->Release();
		pHandlerItem->pmdbx = NULL;
	    }   
	    
	    if (pHandlerItem->lpSession)
	    {
		pHandlerItem->lpSession->Release();
		pHandlerItem->lpSession = NULL;
	    }

	    pHandlerItem->fItemCompleted = TRUE;

	    if (pOfflineSynchronizeCallback)
		pOfflineSynchronizeCallback->Progress(ItemID,&progItem);

	}
	else
	{
	    // call is currently working on this item so just
	    // wait for now until the item finishes
	    // should rely wait and if doesn't abort after so long kill
	    
	    // if this is a prepareforsync set itemcomplted to true 
	    // and set the callback

	    if (m_fInPrepareForSync)
	    {
		pHandlerItem->fItemCompleted = TRUE;

		if (pOfflineSynchronizeCallback)
		    pOfflineSynchronizeCallback->Progress(ItemID,&progItem);
	    }



	}


    }

    LeaveCriticalSection(&m_CriticalSection);

    return NOERROR;
}


STDMETHODIMP CMailHandler::ShowError(HWND hWndParent,REFSYNCMGRERRORID ErrorID)
{
#if _IMPL
	// Can show any synchronization conflicts. Also gives a chance
	// to display any errors that occured during synchronization

	if (SYNCMGRFLAG_MAYBOTHERUSER & m_dwSyncFlags)
	{
		// can show any conflicts or errors that occured.

	}


        // FOR RETRYSYNC TEST FIND FIRST CHECKED ITEMid AND SET THIS

        LPHANDLERITEM pHandlerItem;

        pHandlerItem = (LPHANDLERITEM) GetOfflineItemsHolder()->pFirstOfflineItem;
	
	for ( ; pHandlerItem; pHandlerItem = (LPHANDLERITEM) pHandlerItem->baseItem.pNextOfflineItem)
	{
	    // see if item has been specified to sync, if not, update the state
	    // to reflect this else go ahead and prepare.
	    
	    if (pHandlerItem->baseItem.offlineItem.dwItemState = SYNCMGRITEMSTATE_CHECKED)
            {
                break;
            }

        }

    if (pHandlerItem)
    {
        *ppItemIDs = (SYNCMGRITEMID *) CoTaskMemAlloc(sizeof(SYNCMGRITEMID));
        *ppItemIDs[0] = pHandlerItem->baseItem.offlineItem.ItemID;
        *pcbNumItems = 1;
    }

#endif // _IMPL

  return E_NOTIMPL;
  //  return *pcbNumItems ? S_SYNCMGR_RETRYSYNC : 
}



// Help functions and callbacks

VOID CALLBACK ProgressUpdate(STDPROG *stg, LPSTR lpcStatusText, INT iCurValue, INT iMaxValue)
{
HRESULT hr;
ISyncMgrSynchronizeCallback *lpCallBack = 	(ISyncMgrSynchronizeCallback *) stg->wndprocCancel;
SYNCMGRITEMID* pItemID = (SYNCMGRITEMID *) stg->hcursor;
WCHAR StatusBuf[256];
DWORD dwoffset = 0;

	// status text we get back states "Synchronizing Folder 'inbox', 
	// we always want to wack off the Synchronizing

#ifdef _TRUNCATESTATUS
	if (lpcStatusText && (0 == strnicmp("Synchronizing ",lpcStatusText,sizeof("Synchronizing"))) )
	{
		dwoffset = sizeof("Synchronizing");
	}
#endif // _TRUNCATESTATUS

	
	if (0 ==  MultiByteToWideChar(CP_ACP,0,lpcStatusText + dwoffset,-1,
				StatusBuf,256))
	{
		*StatusBuf = L'\0';

	}


	stg->nProgCur = iCurValue;
	stg->nProgMax = iMaxValue;

	// now estimate the time remaining

	DWORD dwElapsed = GetTickCount() - 	stg->dwStartTime;
	DWORD dwTicksRemaining = 0;

	if (0 != iCurValue)
	{
		dwTicksRemaining = ((iMaxValue - iCurValue) * dwElapsed)/iCurValue;
	}

	SYNCMGRPROGRESSITEM progItem;

	progItem.mask = SYNCMGRPROGRESSITEM_STATUSTEXT
						| SYNCMGRPROGRESSITEM_STATUSTYPE
						| SYNCMGRPROGRESSITEM_PROGVALUE
						| SYNCMGRPROGRESSITEM_MAXVALUE;

	progItem.iProgValue  = iCurValue;
	progItem.iMaxValue = iMaxValue;
	progItem.lpcStatusText = StatusBuf;
	progItem.dwStatusType = SYNCMGRSTATUS_UPDATING;
	
	hr = lpCallBack->Progress(*pItemID,&progItem);


	if (S_SYNCMGR_CANCELITEM == hr || S_SYNCMGR_CANCELALL == hr)
	{ 
		stg->fCancelled = TRUE; // Stop the Transfer.
	}

}

extern "C" HRESULT FormGetFormMessage(LPMAPIFORMINFO pinfo, ULONG FAR *pulReg,
					LPSTR lpcClass, LPMESSAGE FAR *ppmsg); // in IFRMREGU.CPP

// Review, implementation in ifrmregu.cpp
HRESULT FormGetFormMessage(LPMAPIFORMINFO, ULONG FAR *,
                           LPSTR, LPMESSAGE FAR *)
{
    return ResultFromScode(MAPI_E_CALL_FAILED);
}





HRESULT HrGetOneProp(LPMAPIPROP lpIProp, ULONG ulTag, LPSPropValue* lppProp)
{
    SizedSPropTagArray(1,ptag) = {1, {ulTag}};
    ULONG   ulT;

    *lppProp = NULL;

    return lpIProp->GetProps((LPSPropTagArray)&ptag,0, &ulT, lppProp);
}