windows-server-2003/inetcore/outlookexpress/wabw/wabapi/hotsync.c

//  
//  HotSync.c
//
//  Contains code to synchronize addresses and groups with
//  HotMail servers
//

#define COBJMACROS
#include <_apipch.h>
#include <wab.h>
#define COBJMACROS
#include "HotSync.h"
#include "iso8601.h"
#include "uimisc.h"
#include "ui_cflct.h"
#include "ui_pwd.h"
#include "useragnt.h"

typedef enum {
    CIS_STRING = 0,
    CIS_BOOL,
    CIS_DWORD
}CIS_TYPE;

typedef struct CONTACTINFO_STRUCTURE
{
    CIS_TYPE    tType;
    DWORD       dwOffset;
}CONTACTINFO_STRUCTURE;

enum {
    idcisHref = 0,
    idcisId,
    idcisType,
    idcisModified,
    idcisDisplayName,
    idcisGivenName,
    idcisSurname,
    idcisNickName,
    idcisEmail,
    idcisHomeStreet,
    idcisHomeCity, 
    idcisHomeState, 
    idcisHomePostalCode, 
    idcisHomeCountry, 
    idcisCompany, 
    idcisWorkStreet, 
    idcisWorkCity, 
    idcisWorkState, 
    idcisWorkPostalCode, 
    idcisWorkCountry, 
    idcisHomePhone, 
    idcisHomeFax, 
    idcisWorkPhone, 
    idcisWorkFax, 
    idcisMobilePhone, 
    idcisOtherPhone, 
    idcisBday,
    idcisPager
};

CONTACTINFO_STRUCTURE   g_ContactInfoStructure[] = 
{
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHref)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszId)}, 
    {CIS_DWORD,  offsetof(HTTPCONTACTINFO, tyContact)},
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszModified)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszDisplayName)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszGivenName)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszSurname)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszNickname)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszEmail)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomeStreet)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomeCity)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomeState)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomePostalCode)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomeCountry)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszCompany)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkStreet)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkCity)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkState)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkPostalCode)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkCountry)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomePhone)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszHomeFax)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkPhone)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszWorkFax)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszMobilePhone)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszOtherPhone)}, 
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszBday)},
    {CIS_STRING, offsetof(HTTPCONTACTINFO, pszPager)}
};

#define CIS_FIRST_DATA_FIELD    5

#define CIS_GETSTRING(pci, i)  (*((char **)(&((char *)pci)[g_ContactInfoStructure[i].dwOffset])))
#define CIS_GETTYPE(i)         (g_ContactInfoStructure[i].tType)

IHTTPMailCallbackVtbl vtblIHTTPMAILCALLBACK = {
    VTABLE_FILL
    WABSync_QueryInterface,
    WABSync_AddRef,
    WABSync_Release,
    WABSync_OnTimeout,
    WABSync_OnLogonPrompt,
    WABSync_OnPrompt,
    WABSync_OnStatus,
    WABSync_OnError,
    WABSync_OnCommand,
    WABSync_OnResponse,
    WABSync_GetParentWindow
};



enum {
    ieid_PR_DISPLAY_NAME = 0,
    ieid_PR_OBJECT_TYPE,
    ieid_PR_ENTRYID,
	ieid_PR_LAST_MODIFICATION_TIME,
	ieid_PR_WAB_HOTMAIL_CONTACTIDS,
	ieid_PR_WAB_HOTMAIL_SERVERIDS,
	ieid_PR_WAB_HOTMAIL_MODTIMES,
    ieid_Max
};

static SizedSPropTagArray(ieid_Max, ptaEidSync)=
{
    ieid_Max,
    {
        PR_DISPLAY_NAME,
        PR_OBJECT_TYPE,
        PR_ENTRYID,
        PR_LAST_MODIFICATION_TIME,
        PR_ENTRYID,
        PR_ENTRYID,
        PR_ENTRYID
    }
};

enum {
    ieidc_PR_DISPLAY_NAME = 0,
    ieidc_PR_OBJECT_TYPE,
    ieidc_PR_ENTRYID,
	ieidc_PR_LAST_MODIFICATION_TIME,
    ieidc_PR_GIVEN_NAME,
    ieidc_PR_SURNAME,
    ieidc_PR_NICKNAME,
    ieidc_PR_EMAIL_ADDRESS,
    ieidc_PR_HOME_ADDRESS_STREET,
    ieidc_PR_HOME_ADDRESS_CITY,
    ieidc_PR_HOME_ADDRESS_STATE_OR_PROVINCE,
    ieidc_PR_HOME_ADDRESS_POSTAL_CODE,
    ieidc_PR_HOME_ADDRESS_COUNTRY,
    ieidc_PR_COMPANY_NAME,
    ieidc_PR_BUSINESS_ADDRESS_STREET,
    ieidc_PR_BUSINESS_ADDRESS_CITY,
    ieidc_PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE,
    ieidc_PR_BUSINESS_ADDRESS_POSTAL_CODE,
    ieidc_PR_BUSINESS_ADDRESS_COUNTRY,
    ieidc_PR_HOME_TELEPHONE_NUMBER,
    ieidc_PR_HOME_FAX_NUMBER,
    ieidc_PR_BUSINESS_TELEPHONE_NUMBER,
    ieidc_PR_BUSINESS_FAX_NUMBER,
    ieidc_PR_MOBILE_TELEPHONE_NUMBER,
    ieidc_PR_OTHER_TELEPHONE_NUMBER,
    ieidc_PR_BIRTHDAY,
    ieidc_PR_PAGER,
    ieidc_PR_CONTACT_EMAIL_ADDRESSES,
    ieidc_PR_CONTACT_DEFAULT_ADDRESS_INDEX,
#ifdef HM_GROUP_SYNCING
    ieidc_PR_WAB_DL_ENTRIES,
    ieidc_PR_WAB_DL_ONEOFFS,
#endif
	ieidc_PR_WAB_HOTMAIL_CONTACTIDS,
	ieidc_PR_WAB_HOTMAIL_SERVERIDS,
	ieidc_PR_WAB_HOTMAIL_MODTIMES,
    ieidc_Max
};

static SizedSPropTagArray(ieidc_Max, ptaEidCSync)=
{
    ieidc_Max,
    {
        PR_DISPLAY_NAME,
        PR_OBJECT_TYPE,
        PR_ENTRYID,
        PR_LAST_MODIFICATION_TIME,
        PR_GIVEN_NAME,
        PR_SURNAME,
        PR_NICKNAME,
        PR_EMAIL_ADDRESS,
        PR_HOME_ADDRESS_STREET,
        PR_HOME_ADDRESS_CITY,
        PR_HOME_ADDRESS_STATE_OR_PROVINCE,
        PR_HOME_ADDRESS_POSTAL_CODE,
        PR_HOME_ADDRESS_COUNTRY,
        PR_COMPANY_NAME,
        PR_BUSINESS_ADDRESS_STREET,
        PR_BUSINESS_ADDRESS_CITY,
        PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE,
        PR_BUSINESS_ADDRESS_POSTAL_CODE,
        PR_BUSINESS_ADDRESS_COUNTRY,
        PR_HOME_TELEPHONE_NUMBER,
        PR_HOME_FAX_NUMBER,
        PR_BUSINESS_TELEPHONE_NUMBER,
        PR_BUSINESS_FAX_NUMBER,
        PR_MOBILE_TELEPHONE_NUMBER,
        PR_OTHER_TELEPHONE_NUMBER,
        PR_BIRTHDAY,
        PR_PAGER_TELEPHONE_NUMBER,
        PR_CONTACT_EMAIL_ADDRESSES,
        PR_CONTACT_DEFAULT_ADDRESS_INDEX,
#ifdef HM_GROUP_SYNCING
        PR_WAB_DL_ENTRIES,
        PR_ENTRYID,
#endif
        PR_ENTRYID,
        PR_ENTRYID,
        PR_ENTRYID,
    }
};

// HM Nickname invalid characters
const ULONG MAX_INVALID_ARRAY_INDEX = 123;
static BOOL bInvalidCharArray[] = 
{
    TRUE,           // 0
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,           // 9
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,           // 19
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,
    TRUE,           // 29
    TRUE,
    TRUE,
    TRUE,           // 32 (x20) Space
    TRUE,           //          !
    TRUE,           //          "
    TRUE,           //          #
    TRUE,           //          $
    TRUE,           //          %
    TRUE,           //          &
    TRUE,           //          '
    TRUE,           //          (
    TRUE,           //          )
    TRUE,           // 42       *
    TRUE,           //          +
    TRUE,           //          ,
    TRUE,           //          -
    TRUE,           //          .
    TRUE,           //          /
    FALSE,          //          0
    FALSE,          //          1
    FALSE,          //          2
    FALSE,          //          3
    FALSE,          // 52       4
    FALSE,          //          5
    FALSE,          //          6
    FALSE,          //          7
    FALSE,          //          8
    FALSE,          //          9
    TRUE,           //          :
    TRUE,           //          ;
    TRUE,           //          <
    TRUE,           //          =
    TRUE,           // 62       >
    TRUE,           //          ?
    TRUE,           //          @
    FALSE,          //          A
    FALSE,          //          B
    FALSE,          //          C
    FALSE,          //          D
    FALSE,          //          E
    FALSE,          //          F
    FALSE,          //          G
    FALSE,          // 72       H
    FALSE,          //          I
    FALSE,          //          J
    FALSE,          //          K
    FALSE,          //          L
    FALSE,          //          M
    FALSE,          //          N
    FALSE,          //          O
    FALSE,          //          P
    FALSE,          //          Q
    FALSE,          // 82       R
    FALSE,          //          S
    FALSE,          //          T
    FALSE,          //          U
    FALSE,          //          V
    FALSE,          //          W
    FALSE,          //          X
    FALSE,          //          Y
    FALSE,          //          Z
    TRUE,           //          [
    TRUE,           // 92       '\'
    TRUE,           //          ]
    TRUE,           //          ^
    FALSE,          //          _
    TRUE,           //          `
    FALSE,          //          a
    FALSE,          //          b
    FALSE,          //          c
    FALSE,          //          d
    FALSE,          //          e
    FALSE,          // 102      f
    FALSE,          //          g
    FALSE,          //          h
    FALSE,          //          i
    FALSE,          //          j
    FALSE,          //          k
    FALSE,          //          l
    FALSE,          //          m
    FALSE,          //          n
    FALSE,          //          o
    FALSE,          // 112      p
    FALSE,          //          q
    FALSE,          //          r
    FALSE,          //          s
    FALSE,          //          t
    FALSE,          //          u
    FALSE,          //          v
    FALSE,          //          w
    FALSE,          //          x
    FALSE,          //          y
    FALSE,          // 122      z
};

extern HRESULT InitUserIdentityManager(LPIAB lpIAB, IUserIdentityManager ** lppUserIdentityManager);

// Address Book Sync Window Class Name
LPTSTR g_lpszSyncKey = TEXT("Software\\Microsoft\\WAB\\Synchronization\\");

LPTSTR g_szSyncClass =  TEXT("WABSyncView");
extern VOID CenterDialog(HWND hwndDlg);

#define WM_SYNC_NEXTSTATE           (WM_USER + 4)
#define WM_SYNC_NEXTOP              (WM_USER + 5)
#define SafeCoMemFree(_pv) \
    if (_pv) { \
        CoTaskMemFree(_pv); \
        _pv = NULL; \
    } \
    else 


#ifdef HM_GROUP_SYNCING
HRESULT HrSynchronize(HWND hWnd, LPADRBOOK lpIAB, LPCTSTR pszAccountID, BOOL bSyncGroups)
#else
HRESULT HrSynchronize(HWND hWnd, LPADRBOOK lpIAB, LPCTSTR pszAccountID)
#endif
{
    HRESULT hr;
    LPWABSYNC   pWabSync = NULL;

//    if (!bIsThereACurrentUser((LPIAB)lpIAB))
//        return E_FAIL;

    // [PaulHi] Raid 62149  Check to see if user is connected
    {
        DWORD   dwConnectedState;
        TCHAR   tszCaption[256];
        TCHAR   tszMessage[256];

        if ( !InternetGetConnectedState(&dwConnectedState, 0) || (dwConnectedState & INTERNET_CONNECTION_OFFLINE) )
        {
            LoadString(hinstMapiX, idsSyncError, tszCaption, CharSizeOf(tszCaption));
            if (dwConnectedState & INTERNET_CONNECTION_OFFLINE)
                LoadString(hinstMapiX, idsOffline, tszMessage, CharSizeOf(tszMessage));
            else
                LoadString(hinstMapiX, idsNoInternetConnect, tszMessage, CharSizeOf(tszMessage));
            MessageBox(hWnd, tszMessage, tszCaption, MB_ICONEXCLAMATION | MB_OK);

            return E_FAIL;
        }
    }

    // Create the wab sync object
    hr = WABSync_Create(&pWabSync);
    if (FAILED(hr))
        goto exit;
    // initializing it kicks off the whole process
#ifdef HM_GROUP_SYNCING
    // [PaulHi] 2/22/99  Hotmail syncing is now done in two passes.  The first pass is
    // as before and synchronizes the normal email contacts.  The second pass synchronizes
    // the group contacts.  Group contacts contain references to email contacts so email
    // contacts must be completely synchronized before groups can be synchronized.
    hr = WABSync_Initialize(pWabSync, hWnd, lpIAB, pszAccountID, bSyncGroups);
#else
    hr = WABSync_Initialize(pWabSync, hWnd, lpIAB, pszAccountID);
#endif

exit:
    WABSync_Release((IHTTPMailCallback*)pWabSync);

    return hr;
}

static LPSTR _StrDup(LPCSTR pszStr)
{
  	LPMALLOC	lpMalloc;
    LPSTR       pszResult = NULL;
    
    if (!pszStr)
        return NULL;

    CoGetMalloc(MEMCTX_TASK, &lpMalloc);
    if (lpMalloc)
    {
        DWORD cchSize = (lstrlenA(pszStr) + 1);
        pszResult = (LPSTR) lpMalloc->lpVtbl->Alloc(lpMalloc, cchSize * sizeof(pszResult[0]));

        if (pszResult)
            StrCpyNA(pszResult, pszStr, cchSize);
        lpMalloc->lpVtbl->Release(lpMalloc);
    }

    return pszResult;
}

void _FixHotmailDate(LPSTR pszDate)
{
    if (!pszDate)
        return;

    while (*pszDate)
    {
        if (*pszDate == 'T')
        {
            *pszDate = 0;
            break;
        }

        if (*pszDate == '.')
            *pszDate = '-';

        pszDate++;
    }
}

BOOL    LogTransactions(LPWABSYNC pWabSync)
{
    BOOL fInit = FALSE, fLogging = FALSE;
    LPTSTR  pszLogKey = TEXT("Software\\Microsoft\\Outlook Express\\5.0\\Mail");
    LPTSTR  pszLogValue = TEXT("Log HTTPMail (0/1)");
    IUserIdentityManager * lpUserIdentityManager = NULL;
    IUserIdentity * lpUserIdentity = NULL;
    HRESULT hr;
    HKEY hkeyIdentity = NULL, hkeyLog = NULL;
    DWORD   dwValue, dwType, dwSize;

    if(!bIsWABSessionProfileAware((LPIAB)(pWabSync->m_pAB)))
        goto exit;

    if(HR_FAILED(hr = InitUserIdentityManager((LPIAB)(pWabSync->m_pAB), &lpUserIdentityManager)))
        goto exit;
    
    fInit = TRUE;

    if(HR_FAILED(hr = lpUserIdentityManager->lpVtbl->GetIdentityByCookie(lpUserIdentityManager, 
                                                                        (GUID *)&UID_GIBC_CURRENT_USER,
                                                                        &lpUserIdentity)))
        goto exit;

    if (HR_FAILED(hr = lpUserIdentity->lpVtbl->OpenIdentityRegKey(lpUserIdentity, 
                                                                KEY_READ, &hkeyIdentity)))
        goto exit;
    
    if (RegOpenKeyEx(hkeyIdentity, pszLogKey, 0, KEY_READ, &hkeyLog) != ERROR_SUCCESS)
        goto exit;

    dwSize = sizeof(DWORD);

    if (RegQueryValueEx(hkeyLog, pszLogValue, NULL, &dwType, (LPBYTE) &dwValue, &dwSize) != ERROR_SUCCESS)
        goto exit;

    fLogging = (dwValue == 1);
exit:
    if(fInit)
        UninitUserIdentityManager((LPIAB)(pWabSync->m_pAB));

    if(lpUserIdentity)
        lpUserIdentity->lpVtbl->Release(lpUserIdentity);

    if (hkeyLog)
        RegCloseKey(hkeyLog);

    if (hkeyIdentity)
        RegCloseKey(hkeyIdentity);
    
    return fLogging;
}

DWORD   CountHTTPMailAccounts(LPIAB lpIAB)
{
    IImnAccountManager2 *lpAcctMgr;
    IImnEnumAccounts *pEnumAccts = NULL;
    DWORD dwCount = 0;
    HRESULT hr;

    if (FAILED(hr = InitAccountManager(lpIAB, &lpAcctMgr, NULL)) || NULL == lpAcctMgr)
        goto exit;

    if (FAILED(hr = lpAcctMgr->lpVtbl->Enumerate(lpAcctMgr, SRV_HTTPMAIL,&pEnumAccts)))
        goto exit;

    if (FAILED(hr = pEnumAccts->lpVtbl->GetCount(pEnumAccts, &dwCount)))
        dwCount = 0;

exit:
    if( pEnumAccts)
        pEnumAccts->lpVtbl->Release(pEnumAccts);

    return dwCount;
}

HRESULT _FindHTTPMailAccount(HWND hwnd, IImnAccountManager2 *lpAcctMgr, LPSTR pszAcctName, ULONG ccb)
{
    IImnEnumAccounts *pEnumAccts = NULL;
    DWORD dwCount = 0;
    IImnAccount *pAccount = NULL;
    HRESULT hr;

    Assert(lpAcctMgr);

    if (FAILED(hr = lpAcctMgr->lpVtbl->Enumerate(lpAcctMgr, SRV_HTTPMAIL,&pEnumAccts)))
        goto exit;

    if (FAILED(hr = pEnumAccts->lpVtbl->GetCount(pEnumAccts, &dwCount)) || dwCount == 0)
        goto exit;

    if (dwCount > 1)
    {
        if (!ChooseHotmailServer(hwnd, pEnumAccts, pszAcctName, ccb))
        {
            hr = E_UserCancel;
            goto exit;
        }
    }
    else
    {
        if (FAILED(hr = pEnumAccts->lpVtbl->GetNext(pEnumAccts, &pAccount)))
            goto exit;

        if (FAILED(hr = pAccount->lpVtbl->GetProp(pAccount, AP_ACCOUNT_ID, pszAcctName, &ccb)))
            goto exit;
    }
    
    hr = S_OK;
exit:
    if( pAccount)
        pAccount->lpVtbl->Release(pAccount);

    if( pEnumAccts)
        pEnumAccts->lpVtbl->Release(pEnumAccts);

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//  HrMakeContactId
//
//  Helper function to convert ANSI strings and create UNICODE contact ID
//  string.
///////////////////////////////////////////////////////////////////////////////
HRESULT hrMakeContactId(
    LPTSTR  lptszContactId,     // [out]
    int     nCharNum,           // [in]
    LPCTSTR lptcszProfileId,    // [in]
    LPCSTR  lpcszAccountId,     // [in]
    LPCSTR  lpcszLoginName)     // [in]
{
    HRESULT hr = S_OK;
    LPWSTR  lpwszAccountId = NULL;
    LPWSTR  lpwszLoginName = NULL; 

    // Validate arguments
    if ( !lptszContactId ||
         !lptcszProfileId ||
         !lpcszAccountId ||
         !lpcszLoginName)
    {
        Assert(0);
        return ERROR_INVALID_PARAMETER;
    }

    // Check buffer size.  Account for the two extra '-' characters.
    if ( nCharNum <= (lstrlen(lptcszProfileId) + lstrlenA(lpcszAccountId) + lstrlenA(lpcszLoginName) + 2) )
    {
        Assert(0);
        return ERROR_INSUFFICIENT_BUFFER;
    }

    lpwszAccountId = ConvertAtoW(lpcszAccountId);
    lpwszLoginName = ConvertAtoW(lpcszLoginName);

    if (!lpwszAccountId || !lpwszLoginName)
    {
        Assert(0);
        hr = E_FAIL;
    }
    else
    {
        wnsprintf(lptszContactId, nCharNum, TEXT("%s-%s-%s"), lptcszProfileId, lpwszAccountId, lpwszLoginName);
    }
    
    LocalFreeAndNull(&lpwszAccountId);
    LocalFreeAndNull(&lpwszLoginName);

    return hr;
}


#ifdef HM_GROUP_SYNCING
///////////////////////////////////////////////////////////////////////////////
//  hrAppendName
//
//  Helper function to take a double byte name string, converts it to single
//  byte and appends it to the given name string, using ',' as the delimiter.
//  The name string pointer will be allocated and reallocated as needed.  The 
//  caller is responible for freeing the name string with CoTaskMemFree().
//
//  Parameters
//  [IN/OUT] lpszNameString - name string pointer
//  [IN]     ulCharCount - current name string size in char
//  [IN]     double byte character string to append
///////////////////////////////////////////////////////////////////////////////
LPCSTR lpszDelimiter = ",";

ULONG ulAppendName(
    LPSTR * lppszNameString,
    ULONG   ulCharCount,
    LPCTSTR lptszName)
{
    ULONG   ulLen = 0;
    ULONG   ulNewLen = 0;
    ULONG   ulNew = ulCharCount;
    LPSTR   lpszTemp = NULL;

    Assert(lppszNameString);
    Assert(lptszName);

    // Check size of new string
    ulNewLen = (ULONG)lstrlen(lptszName) + 2;  // Include delimiter character and termination
    if (*lppszNameString)
        ulLen = ulNewLen + (ULONG)lstrlenA(*lppszNameString);
    else
        ulLen = ulNewLen;
    if (ulLen > ulCharCount)
    {
        ulNew = (ulNewLen > MAX_PATH) ? (ulCharCount+ulNewLen+MAX_PATH) : (ulCharCount+MAX_PATH);
        lpszTemp = CoTaskMemAlloc(ulNew * sizeof(WCHAR));
        if (!lpszTemp)
        {
            Assert(0);
            goto error_out;
        }
        *lpszTemp = '\0';

        if (*lppszNameString)
        {
            StrCpyNA(lpszTemp, *lppszNameString, ulNew);
            CoTaskMemFree(*lppszNameString);
        }
        *lppszNameString = lpszTemp;
        ulCharCount = ulNew;
    }

    // Append new string name
    {
        LPSTR   lptsz = ConvertWtoA(lptszName);
        if (**lppszNameString != '\0')
            StrCatBuffA(*lppszNameString, lpszDelimiter, ulCharCount);
        StrCatBuffA(*lppszNameString, lptsz, ulCharCount);
        LocalFreeAndNull(&lptsz);
    }

    return ulNew;

error_out:
    
    // Error, return NULL string pointer
    if (*lppszNameString)
    {
        CoTaskMemFree(*lppszNameString);
        *lppszNameString = NULL;
    }
            
    return 0;
}


///////////////////////////////////////////////////////////////////////////////
//  hrAppendGroupContact
//
//  Helper function to a group's PR_WAB_DL_ENTRIES and/or PR_WAB_DL_ONEOFFS
//  names and append to the given name string.  This name string is in the same
//  format as what is retrieved from a HotMail server, and is compared directly
//  with the corresponding HotMail group.  
//
//  a)  PR_WAB_DL_ENTRIES are WAB entry ID contacts that map to HM contacts
//      distinquished by nickname.
//  b)  PR_WAB_DL_ONEOFFS are WAB entry ID one-offs with user and email embedded
//      directly in the entry ID structure.
//
//  Parameters
//  [IN] pWabSync
//  [IN] ulPropTag
//  [IN] lpProp - Pointer to property struct
//  [IN/OUT] lppszHMEmailName - HM string with new names appended
//           !!NOTE that this needs to be freed by caller using CoMemTaskFree()!!
///////////////////////////////////////////////////////////////////////////////
HRESULT hrAppendGroupContact(
    LPWABSYNC    pWabSync,              // [IN]
    ULONG        ulPropTag,             // [IN]
    LPSPropValue lpProp,                // [IN]
    LPSTR *      lppszHMEmailName)      // [IN/OUT]
{
    HRESULT      hr = S_OK;
    LPSPropValue lpaProps = NULL;
    ULONG        ulcProps = 0;
    ULONG        ul;
    ULONG        ulCharSize = 0;

    Assert(pWabSync);
    Assert(lppszHMEmailName);
    Assert( (ulPropTag == PR_WAB_DL_ENTRIES) || (ulPropTag == PR_WAB_DL_ONEOFFS) );

    // Check each DL entry and check whether it is another WAB (mail user) contact
    // EID or a WAB One-Off email/name string EID.
    if (ulPropTag == PR_WAB_DL_ONEOFFS)
    {
        // Wab one-off is equivalent to a HM direct email name
        for (ul=0; ul<lpProp->Value.MVbin.cValues; ul++)
        {
            ULONG       cbEntryID = lpProp->Value.MVbin.lpbin[ul].cb;
            LPENTRYID   lpEntryID = (LPENTRYID)lpProp->Value.MVbin.lpbin[ul].lpb;
            BYTE        bType;
            LPTSTR      lptstrDisplayName, lptstrAddrType;
            LPTSTR      lptstrAddress = NULL;

            bType = IsWABEntryID(cbEntryID, lpEntryID, 
                        &lptstrDisplayName, 
                        &lptstrAddrType, 
                        &lptstrAddress, NULL, NULL);
            if (lptstrAddress)
            {
                // Append the one-off email name
                ulCharSize = ulAppendName(lppszHMEmailName, ulCharSize, lptstrAddress);
                if (ulCharSize == 0)
                {
                    hr = E_OUTOFMEMORY;
                    goto out;
                }
            }
            else
            {
                Assert(0);
            }
        }
    }
    else if (ulPropTag == PR_WAB_DL_ENTRIES)
    {
        // WAB mail user contact is equivalent to a HM contact
        for (ul=0; ul<lpProp->Value.MVbin.cValues; ul++)
        {
            HRESULT     hr;
            LPMAILUSER  lpMailUser;
            ULONG       ulObjectType;
            ULONG       cbEntryID = lpProp->Value.MVbin.lpbin[ul].cb;
            LPENTRYID   lpEntryID = (LPENTRYID)lpProp->Value.MVbin.lpbin[ul].lpb;

            hr = pWabSync->m_pAB->lpVtbl->OpenEntry(pWabSync->m_pAB, cbEntryID, lpEntryID, 
                NULL, 0, &ulObjectType, (LPUNKNOWN *)&lpMailUser);

            if (SUCCEEDED(hr))
            {
                LPSPropValue    lpaProps;
                ULONG           ulcProps;

                Assert(ulObjectType == MAPI_MAILUSER);

                // HM contacts are designated by the nickname field, so this is all
                // we need to append to the name string.
                hr = lpMailUser->lpVtbl->GetProps(lpMailUser, NULL, MAPI_UNICODE, &ulcProps, &lpaProps);
                if (SUCCEEDED(hr))
                {
                    ULONG   ulc;
                    LPCTSTR lptszNickname = NULL;
                    for (ulc=0; ulc<ulcProps; ulc++)
                    {
                        if (lpaProps[ulc].ulPropTag == PR_NICKNAME)
                            break;
                    }
                    if (ulc == ulcProps)
                    {
                        // No nickname.  This means that the preceeding contact sync has
                        // failed or not completed in some way.  Skip.
                        Assert(0);
                        continue;
                    }
                    else
                        lptszNickname = (LPCTSTR)lpaProps[ulc].Value.lpszW;

                    ulCharSize = ulAppendName(lppszHMEmailName, ulCharSize, lptszNickname);
                    if (ulCharSize == 0)
                    {
                        hr = E_OUTOFMEMORY;
                        goto out;
                    }
                }
            }
        }
    }
    else
    {
        // Trace("Unknown property tag type");
        Assert(0);
    }

out:

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//  hrParseHMGroupEmail
//
//  Helper function to parse a HM group email string into nickname names 
//  (contacts) and email names (one-offs).  The name arrays are simply pointers
//  into the passed in email name string and so are valid as long at that 
//  input string is valid.  Note that this function modifies the input string
//  lptszEmailName.
//
//  Parameters
//  [IN]  lptszEmailName - email string to parse
//  [OUT] patszContacts - array of parsed contact (nickname) names if requested
//  [OUT] pcContacts - number of contact names
//  [OUT] patszOneOffs - array of parsed one-off (email) names if requested
//  [OUT] pcOneOffs - number of one-off names
///////////////////////////////////////////////////////////////////////////////
// It looks like HM allows four possible text delimiters: ' ', ',', ';', '+'
const TCHAR tszSpace[] = TEXT(" ");
const TCHAR tszComma[] = TEXT(",");
const TCHAR tszSemi[] = TEXT(";");
const TCHAR tszPlus[] = TEXT("+");
const TCHAR tszAt[] = TEXT("@");

HRESULT hrParseHMGroupEmail(
    LPTSTR     lptszEmailName,
    LPTSTR **  patszContacts,
    ULONG *    pcContacts,
    LPTSTR **  patszOneOffs,
    ULONG *    pcOneOffs)
{
    HRESULT     hr = S_OK;
    ULONG       cCount = 1;
    ULONG       ul;
    LPTSTR      lptszTemp = lptszEmailName;
    LPTSTR *    atszContacts = NULL;
    LPTSTR *    atszOneOffs = NULL;
    ULONG       cContacts = 0;
    ULONG       cOneOffs = 0;

    Assert( lptszEmailName && (pcContacts || pcOneOffs) );

    // Strip all leading and ending spaces
    TrimSpaces(lptszTemp);

    // Count
    while (*lptszTemp)
    {
        if ( ((*lptszTemp) == (*tszSpace)) ||
             ((*lptszTemp) == (*tszComma)) ||
             ((*lptszTemp) == (*tszSemi)) ||
             ((*lptszTemp) == (*tszPlus)) )
        {
            ++cCount;

            // Increment to next valid name
            ++lptszTemp;
            while ( ((*lptszTemp) == (*tszSpace)) ||
                    ((*lptszTemp) == (*tszComma)) ||
                    ((*lptszTemp) == (*tszSemi)) ||
                    ((*lptszTemp) == (*tszPlus)) )
            {
                ++lptszTemp;
            }
        }
        else
            ++lptszTemp;
    }

    // Create Contacts and One-Offs name pointer arrays
    atszContacts = LocalAlloc(LMEM_ZEROINIT, (cCount * sizeof(LPTSTR)));
    if (!atszContacts)
    {
        hr = E_OUTOFMEMORY;
        goto out;
    }
    atszOneOffs = LocalAlloc(LMEM_ZEROINIT, (cCount * sizeof(LPTSTR)));
    if (!atszOneOffs)
    {
        hr = E_OUTOFMEMORY;
        goto out;
    }

    // Fill the name pointer arrays and counts
    {
        LPTSTR  lptszName = lptszEmailName;
        BOOL    fIsEmail = FALSE;
        
        lptszTemp = lptszName;
        while(*lptszTemp)
        {
            // Determine whether this name is a nickname or email.  I am assuning
            // that all email names will have the '@' character.
            if ((*lptszTemp) == (*tszAt))
                fIsEmail = TRUE;

            if ( ((*lptszTemp) == (*tszSpace)) ||
                 ((*lptszTemp) == (*tszComma)) ||
                 ((*lptszTemp) == (*tszSemi)) ||
                 ((*lptszTemp) == (*tszPlus)) )
            {
                *lptszTemp = '\0';
                ++lptszTemp;

                if (fIsEmail)
                {
                    atszOneOffs[cOneOffs++] = lptszName;
                    Assert(cOneOffs <= cCount);
                    fIsEmail = FALSE;
                }
                else
                {
                    atszContacts[cContacts++] = lptszName;
                    Assert(cContacts <= cCount);
                }

                // Increment to next valid name
                while ( ((*lptszTemp) == (*tszSpace)) ||
                        ((*lptszTemp) == (*tszComma)) ||
                        ((*lptszTemp) == (*tszSemi)) ||
                        ((*lptszTemp) == (*tszPlus)) )
                {
                    ++lptszTemp;
                }

                lptszName = lptszTemp;
            }
            else
                ++lptszTemp;
        }
        // Pick up last item
        if (*lptszName)
        {
            if (fIsEmail)
            {
                atszOneOffs[cOneOffs++] = lptszName;
                Assert(cOneOffs <= cCount);
            }
            else
            {
                atszContacts[cContacts++] = lptszName;
                Assert(cContacts <= cCount);
            }
        }
    }

    // Pass back contact name array if requested
    if (cContacts && pcContacts)
    {
        *pcContacts = cContacts;
    }
    if (patszContacts)
        (*patszContacts) = atszContacts;

    // Pass back one-off name array if requested
    if (cOneOffs && pcOneOffs )
    {
        *pcOneOffs = cOneOffs;
    }
    if (patszOneOffs)
        (*patszOneOffs) = atszOneOffs;

out:

    if ( FAILED(hr) || !patszContacts )
        LocalFreeAndNull((LPVOID *)&atszContacts);

    if ( FAILED(hr) || !patszOneOffs )
        LocalFreeAndNull((LPVOID *)&atszOneOffs);

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//  hrCreateGroupMVBin
//
//  Creates either a PR_WAB_DL_ENTRIES or PR_WAB_DL_ONEOFFS MVBin property and
//  adds it to the passed in property array.  
//
//  If the proptag is PR_WAB_DL_ENTRIES then the atszNames array is assumed to
//  contain valid WAB contact nicknames.  The first contact's (mail user) EID
//  with that nickname is added to the MVBin property.  It is assumed that 
//  nicknames are unique (after contact syncing which is performed first) as is
//  required by Hotmail.
//
//  If the proptag is PR_WAB_DL_ONEOFFS then the atszNames array is assumed to
//  contain valid email names.  WAB one-off EIDs are created from these and 
//  added to the MVBin property.
//
//  Parameters
//  [IN] pWabSync
//  [IN] ulPropTag
//  [IN] atszNames - Array of wide char names
//  [IN] cCount - Number of items in above array
//  [IN/OUT] lpPropArray
//  [IN/OUT] pdwLoc - Current lpPropArray index
///////////////////////////////////////////////////////////////////////////////
HRESULT hrCreateGroupMVBin(
    LPWABSYNC    pWabSync,
    ULONG        ulPropTag,
    LPTSTR *     atszNames,
    ULONG        cCount,
    LPSPropValue lpPropArray,
    DWORD *      pdwLoc)
{
    HRESULT hr = S_OK;
    ULONG   ul;

    Assert(atszNames);
    Assert(lpPropArray);
    Assert(pdwLoc);

    // Set up this property as error.  When the MVbin values are added via
    // AddPropToMVPBin() the tag type will change to valid PT_MV_BINARY type.
    lpPropArray[*pdwLoc].ulPropTag = PROP_TAG(PT_ERROR, PROP_ID(ulPropTag));
    lpPropArray[*pdwLoc].dwAlignPad = 0;
    lpPropArray[*pdwLoc].Value.MVbin.cValues = 0;
    lpPropArray[*pdwLoc].Value.MVbin.lpbin = NULL;
    
    if (ulPropTag == PR_WAB_DL_ENTRIES)
    {
        // Search for WAB mail users with these nicknames
        for (ul=0; ul<cCount; ul++)
        {
            SPropertyRestriction PropRes;
            SPropValue Prop = {0};
            LPSBinary rgsbEntryIDs = NULL;
            ULONG ulCount = 1;

            // Set up search restriction
            Prop.ulPropTag = PR_NICKNAME;
            Prop.Value.LPSZ = atszNames[ul];
            PropRes.lpProp = &Prop;
            PropRes.relop = RELOP_EQ;
            PropRes.ulPropTag = PR_NICKNAME;

            if (SUCCEEDED(FindRecords(((LPIAB)pWabSync->m_pAB)->lpPropertyStore->hPropertyStore,
	                                  NULL,			// pmbinFolder
                                      0,            // ulFlags
                                      TRUE,         // Always TRUE
                                      &PropRes,     // Propertyrestriction
                                      &ulCount,     // IN: number of matches to find, OUT: number found
                                      &rgsbEntryIDs)))
            {
                // Add EID property
                if (ulCount > 0)
                {
                    if ( FAILED(AddPropToMVPBin(
                            lpPropArray,
                            *pdwLoc,
                            rgsbEntryIDs[0].lpb,
                            rgsbEntryIDs[0].cb,
                            FALSE)) )                   // Don't add duplicates, not
                    {
                        Assert(0);
                    }
                }

                FreeEntryIDs(((LPIAB)pWabSync->m_pAB)->lpPropertyStore->hPropertyStore, ulCount, rgsbEntryIDs);
            }
            else
            {
                // All contacts should be in WAB unless the preceeding mail user contact
                // sync failed.
                DebugTrace(TEXT("hrCreateGroupMVBin - Failed to find HM group contact\n"));
            }
        }
    }
    else if (ulPropTag == PR_WAB_DL_ONEOFFS)
    {        
        for (ul=0; ul<cCount; ul++)
        {
            ULONG       cbEID = 0;
            LPENTRYID   lpEID = NULL;
            LPTSTR      lptszName = NULL;
            LPTSTR      lptszSMTP = TEXT("");
            LPTSTR      lptszEmail = atszNames[ul];
            LPTSTR      lptszTemp = NULL;
            int         nLen = lstrlen(atszNames[ul]) + 1;

            // A WAB DL OneOff must have a valid display name.  Take the first
            // part of the email name for this.
            lptszName = LocalAlloc(LMEM_ZEROINIT, (nLen * sizeof(WCHAR)));
            if (!lptszName)
            {
                hr = E_OUTOFMEMORY;
                goto out;
            }
            StrCpyN(lptszName, lptszEmail, nLen);
            lptszTemp = lptszName;
            while ( *lptszTemp &&
                    (*lptszTemp) != (*tszAt) )
            {
                ++lptszTemp;
            }
            (*lptszTemp) = '\0';

            // Creates UNICODE string embedded WAB one-off EID
            if ( SUCCEEDED(CreateWABEntryID(WAB_ONEOFF,
                                            (LPVOID)lptszName,
                                            (LPVOID)lptszSMTP,
                                            (LPVOID)lptszEmail,
                                            0, 0, NULL,
                                            &cbEID,
                                            &lpEID)) )
            {
                if ( FAILED(AddPropToMVPBin(
                        lpPropArray,
                        *pdwLoc,
                        lpEID,
                        cbEID,
                        FALSE)) )                   // Don't add duplicates, not
                {
                    Assert(0);
                }
            }

            LocalFreeAndNull(&lptszName);
        }
    }
    else
    {
        Assert(0);
    }

out:

    ++(*pdwLoc);
    return hr;
}
#endif  // HM_GROUP_SYNCING


///////////////////////////////////////////////////////////////////////////////
//  hrStripInvalidChars
//
//  Helper function to remove disallowed characters.  HM only allows 
//  alphanumeric and '-' and '_' characters in a nickname.  All illegal chars
//  are removed from the string.
//
///////////////////////////////////////////////////////////////////////////////
HRESULT hrStripInvalidChars(LPSTR lpszName)
{
    HRESULT hr = S_OK;
    LPSTR   lpszAddTo = NULL;

    Assert(lpszName);

    lpszAddTo = lpszName;
    while (*lpszName)
    {
        // @review  Currently the look up table only contains 122 characters.  Make
        // it full 256?  How will HM change when it adds intenational suppport?
        if ( ((UCHAR)(*lpszName) < MAX_INVALID_ARRAY_INDEX) && !bInvalidCharArray[*lpszName] )
        {
            *lpszAddTo = *lpszName;
            ++lpszAddTo;
        }
        ++lpszName;
    }
    *lpszAddTo = '\0';

    return hr;
}



// ****************************************************************************************************
//  C   H   O   T   S   Y   N   C          C   L   A   S   S   
//
//  Class to handle the synchronizing of WAB and Hotmail contacts
//

HRESULT     WABSync_Create(LPWABSYNC *ppWabSync)
{
    Assert(ppWabSync);

    *ppWabSync = LocalAlloc(LMEM_ZEROINIT, sizeof(WABSYNC));
   
    // fix up the prop tag array structure to take into account the variable values
    ptaEidSync.aulPropTag[ieid_PR_WAB_HOTMAIL_CONTACTIDS] = PR_WAB_HOTMAIL_CONTACTIDS;
    ptaEidSync.aulPropTag[ieid_PR_WAB_HOTMAIL_SERVERIDS] = PR_WAB_HOTMAIL_SERVERIDS;
    ptaEidSync.aulPropTag[ieid_PR_WAB_HOTMAIL_MODTIMES] = PR_WAB_HOTMAIL_MODTIMES;

    // fix up the other prop tag array structure to take into account the variable values
    ptaEidCSync.aulPropTag[ieidc_PR_WAB_HOTMAIL_CONTACTIDS] = PR_WAB_HOTMAIL_CONTACTIDS;
    ptaEidCSync.aulPropTag[ieidc_PR_WAB_HOTMAIL_SERVERIDS] = PR_WAB_HOTMAIL_SERVERIDS;
    ptaEidCSync.aulPropTag[ieidc_PR_WAB_HOTMAIL_MODTIMES] = PR_WAB_HOTMAIL_MODTIMES;
#ifdef HM_GROUP_SYNCING
    ptaEidCSync.aulPropTag[ieidc_PR_WAB_DL_ONEOFFS] = PR_WAB_DL_ONEOFFS;
#endif

    if (*ppWabSync)
    {
        (*ppWabSync)->vtbl = &vtblIHTTPMAILCALLBACK;
        (*ppWabSync)->m_cRef = 1;
        (*ppWabSync)->m_state = SYNC_STATE_INITIALIZING;
        (*ppWabSync)->m_ixpStatus = IXP_DISCONNECTED;
        ZeroMemory(&(*ppWabSync)->m_rInetServerInfo, sizeof(INETSERVER));
    }
    else
        return E_OUTOFMEMORY;

    return S_OK;
}


void        WABSync_Delete(LPWABSYNC pWabSync)
{
    Assert(pWabSync);

    ZeroMemory(&(pWabSync->m_rInetServerInfo), sizeof(INETSERVER));     // Done for security

    if (pWabSync->m_pOps)
    {
        WABSync_FreeOps(pWabSync);
        Vector_Delete(pWabSync->m_pOps);
        pWabSync->m_pOps = NULL;
    }

    if (pWabSync->m_pWabItems)
    {
        WABSync_FreeItems(pWabSync);
        Vector_Delete(pWabSync->m_pWabItems);
    }

    if (pWabSync->m_pszAccountId)
        CoTaskMemFree(pWabSync->m_pszAccountId);

    if (pWabSync->m_pAB)
        pWabSync->m_pAB->lpVtbl->Release(pWabSync->m_pAB);

    if (pWabSync->m_pTransport)
        IHTTPMailTransport_Release(pWabSync->m_pTransport);

    if (pWabSync->m_pszRootUrl)
        CoTaskMemFree(pWabSync->m_pszRootUrl);

#ifdef HM_GROUP_SYNCING
    // [PaulHi] If we are ending a mail contact sync, kick off a second pass
    // to synchronize the group contacts.
    // @review - We may want to skip group syncing if an error occurs during the
    // first pass contact syncing.
    if (!pWabSync->m_fSyncGroups && pWabSync->m_hParentWnd)
        PostMessage(pWabSync->m_hParentWnd, WM_USER_SYNCGROUPS, 0, 0L);
#endif

    LocalFree(pWabSync);
}


//----------------------------------------------------------------------
// IUnknown Members
//----------------------------------------------------------------------
HRESULT WABSync_QueryInterface (IHTTPMailCallback __RPC_FAR *lpunkobj,
                                REFIID          riid,
                                LPVOID FAR *    lppUnk)
{
    SCODE       sc;
    LPWABSYNC   lpWabSync = (LPWABSYNC)lpunkobj;

    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IHTTPMailCallback) ||
        IsEqualGUID(riid, &IID_ITransportCallback))
    {
        sc = S_OK;
    }
    else
    {
		*lppUnk = NULL;	// OLE requires zeroing [out] parameters
		sc = E_NOINTERFACE;
		goto error;
    }

	/* We found the requested interface so increment the reference count.
	 */
	lpWabSync ->m_cRef++;

	*lppUnk = lpunkobj;

	return hrSuccess;

error:
	return ResultFromScode(sc);
}


ULONG WABSync_AddRef(IHTTPMailCallback __RPC_FAR *This)
{
    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return InterlockedIncrement(&pWabSync->m_cRef);
}

ULONG WABSync_Release(IHTTPMailCallback __RPC_FAR *This)
{
    LPWABSYNC pWabSync = (LPWABSYNC)This;
    LONG cRef = InterlockedDecrement(&pWabSync->m_cRef);
    
    Assert(cRef >= 0);

    if (0 == cRef)
        WABSync_Delete(pWabSync);

    return (ULONG)cRef;
}


//----------------------------------------------------------------------
// IHTTPMailCallback Members
//----------------------------------------------------------------------
STDMETHODIMP WABSync_OnTimeout (IHTTPMailCallback __RPC_FAR *This, DWORD *pdwTimeout, IInternetTransport *pTransport)
{
//    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return E_NOTIMPL;
}

STDMETHODIMP WABSync_OnLogonPrompt (IHTTPMailCallback __RPC_FAR *This, LPINETSERVER pInetServer, IInternetTransport *pTransport)
{
    LPWABSYNC pWabSync = (LPWABSYNC)This;
    if (PromptUserForPassword(pInetServer, pWabSync->m_hWnd))
    {
        return S_OK;
    }
    return E_FAIL;
}

STDMETHODIMP_(INT) WABSync_OnPrompt (IHTTPMailCallback __RPC_FAR *This, HRESULT hrError, LPCTSTR pszText, LPCTSTR pszCaption, UINT uType, IInternetTransport *pTransport)
{
//    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return E_NOTIMPL;
}

STDMETHODIMP WABSync_OnStatus (IHTTPMailCallback __RPC_FAR *This, IXPSTATUS ixpstatus, IInternetTransport *pTransport)
{
//    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return E_NOTIMPL;
}

STDMETHODIMP WABSync_OnError (IHTTPMailCallback __RPC_FAR *This, IXPSTATUS ixpstatus, LPIXPRESULT pResult, IInternetTransport *pTransport)
{
//    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return E_NOTIMPL;
}

STDMETHODIMP WABSync_OnCommand (IHTTPMailCallback __RPC_FAR *This, CMDTYPE cmdtype, LPSTR pszLine, HRESULT hrResponse, IInternetTransport *pTransport)
{
//    LPWABSYNC pWabSync = (LPWABSYNC)This;
    return E_NOTIMPL;
}

STDMETHODIMP WABSync_GetParentWindow (IHTTPMailCallback __RPC_FAR *This, HWND *pHwndParent)
{
    LPWABSYNC pWabSync = (LPWABSYNC)This;
    
    *pHwndParent = pWabSync->m_hWnd;
    return S_OK;
}

STDMETHODIMP WABSync_OnResponse (IHTTPMailCallback __RPC_FAR *This, LPHTTPMAILRESPONSE pResponse)
{
    LPWABSYNC pWabSync = (LPWABSYNC)This;
    HRESULT hr = S_OK;
    
    Assert(pWabSync);
    Assert(pResponse);

    if (FAILED(pResponse->rIxpResult.hrResult))
    {
        switch (pResponse->rIxpResult.hrResult)
        {
            case IXP_E_HTTP_INSUFFICIENT_STORAGE:
            case IXP_E_HTTP_ROOT_PROP_NOT_FOUND:
            case IXP_E_HTTP_NOT_IMPLEMENTED:
                WABSync_Abort(pWabSync, pResponse->rIxpResult.hrResult);
                break;
        }
    }

    if (pWabSync->m_fAborted)
        return E_FAIL;

    if (SYNC_STATE_SERVER_CONTACT_DISCOVERY == pWabSync->m_state)
    {
        if (pResponse->command == HTTPMAIL_GETPROP)
            hr = WABSync_HandleContactsRootResponse(pWabSync, pResponse);
        else
            hr = WABSync_HandleIDListResponse(pWabSync, pResponse);
    }    
    else if ((SYNC_STATE_PROCESS_OPS == pWabSync->m_state || SYNC_STATE_PROCESS_MERGED_CONFLICTS == pWabSync->m_state)
                && pWabSync->m_pOps)
    {   
        LPHOTSYNCOP pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);
        Assert(pOp);

        if (pOp)
            hr = Syncop_HandleResponse(pOp, pResponse);
        else
            hr = E_FAIL;

        if (FAILED(hr))
            WABSync_AbortOp(pWabSync, hr);
    }
    else
        hr = E_FAIL;

    return hr;
}

#ifdef HM_GROUP_SYNCING
STDMETHODIMP WABSync_Initialize(LPWABSYNC pWabSync, HWND hWnd, IAddrBook *pAB, LPCTSTR pszAccountID, BOOL bSyncGroups)
#else
STDMETHODIMP WABSync_Initialize(LPWABSYNC pWabSync, HWND hWnd, IAddrBook *pAB, LPCTSTR pszAccountID)
#endif
{
    IImnAccountManager2 *lpAcctMgr = NULL;
    IImnAccount        *pAccount = NULL;
    HRESULT             hr;
    char                szAcctName[CCHMAX_ACCOUNT_NAME+1];
    DWORD               ccb = CCHMAX_ACCOUNT_NAME;
    LPSTR               pszUserAgent = NULL;
#ifdef HM_GROUP_SYNCING
    LPPTGDATA           lpPTGData=GetThreadStoragePointer();
#endif

    Assert(pWabSync);
    Assert(pAB);

    pWabSync->m_hParentWnd = hWnd;
    pWabSync->m_pTransport = NULL;
    pWabSync->m_fSkipped = FALSE;
#ifdef HM_GROUP_SYNCING
    pWabSync->m_fSyncGroups = bSyncGroups;
#endif

    pWabSync->m_hWnd =  CreateDialogParam (hinstMapiX, MAKEINTRESOURCE (iddSyncProgress),
                        pWabSync->m_hParentWnd, SyncProgressDlgProc, (LPARAM)pWabSync);


    if (!pWabSync->m_hWnd)
    {
        hr = E_FAIL;
        goto exit;
    }
    ShowWindow(pWabSync->m_hWnd, SW_SHOW);
    if (pWabSync->m_hParentWnd)
        EnableWindow (pWabSync->m_hParentWnd, FALSE);

    WABSync_BeginSynchronize(pWabSync);
    
    InitWABUserAgent(TRUE);

    if (FAILED(hr = InitAccountManager(NULL, &lpAcctMgr, NULL)))
        goto exit;

    if (pszAccountID == NULL)
    {
        if (FAILED(hr = _FindHTTPMailAccount(pWabSync->m_hWnd, lpAcctMgr, szAcctName, CCHMAX_ACCOUNT_NAME)))
            goto exit;
#ifdef HM_GROUP_SYNCING
        // [PaulHi] We don't want the user to have to choose the HM account twice (once for contact and
        // then for group syncing).  So save the account ID here.
        LocalFreeAndNull(&(lpPTGData->lptszHMAccountId));
        lpPTGData->lptszHMAccountId = ConvertAtoW(szAcctName);
#endif
    }
    else
    {
        LPSTR lpAcctA = ConvertWtoA((LPWSTR)pszAccountID);
        StrCpyNA(szAcctName, lpAcctA, ARRAYSIZE(szAcctName));
        LocalFreeAndNull(&lpAcctA);
    }

    // Get the account
    hr = lpAcctMgr->lpVtbl->FindAccount(lpAcctMgr, AP_ACCOUNT_ID, szAcctName, &pAccount);
    if (FAILED(hr))
    {
        hr = lpAcctMgr->lpVtbl->FindAccount(lpAcctMgr, AP_ACCOUNT_NAME, szAcctName, &pAccount);
        if (FAILED(hr))
            goto exit;
    }

    if (SUCCEEDED(hr = pAccount->lpVtbl->GetProp(pAccount, AP_ACCOUNT_ID, szAcctName, &ccb)))
        pWabSync->m_pszAccountId = _StrDup(szAcctName);

    pWabSync->m_pAB = pAB;
    
    pWabSync->m_pAB->lpVtbl->AddRef(pWabSync->m_pAB);

    // Create the Transport
    hr = CoCreateInstance(  &CLSID_IHTTPMailTransport, 
                            NULL, 
                            CLSCTX_INPROC_SERVER,
                            &IID_IHTTPMailTransport, 
                            (LPVOID *)&(pWabSync->m_pTransport));
    
    if (FAILED(hr) || !pWabSync->m_pTransport)
        goto exit;

    pszUserAgent = GetWABUserAgentString();
    if (!pszUserAgent)
        goto exit;

    // Initialize the transport
    hr = IHTTPMailTransport_InitNew(pWabSync->m_pTransport, pszUserAgent, (LogTransactions(pWabSync) ? "C:\\WabSync.log" : NULL),(IHTTPMailCallback*)pWabSync);
    if (FAILED(hr))
        goto exit;

    // Create the SERVERINFO
    hr = IHTTPMailTransport_InetServerFromAccount(pWabSync->m_pTransport, pAccount, &pWabSync->m_rInetServerInfo);
    if (FAILED(hr))
        goto exit;
    
    StrCpyNA(pWabSync->m_szLoginName, pWabSync->m_rInetServerInfo.szUserName, ARRAYSIZE(pWabSync->m_szLoginName));

    // Check if I can connect
    hr = IHTTPMailTransport_Connect(pWabSync->m_pTransport,&pWabSync->m_rInetServerInfo,TRUE,TRUE);
    if (FAILED(hr))
        goto exit;

    hr = WABSync_LoadLastModInfo(pWabSync);
    if (FAILED(hr))
        goto exit;

    hr = WABSync_BuildWabContactList(pWabSync);
    if (FAILED(hr))
        goto exit;

    WABSync_NextState(pWabSync);

exit:
    if (pszUserAgent)
        LocalFree(pszUserAgent);

    if (FAILED(hr))
    {
        if (pWabSync->m_pTransport)
            IHTTPMailTransport_Release(pWabSync->m_pTransport);
        pWabSync->m_pTransport = NULL;
        WABSync_Abort(pWabSync, hr);

        if (pWabSync->m_pAB)
        {
            pWabSync->m_pAB->lpVtbl->Release(pWabSync->m_pAB);
            pWabSync->m_pAB = NULL;
        }
    }

    // don't release the lpAcctMgr since the WAB maintains a global reference.
        
    if (pAccount)
        pAccount->lpVtbl->Release(pAccount);

    return hr;
}


//
//    CHotSync::Abort
//
//    Blow away all of the pending items in the queue.
//
STDMETHODIMP WABSync_Abort(LPWABSYNC pWabSync, HRESULT hr)
{
    LPHOTSYNCOP         pOp;
    TCHAR   szMsg[512], szCaption[255], szRes[512];
    
    Assert(pWabSync);
    
    pWabSync->m_fAborted = TRUE;

    if (pWabSync->m_pOps)
    {
        DWORD   dwIndex, cOps = Vector_GetLength(pWabSync->m_pOps);

        for (dwIndex = 0; dwIndex < cOps; ++dwIndex)
        {
            pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);

            if (pOp)
            {
                Syncop_Abort(pOp);
                Syncop_Delete(pOp);
            }

            Vector_RemoveItem(pWabSync->m_pOps, 0);
        }
    }

    if (FAILED(hr) && hr != E_UserCancel)
    {
        switch (hr)
        {
            case IXP_E_HTTP_INSUFFICIENT_STORAGE:
                LoadString(hinstMapiX, idsOutOfServerSpace, szMsg, CharSizeOf(szMsg));
                break;

            case IXP_E_HTTP_ROOT_PROP_NOT_FOUND:
            case IXP_E_HTTP_NOT_IMPLEMENTED:
                LoadString(hinstMapiX, idsSyncNotHandled, szMsg, CharSizeOf(szMsg));
                break;
            
            default:
                LoadString(hinstMapiX, idsSyncAborted, szRes, CharSizeOf(szRes));
                wnsprintf(szMsg, ARRAYSIZE(szMsg), szRes, hr);
                break;
        }
        LoadString(hinstMapiX, idsSyncError, szCaption, CharSizeOf(szCaption));
        MessageBox(pWabSync->m_hWnd, szMsg, szCaption, MB_ICONEXCLAMATION | MB_OK);
    }

    WABSync_FinishSynchronize(pWabSync, hr);

    return S_OK;
}

//
//    CHotSync::AbortOp
//
//    Abort the current operation (for some reason)
//
STDMETHODIMP WABSync_AbortOp(LPWABSYNC pWabSync, HRESULT hr)
{
    LPHOTSYNCOP         pOp;
    
    Assert(pWabSync);
    
    pWabSync->m_cAborts++;

    // do something with the knowledge of this abort (log to whatever)
    if (!WABSync_NextOp(pWabSync, TRUE))
        WABSync_NextState(pWabSync);

    return S_OK;
}

int __cdecl CompareOpTypes(const void* lpvA, const void* lpvB)
{
    LPHOTSYNCOP pSyncOpA;
    LPHOTSYNCOP pSyncOpB;

    pSyncOpA = *((LPHOTSYNCOP*)lpvA);
    pSyncOpB = *((LPHOTSYNCOP*)lpvB);

    return (pSyncOpA->m_bOpType - pSyncOpB->m_bOpType);
}


STDMETHODIMP WABSync_RequestContactsRootProperty(LPWABSYNC pWabSync)
{
    HRESULT hr;

    Assert(pWabSync);
    Assert(pWabSync->m_pTransport);

    hr = pWabSync->m_pTransport->lpVtbl->GetProperty(pWabSync->m_pTransport, HTTPMAIL_PROP_CONTACTS, &pWabSync->m_pszRootUrl);
    
    if(hr == E_PENDING)
        hr = S_OK;
    else if (SUCCEEDED(hr) && pWabSync->m_pszRootUrl)
        WABSync_RequestServerIDList(pWabSync);
    else
        WABSync_Abort(pWabSync, hr);    //something went terribly wrong

    return S_OK;
}

STDMETHODIMP WABSync_HandleContactsRootResponse(LPWABSYNC pWabSync, LPHTTPMAILRESPONSE pResponse)
{
    Assert(pWabSync);

    pWabSync->m_pszRootUrl = NULL;
    if (SUCCEEDED(pResponse->rIxpResult.hrResult))
    {
        if (pResponse->rGetPropInfo.type == HTTPMAIL_PROP_CONTACTS)
        {
            pWabSync->m_pszRootUrl = pResponse->rGetPropInfo.pszProp;
            pResponse->rGetPropInfo.pszProp = NULL;
        }            
    }

    if (pWabSync->m_pszRootUrl)
        WABSync_RequestServerIDList(pWabSync);
    else
        WABSync_Abort(pWabSync, pResponse->rIxpResult.hrResult);


    return S_OK;
}

STDMETHODIMP WABSync_RequestServerIDList(LPWABSYNC pWabSync)
{
    HRESULT             hr;

    Assert(pWabSync);
    Assert(pWabSync->m_pTransport);
    Assert(pWabSync->m_pszRootUrl && *pWabSync->m_pszRootUrl);

    WABSync_Progress(pWabSync, idsSyncGathering, -1);

    hr = pWabSync->m_pTransport->lpVtbl->ListContactInfos(pWabSync->m_pTransport, pWabSync->m_pszRootUrl, 0);

    if FAILED(hr)
        WABSync_Abort(pWabSync, hr);

    return hr;
}

STDMETHODIMP WABSync_FindContactByServerId(LPWABSYNC pWabSync, LPSTR pszServerId, LPWABCONTACTINFO *ppContact, DWORD *pdwIndex)
{
    DWORD               cItems, dwIndex;
    LPWABCONTACTINFO    pContact;

    Assert(pWabSync);
    Assert(pWabSync->m_pWabItems);

    cItems = Vector_GetLength(pWabSync->m_pWabItems);

    for (dwIndex = 0; dwIndex < cItems; dwIndex++)
    {
        pContact = (LPWABCONTACTINFO)Vector_GetItem(pWabSync->m_pWabItems, dwIndex);

        if (pContact && pContact->pszHotmailId && lstrcmpA(pContact->pszHotmailId, pszServerId) == 0)
        {
            *ppContact = pContact;
            *pdwIndex = dwIndex;
            return S_OK;
        }
    }
    return E_FAIL;
}
 
STDMETHODIMP WABSync_HandleIDListResponse(LPWABSYNC pWabSync, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr;
    LPHOTSYNCOP      pNewOp;

    if (SUCCEEDED(pResponse->rIxpResult.hrResult))
    {
        ULONG   cItems = pResponse->rContactInfoList.cContactInfo;
        LPHTTPCONTACTINFO prgId = pResponse->rContactInfoList.prgContactInfo;
        DWORD   dwItem;

        for (dwItem = 0; dwItem < cItems; dwItem++)
        {
#ifdef HM_GROUP_SYNCING
            // [PaulHi] We synchronize contacts and groups separately
            if ( (!pWabSync->m_fSyncGroups && (prgId[dwItem].tyContact == HTTPMAIL_CT_CONTACT)) ||
                 (pWabSync->m_fSyncGroups && (prgId[dwItem].tyContact == HTTPMAIL_CT_GROUP)) )
#else
            if (HTTPMAIL_CT_GROUP == prgId[dwItem].tyContact)
            {
                // ignore groups for now
                continue;
            }
            else
#endif
            {
                LPWABCONTACTINFO pContact;
                DWORD            dwIndex;
                FILETIME         ftModTime = {0,0};

                pNewOp = NULL;
                // [PaulHi] 12/17/98  Raid #61548
                // The Exchange server will pass in contacts with no file mod time, 
                // which really hoses the sync process.  We could just skip these 
                // contacts but to keep things simple we abort the sync process here.
                // Note that HotMail servers work correctly.
                //
                // @todo [PaulHi]
                // After IE5 ship of WAB, fix this by creating a conflict op code and
                // let user straighten out any differences.  Also time stamp so future
                // syncs will work.
                hr = iso8601ToFileTime(prgId[dwItem].pszModified, &ftModTime, TRUE, TRUE);
                if (FAILED(hr))
                {
                    WABSync_Abort(pWabSync, hr);
                    return hr;
                }

                if (SUCCEEDED(WABSync_FindContactByServerId(pWabSync, prgId[dwItem].pszId, &pContact, &dwIndex)))
                {
                    if (pContact->fDelete)
                    {
                        // it has been deleted from the wab.  Now delete it from the server.
                        pContact->pszHotmailHref = prgId[dwItem].pszHref;
                        prgId[dwItem].pszHref = NULL;

                        pContact->pszModHotmail = prgId[dwItem].pszModified;
                        prgId[dwItem].pszModified = NULL;

                        pNewOp = Syncop_CreateServerDelete(pContact);
                    }
                    else
                    {
                        LONG lLocalCompare = CompareFileTime(&pWabSync->m_ftLastSync, &pContact->ftModWab);
                        LONG lServerCompare = pContact->pszModHotmail && prgId[dwItem].pszModified ? lstrcmpA(pContact->pszModHotmail, prgId[dwItem].pszModified) : -1;

                        SafeCoMemFree(pContact->pszHotmailHref);
                        pContact->pszHotmailHref = prgId[dwItem].pszHref;
                        prgId[dwItem].pszHref = NULL;

                        SafeCoMemFree(pContact->pszHotmailId);
                        pContact->pszHotmailId = prgId[dwItem].pszId;
                        prgId[dwItem].pszId = NULL;

                        SafeCoMemFree(pContact->pszModHotmail);
                        pContact->pszModHotmail = prgId[dwItem].pszModified;
                        prgId[dwItem].pszModified = NULL;
                    
                        if (lLocalCompare >= 0)
                        {
                            // hasn't changed locally since last sync
                        
                            if (lServerCompare)
                            {
                                // has changed on server, just update here
                                pNewOp = Syncop_CreateClientChange(pContact);
                                Assert(pNewOp);
                                Syncop_SetServerContactInfo(pNewOp, pContact, &prgId[dwItem]);
                            }
                            else
                            {
                                // hasn't changed anywhere.  do nothing.
                                WABContact_Delete(pContact);
                                pContact = NULL;
                            }
                        }   
                        else 
                        {
                            // has changed locally.

                            if (lServerCompare)
                            {
                                // has changed on server, CONFLICT
                                pNewOp = Syncop_CreateConflict(pContact);
                                Assert(pNewOp);
                                Syncop_SetServerContactInfo(pNewOp, pContact, &prgId[dwItem]);
                            }
                            else
                            {
                                // Local change only, upload changes
                                pNewOp = Syncop_CreateServerChange(pContact);
                                Assert(pNewOp);
                                Syncop_SetServerContactInfo(pNewOp, pContact, &prgId[dwItem]);
                            }
                        }
                    }
                    
                    //remove the contact from the list of local contacts
                    Vector_RemoveItem(pWabSync->m_pWabItems, dwIndex);   
                }
                else
                {
                    // its not in the WAB, we need to add it there.
                    pContact = LocalAlloc(LMEM_ZEROINIT, sizeof(WABCONTACTINFO));
                    Assert(pContact);

                    if (pContact)
                    {
                        pContact->pszHotmailHref = prgId[dwItem].pszHref;
                        prgId[dwItem].pszHref = NULL;

                        pContact->pszHotmailId = prgId[dwItem].pszId;
                        prgId[dwItem].pszId = NULL;

                        pContact->pszModHotmail = prgId[dwItem].pszModified;
                        prgId[dwItem].pszModified = NULL;

                        pNewOp = Syncop_CreateClientAdd(pContact);
                        Assert(pNewOp);
                        Syncop_SetServerContactInfo(pNewOp, pContact, &prgId[dwItem]);
                    }
                }

                if (pNewOp)
                {
                    Syncop_Init(pNewOp, (IHTTPMailCallback *)pWabSync, pWabSync->m_pTransport);
                    hr = Vector_AddItem(pWabSync->m_pOps, pNewOp);
                }
                else
                {
                    if (pContact)
                        WABContact_Delete(pContact);
                }
            }
        }


        if (pResponse->fDone)
        {
            //everything left in the contact list needs to either
            //be added to the server or deleted locally.
            LONG                cItems, dwIndex;
            LPWABCONTACTINFO    pContact;

            Assert(pWabSync->m_pWabItems);

            cItems = Vector_GetLength(pWabSync->m_pWabItems);

            if (cItems > 0)
            {
                for (dwIndex = cItems - 1; dwIndex >= 0; dwIndex--)
                {
                    pNewOp = NULL;
                    pContact = (LPWABCONTACTINFO)Vector_GetItem(pWabSync->m_pWabItems, dwIndex);

                    if (pContact && pContact->pszHotmailId)
                    {
                        if (pContact->fDelete)
                        {
                            TCHAR   tszServerId[MAX_PATH];
                            TCHAR   tszKey[MAX_PATH];
                            HKEY    hkey;
                            // now that the delete has completed, delete the tombstone from the registry.
                            hr = hrMakeContactId(
                                tszServerId,
                                MAX_PATH,
                                ((LPIAB)(pWabSync->m_pAB))->szProfileID,
                                pWabSync->m_pszAccountId,
                                pWabSync->m_szLoginName);
                            if (FAILED(hr))
                                return hr;
                            wnsprintf(tszKey, ARRAYSIZE(tszKey), TEXT("%s%s"), g_lpszSyncKey, tszServerId);

                            if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, tszKey, 0, KEY_SET_VALUE, &hkey))
                            {
                                LPTSTR lpKey =
                                    ConvertAtoW(pContact->pszHotmailId);
                                RegDeleteValue(hkey, lpKey);
                                LocalFreeAndNull(&lpKey);
                                RegCloseKey(hkey);
                            }
                        }
                        else
                        {
                            //needs to be deleted locally
                            pNewOp = Syncop_CreateClientDelete(pContact);
                        }
                    }
                    else if (pContact)
                    {
                        //needs to be added remotely
                        pNewOp = Syncop_CreateServerAdd(pContact);
                    }

                    if (pNewOp)
                    {
                        //remove the contact from the list of local contacts
                        Vector_RemoveItem(pWabSync->m_pWabItems, dwIndex);   
                        Syncop_Init(pNewOp, (IHTTPMailCallback *)pWabSync, pWabSync->m_pTransport);
                        hr = Vector_AddItem(pWabSync->m_pOps, pNewOp);
                    }
                }

            }

            WABSync_MergeAddsToConflicts(pWabSync);

            pWabSync->m_cTotalOps = Vector_GetLength(pWabSync->m_pOps);
            
            Vector_Sort(pWabSync->m_pOps, CompareOpTypes); 

            //Now go on to handling the operations
            WABSync_NextState(pWabSync);
        }
    }
    else
        WABSync_Abort(pWabSync, pResponse->rIxpResult.hrResult);

    return S_OK;
}

STDMETHODIMP WABSync_OperationCompleted(LPWABSYNC pWabSync, LPHOTSYNCOP pOp)
{
    Assert(pWabSync->m_pOps);
    Assert(pOp == Vector_GetItem(pWabSync->m_pOps, 0));  //completing op should be first op in the list

    Syncop_Delete(pOp);
    Vector_RemoveItem(pWabSync->m_pOps, 0);

    // get the next operation and start it running.
    // if there are no more operations, go to the next state
    pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);
    if (pOp)
        Syncop_Begin(pOp);
    else
        WABSync_NextState(pWabSync);

    return S_OK;
}


STDMETHODIMP WABSync_BeginSynchronize(LPWABSYNC pWabSync)
{
    //Keep a reference to ourself while the UI is shown
    WABSync_AddRef((IHTTPMailCallback *)pWabSync); 

    // begin ui
    
    return S_OK;
}

STDMETHODIMP WABSync_FinishSynchronize(LPWABSYNC pWabSync, HRESULT hr)
{
    // if there were any failures or the user didn't resolve all of the 
    // conflicts, then don't update the mod info so we have to do it again.
#ifdef HM_GROUP_SYNCING
    // [PaulHi]  Don't store the current mod time until the synchronization
    // process is completely through, meaning that we are ending the second
    // group contact syncing pass
    if (SUCCEEDED(hr) && !pWabSync->m_fSkipped && pWabSync->m_fSyncGroups)
#else
    if (SUCCEEDED(hr) && !pWabSync->m_fSkipped)
#endif
        WABSync_SaveCurrentModInfo(pWabSync);
    else if (!pWabSync->m_fAborted && FAILED(hr))
    {
        TCHAR   szMsg[512], szCaption[255];

        LoadString(hinstMapiX, idsSyncFailed, szMsg, CharSizeOf(szMsg));
        LoadString(hinstMapiX, idsSyncError, szCaption, CharSizeOf(szCaption));
        
        MessageBox(pWabSync->m_hWnd, szMsg, szCaption, MB_ICONEXCLAMATION | MB_OK);
    }

    if (pWabSync->m_pTransport)
    {
        IHTTPMailTransport_Release(pWabSync->m_pTransport);
        pWabSync->m_pTransport = NULL;
    }

    if (pWabSync->m_hWnd)
    {
        if (pWabSync->m_hParentWnd)
            EnableWindow (pWabSync->m_hParentWnd, TRUE);

        DestroyWindow(pWabSync->m_hWnd);
        pWabSync->m_hWnd = NULL;
    }
    InitWABUserAgent(FALSE);

    WABSync_Release((IHTTPMailCallback *)pWabSync);
 
    return S_OK;  
}


void    WABSync_CheckForLocalDeletions(LPWABSYNC pWabSync)
{
    TCHAR   tszKey[MAX_PATH], tszId[MAX_PATH];
    TCHAR   tszServerId[MAX_PATH];
    DWORD   dwType = 0;
    DWORD   dwValue = 0;
    HKEY    hkey = NULL;
    DWORD   dwSize;
    HRESULT hr = E_FAIL;
    DWORD   cRecords, i, cb, lResult;

    Assert(pWabSync);
    Assert(*pWabSync->m_szLoginName);

    // [PaulHi]  Assemble the contact ID string
    if ( FAILED(hrMakeContactId(
        tszServerId,
        MAX_PATH,
        ((LPIAB)(pWabSync->m_pAB))->szProfileID,
        pWabSync->m_pszAccountId,
        pWabSync->m_szLoginName)) )
    {
        return;
    }
    wnsprintf(tszKey, ARRAYSIZE(tszKey), TEXT("%s%s"), g_lpszSyncKey, tszServerId);

    if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, tszKey, 0, KEY_READ, &hkey))
    {
        if (ERROR_SUCCESS == RegQueryInfoKey(hkey, NULL, NULL, 0, NULL, NULL, NULL, &cRecords, NULL, NULL, NULL, NULL) &&
            cRecords > 0)
        {
            // Start Enumerating the keys
            for (i = 0; i < cRecords; i++)
            {
                // Enumerate Friendly Names
                cb = CharSizeOf(tszId);
                lResult = RegEnumValue(hkey, i, tszId, &cb, 0, NULL, NULL, NULL);

                if (ERROR_SUCCESS == lResult && *tszId)
                {
                    WABCONTACTINFO *lpWCI;

                    lpWCI = LocalAlloc(LMEM_ZEROINIT, sizeof(WABCONTACTINFO));

                    if (!lpWCI)
                    {
                        hr = E_OUTOFMEMORY;
                        DebugPrintError(( TEXT("WABCONTACTINFO Alloc Failed\n")));
                        goto out;
                    }
                    
                    lpWCI->fDelete = TRUE;

                    {
                        LPSTR lpID = 
                            ConvertWtoA(tszId);
                        lpWCI->pszHotmailId = _StrDup(lpID);
                        LocalFreeAndNull(&lpID);
                    }
                    if (FAILED(Vector_AddItem(pWabSync->m_pWabItems, lpWCI)))
                        goto out;

                }
            }        

        }
out:
        RegCloseKey(hkey);
    }

        
}

STDMETHODIMP WABSync_BuildWabContactList(LPWABSYNC pWabSync)
{
    HRESULT hr = S_OK;
    ULONG   ulObjType;
    LPENTRYID   pEntryID = NULL;
    ULONG       cbEntryID = 0;
    LPABCONT    lpContainer = NULL;
    ULONG       ulObjectType;
    LPMAPITABLE lpABTable =  NULL;
    LPSRowSet   lpRowAB =   NULL;
	int cNumRows = 0;
    int nRows=0;

    Assert(pWabSync->m_pAB);

    Vector_Create(&pWabSync->m_pOps);
    if (pWabSync->m_pOps == NULL)
    {
        WABSync_Abort(pWabSync, E_OUTOFMEMORY);

        return E_OUTOFMEMORY;
    }

    Vector_Create(&pWabSync->m_pWabItems);
    if (pWabSync->m_pWabItems == NULL)
    {
        WABSync_Abort(pWabSync, E_OUTOFMEMORY);

        return E_OUTOFMEMORY;
    }

    WABSync_CheckForLocalDeletions(pWabSync);

    if (HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->GetPAB(pWabSync->m_pAB, &cbEntryID, &pEntryID)))
    {
        DebugPrintError(( TEXT("GetPAB Failed\n")));
        goto out;
    }
   
    hr = pWabSync->m_pAB->lpVtbl->OpenEntry(pWabSync->m_pAB, cbEntryID,     // size of EntryID to open
                                                pEntryID,     // EntryID to open
                                                NULL,         // interface
                                                0,            // flags
                                                &ulObjType,
                                                (LPUNKNOWN *)&lpContainer);

	MAPIFreeBuffer(pEntryID);

	pEntryID = NULL;
    
    if (HR_FAILED(hr))
    {
        DebugPrintError(( TEXT("OpenEntry Failed\n")));
        goto out;
    }

    if (HR_FAILED(hr = lpContainer->lpVtbl->GetContentsTable(lpContainer, MAPI_UNICODE | WAB_PROFILE_CONTENTS, &lpABTable)))
    {
        DebugPrintError(( TEXT("GetContentsTable Failed\n")));
        goto out;
    }

	hr = lpABTable->lpVtbl->SetColumns(lpABTable, (LPSPropTagArray)&ptaEidSync, 0 );

    if(HR_FAILED(hr))
        goto out;

    // Reset to the beginning of the table
    //
	hr = lpABTable->lpVtbl->SeekRow(lpABTable, BOOKMARK_BEGINNING, 0, NULL );

    if(HR_FAILED(hr))
        goto out;

    // Read all the rows of the table one by one
    //
	do {

        hr = lpABTable->lpVtbl->QueryRows(lpABTable, 1, 0, &lpRowAB);

        if(HR_FAILED(hr))
            break;

        if(lpRowAB)
        {
            cNumRows = lpRowAB->cRows;

            if (cNumRows)
            {
                LPTSTR lpsz = lpRowAB->aRow[0].lpProps[ieid_PR_DISPLAY_NAME].Value.LPSZ;
                LPENTRYID lpEID = (LPENTRYID) lpRowAB->aRow[0].lpProps[ieid_PR_ENTRYID].Value.bin.lpb;
                ULONG cbEID = lpRowAB->aRow[0].lpProps[ieid_PR_ENTRYID].Value.bin.cb;
                
                //
                // There are 2 kinds of objects - the MAPI_MAILUSER contact object
                // and the MAPI_DISTLIST contact object
                //
#ifdef HM_GROUP_SYNCING
                if( (!pWabSync->m_fSyncGroups && (lpRowAB->aRow[0].lpProps[ieid_PR_OBJECT_TYPE].Value.l == MAPI_MAILUSER)) ||
                    (pWabSync->m_fSyncGroups && (lpRowAB->aRow[0].lpProps[ieid_PR_OBJECT_TYPE].Value.l == MAPI_DISTLIST)) )
#else
                // Only consider MAILUSER objects
                if (lpRowAB->aRow[0].lpProps[ieid_PR_OBJECT_TYPE].Value.l == MAPI_MAILUSER)
#endif
                {
                    WABCONTACTINFO *lpWCI;
                    HTTPCONTACTINFO hci;

                    lpWCI = LocalAlloc(LMEM_ZEROINIT, sizeof(WABCONTACTINFO));

                    if (!lpWCI)
                    {
                        hr = E_OUTOFMEMORY;
                        DebugPrintError(( TEXT("WABCONTACTINFO Alloc Failed\n")));
                        goto out;
                    }

                    lpWCI->lpEID = LocalAlloc(LMEM_ZEROINIT, cbEID);

                    if (!lpWCI->lpEID)
                    {
                        hr = E_OUTOFMEMORY;
                        DebugPrintError(( TEXT("WABCONTACTINFO.ENTRYID Alloc Failed\n")));
                        goto out;
                    }

                    lpWCI->cbEID = cbEID;
                    CopyMemory(lpWCI->lpEID, lpEID, cbEID);
                    
                    lpWCI->ftModWab = lpRowAB->aRow[0].lpProps[ieid_PR_LAST_MODIFICATION_TIME].Value.ft;
                    
                    lpWCI->pszHotmailId = NULL;
                    lpWCI->pszModHotmail = NULL;
                    
                    if (SUCCEEDED(ContactInfo_LoadFromWAB(pWabSync, &hci, lpWCI, lpEID, cbEID)))
                    {
                        lpWCI->pszHotmailId = _StrDup(hci.pszId);
                        lpWCI->pszModHotmail = _StrDup(hci.pszModified);
                        ContactInfo_Free(&hci);
                    }

                    // search the multi value list of longs for the proper server id.  If found,
                    // then get the appropriate hotmail id and mod id.

                    if (FAILED(Vector_AddItem(pWabSync->m_pWabItems, lpWCI)))
                        goto out;
                }
		    }
		    FreeProws(lpRowAB );		
        }

	}while ( SUCCEEDED(hr) && cNumRows && lpRowAB)  ;

    
out:
    if (HR_FAILED(hr))
    {
        if (pWabSync->m_pWabItems)
            WABSync_FreeItems(pWabSync);
        if (lpContainer)
            lpContainer->lpVtbl->Release(lpContainer);
        if (lpABTable)
            lpABTable->lpVtbl->Release(lpABTable);
    }


    return hr;
}


HRESULT WABSync_LoadLastModInfo(LPWABSYNC pWabSync)
{
    TCHAR szKey[MAX_PATH];
    DWORD dwType = 0;
    DWORD dwValue = 0;
    HKEY hKey = NULL;
    DWORD dwSize;
    HRESULT hr = E_FAIL;
    FILETIME    ftValue;
    
    Assert(pWabSync);
    Assert(*pWabSync->m_szLoginName);

    StrCpyN(szKey, g_lpszSyncKey, ARRAYSIZE(szKey));
#ifndef UNICODE
    StrCatBuff(szKey, pWabSync->m_szLoginName, ARRAYSIZE(szKey));
#else
    {
        LPTSTR lpName = ConvertAtoW(pWabSync->m_szLoginName);
        StrCatBuff(szKey, lpName, ARRAYSIZE(szKey));
        LocalFreeAndNull(&lpName);
    }
#endif

    if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, szKey, 0, KEY_READ, &hKey))
    {
        dwSize = sizeof(DWORD);
        hr = RegQueryValueEx( hKey,  TEXT("Server ID"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);
        if (dwValue && ERROR_SUCCESS == hr)
        {
            pWabSync->m_dwServerID = dwValue;
        }
        else
            goto fail;

        dwSize = sizeof(FILETIME);
        if (ERROR_SUCCESS == (hr = RegQueryValueEx( hKey,  TEXT("Server Last Sync"), NULL, &dwType, (LPBYTE) &ftValue, &dwSize)))
        {
            pWabSync->m_ftLastSync = ftValue;
        }
        else
            goto fail;
    }
    else    
    {
        // the key for this user account isn't there.  
        // create a new one and return default values.

        // a random number would be nice here, instead we will
        // use the low DWORD of a date time....
        GetSystemTimeAsFileTime(&ftValue);
        pWabSync->m_dwServerID = ftValue.dwLowDateTime;

        // NULL filetime since we haven't synced yet, everything is after the last sync
        ZeroMemory(&pWabSync->m_ftLastSync, sizeof(FILETIME));

        hr = WABSync_SaveCurrentModInfo(pWabSync);
    }

fail:
    if (hKey)
        RegCloseKey(hKey);

    return hr;
}


HRESULT      WABSync_SaveCurrentModInfo(LPWABSYNC pWabSync)
{
    TCHAR szKey[MAX_PATH];
    HKEY hKey = NULL;
    HRESULT hr = E_FAIL;
    
    Assert(pWabSync);
    Assert(*pWabSync->m_szLoginName);

    StrCpyN(szKey, g_lpszSyncKey, ARRAYSIZE(szKey));

    {
        LPTSTR lpName = ConvertAtoW(pWabSync->m_szLoginName);
        StrCatBuff(szKey, lpName, ARRAYSIZE(szKey));
        LocalFreeAndNull(&lpName);
    }

    
    if(ERROR_SUCCESS == ( hr = RegCreateKey(HKEY_CURRENT_USER, szKey, &hKey)))
    {
        GetSystemTimeAsFileTime(&pWabSync->m_ftLastSync);

        hr = RegSetValueEx( hKey,  TEXT("Server ID"), 0, REG_DWORD, (BYTE *)&pWabSync->m_dwServerID, sizeof(DWORD));
        hr = RegSetValueEx( hKey,  TEXT("Server Last Sync"), 0, REG_BINARY, (BYTE *)&pWabSync->m_ftLastSync, sizeof(FILETIME));
    
        RegCloseKey(hKey);
    }
    
    return hr;
}

void WABSync_Progress(LPWABSYNC pWabSync, DWORD dwResId, DWORD dwCount)
{
    TCHAR   szRes[MAX_PATH], szMsg[MAX_PATH];
    HWND    hwndText;

    LoadString(hinstMapiX, dwResId, szRes, CharSizeOf(szRes));
    if (dwCount != -1)
        wnsprintf(szMsg, ARRAYSIZE(szMsg), szRes, dwCount);
    else
        StrCpyN(szMsg, szRes, ARRAYSIZE(szMsg));

    hwndText = GetDlgItem(pWabSync->m_hWnd, IDC_SYNC_MSG);
    if (hwndText)
    {
        SetWindowText(hwndText, szMsg);
    }

    SendDlgItemMessage(pWabSync->m_hWnd, IDC_SYNC_PROGBAR, PBM_SETRANGE, 0, MAKELPARAM(0, pWabSync->m_cTotalOps));
    SendDlgItemMessage(pWabSync->m_hWnd, IDC_SYNC_PROGBAR, PBM_SETPOS, pWabSync->m_cTotalOps - dwCount, 0);
}

void    WABSync_NextState(LPWABSYNC pWabSync)
{
    PostMessage(pWabSync->m_hWnd, WM_SYNC_NEXTSTATE, 0, (LPARAM)pWabSync);
}

void    _WABSync_NextState(LPWABSYNC pWabSync)
{
    HRESULT hr;

    Assert(pWabSync);

    pWabSync->m_state++;

    switch(pWabSync->m_state)
    {
        case SYNC_STATE_SERVER_CONTACT_DISCOVERY:
            WABSync_Progress(pWabSync, idsSyncConnecting, -1);
            hr = WABSync_RequestContactsRootProperty(pWabSync);
            break;

        case SYNC_STATE_PROCESS_OPS:
            WABSync_Progress(pWabSync, idsSyncSynchronizing, Vector_GetLength(pWabSync->m_pOps));
            if (pWabSync->m_pOps && Vector_GetLength(pWabSync->m_pOps) > 0)
            {
                if (WABSync_NextOp(pWabSync, FALSE))
                    return;
            }
            // fall through if there are no ops
            pWabSync->m_state++;

        case SYNC_STATE_PROCESS_CONFLICTS:
            WABSync_Progress(pWabSync, idsSyncConflicts, Vector_GetLength(pWabSync->m_pOps));
            if (pWabSync->m_pOps && Vector_GetLength(pWabSync->m_pOps) > 0)
            {
                if(SUCCEEDED(WABSync_DoConflicts(pWabSync)))
                    return;
            }
            // fall through if there are no ops
            pWabSync->m_state++;
            if (pWabSync->m_fAborted)
                return;

        case SYNC_STATE_PROCESS_MERGED_CONFLICTS:
            WABSync_Progress(pWabSync, idsSyncFinishing, Vector_GetLength(pWabSync->m_pOps));
            if (pWabSync->m_pOps && Vector_GetLength(pWabSync->m_pOps) > 0)
            {
                if (WABSync_NextOp(pWabSync, FALSE))
                    return;
            }
            // fall through if there are no ops
            pWabSync->m_state++;

        case SYNC_STATE_DONE:
            WABSync_FinishSynchronize(pWabSync, (pWabSync->m_cAborts == 0 ? S_OK : E_FAIL));
            break;
    }
}

BOOL  _WABSync_NextOp(LPWABSYNC pWabSync, BOOL fPopFirst)
{
    HRESULT hr = E_FAIL;
    LPHOTSYNCOP pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);

    Assert(pWabSync->m_state == SYNC_STATE_PROCESS_OPS || pWabSync->m_state == SYNC_STATE_PROCESS_MERGED_CONFLICTS);
    Assert(pOp);

    if (pOp && fPopFirst)
    {
        LPVECTOR  pVector;
        pVector = pWabSync->m_pOps;
        Assert(pVector);
        Vector_Remove(pVector, pOp);
        Syncop_Delete(pOp);
        pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);
    }

    if (pWabSync->m_state == SYNC_STATE_PROCESS_OPS)
        WABSync_Progress(pWabSync, idsSyncSynchronizing, Vector_GetLength(pWabSync->m_pOps));
    else if (pWabSync->m_state == SYNC_STATE_PROCESS_MERGED_CONFLICTS)
        WABSync_Progress(pWabSync, idsSyncFinishing, Vector_GetLength(pWabSync->m_pOps));

    if (pOp)
        hr = Syncop_Begin(pOp);  
    
    return (SUCCEEDED(hr));
}

BOOL WABSync_NextOp(LPWABSYNC pWabSync, BOOL fPopFirst)
{
    HRESULT hr = E_FAIL;
    LPHOTSYNCOP pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, 0);

    if (!pOp)
        return FALSE;
    PostMessage(pWabSync->m_hWnd, WM_SYNC_NEXTOP, fPopFirst, (LPARAM)pWabSync);
    return TRUE;
}

void         WABSync_FreeOps(LPWABSYNC pWabSync)
{
    LPHOTSYNCOP    pOp;

    if (pWabSync->m_pOps)
    {
        LONG   dwIndex, cItems = Vector_GetLength(pWabSync->m_pOps);

        for (dwIndex = cItems - 1; dwIndex >= 0; --dwIndex)
        {
            pOp = (LPHOTSYNCOP)Vector_GetItem(pWabSync->m_pOps, dwIndex);

            if (pOp)
            {
                Vector_RemoveItem(pWabSync->m_pOps, dwIndex);
                Syncop_Abort(pOp);
                Syncop_Delete(pOp);
            }

            if (dwIndex == 0)
                break;
        }
    }
}

void         WABSync_FreeItems(LPWABSYNC pWabSync)
{
    LPWABCONTACTINFO    lprWCI;

    if (pWabSync->m_pWabItems)
    {
        LONG   dwIndex, cItems = Vector_GetLength(pWabSync->m_pWabItems);

        for (dwIndex = cItems - 1; dwIndex >= 0; --dwIndex)
        {
            lprWCI = (LPWABCONTACTINFO)Vector_GetItem(pWabSync->m_pWabItems, dwIndex);

            if (lprWCI)
            {
                if (lprWCI->lpEID)
                    LocalFree(lprWCI->lpEID);
                LocalFree(lprWCI);
            }

            Vector_RemoveItem(pWabSync->m_pWabItems, dwIndex);
            
            if (dwIndex == 0)
                break;
        }
    }

}

HRESULT WABSync_DoConflicts(LPWABSYNC pWabSync)
{
    LONG                dwIndex, cConflicts = 0, cItems = Vector_GetLength(pWabSync->m_pOps);
    LPHOTSYNCOP         pOp;
    LPHTTPCONFLICTINFO  pConflicts = NULL;
    if (cItems == 0)
    {
        WABSync_NextState(pWabSync);
        return S_OK;
    }

    pConflicts = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONFLICTINFO) * cItems);
    if (!pConflicts)
        return E_OUTOFMEMORY;

    for (dwIndex = 0; dwIndex < cItems; dwIndex++)
    {
        pOp = Vector_GetItem(pWabSync->m_pOps, dwIndex);
        Assert(pOp->m_bOpType == SYNCOP_CONFLICT);
        
        if (!pOp || pOp->m_bOpType != SYNCOP_CONFLICT)
           continue;

        Assert(pOp->m_pServerContact);
        Assert(pOp->m_pClientContact);

        pConflicts[dwIndex].pciServer = pOp->m_pServerContact;
        pConflicts[dwIndex].pciClient = pOp->m_pClientContact;
        cConflicts++;
    }

    if (ResolveConflicts(pWabSync->m_hParentWnd, pConflicts, cConflicts))
    {
        HRESULT hr = S_OK;
        for (dwIndex = 0; dwIndex < cConflicts; dwIndex++)
        {
            BOOL    fChanged = FALSE;
            DWORD   dw;

            pOp = Vector_GetItem(pWabSync->m_pOps, dwIndex);
            Assert(pOp->m_bOpType == SYNCOP_CONFLICT);
        
            Assert(pOp->m_pServerContact);
            Assert(pOp->m_pClientContact);
            
            for (dw = 0; dw < CONFLICT_DECISION_COUNT; dw++)
            {
                if (pConflicts[dwIndex].rgcd[dw] != 0)
                {
                    fChanged = TRUE;
                    break;
                }
            }

            if (fChanged)
            {
                hr = ContactInfo_BlendResults(pOp->m_pServerContact, pOp->m_pClientContact, (CONFLICT_DECISION *)&(pConflicts[dwIndex].rgcd));
                pOp->m_bState = OP_STATE_MERGED;
            }
            else
            {
                // toss out the conflict since they didn't want to change anything
                pOp->m_bState = OP_STATE_DONE;
            }

            // if any of it was skipped, we need to remember this and not update the timestamps.
            if (pConflicts[dwIndex].fContainsSkip)
            {
                pOp->m_fPartialSkip = TRUE;
                pWabSync->m_fSkipped = TRUE;
            }
        }
        //reset progress to new total ops
        pWabSync->m_cTotalOps = Vector_GetLength(pWabSync->m_pOps);

        // HACK to get back into processing ops
        WABSync_NextState(pWabSync);
        return hr;
    }
    else
        WABSync_Abort(pWabSync, E_UserCancel);

    if (pConflicts)
        LocalFree(pConflicts);

    return E_FAIL;
}


void WABSync_MergeAddsToConflicts(LPWABSYNC pWabSync)
{
    DWORD       dwOpCount;
    DWORD       dwCliAddIndex, dwSvrAddIndex;
    LPHOTSYNCOP pCliOp, pOp, pNewOp;
    BOOL        fMerged = FALSE;
    HRESULT     hr;

    dwOpCount = Vector_GetLength(pWabSync->m_pOps);

    // search for Client Adds.  If found, look for a server add for the 
    // same contact.
    for (dwCliAddIndex = 0; dwCliAddIndex < dwOpCount; dwCliAddIndex++)
    {
        fMerged = FALSE;
        pCliOp = Vector_GetItem(pWabSync->m_pOps, dwCliAddIndex);
        if (pCliOp && pCliOp->m_bOpType == SYNCOP_CLIENT_ADD)
        {
            for (dwSvrAddIndex = 0; dwSvrAddIndex < dwOpCount; dwSvrAddIndex++)
            {
                pOp = Vector_GetItem(pWabSync->m_pOps, dwSvrAddIndex);
                if (pOp && pOp->m_bOpType == SYNCOP_SERVER_ADD)
                {
                    if (pOp->m_pClientContact && pOp->m_pClientContact->pszEmail &&
                        pCliOp->m_pServerContact && pCliOp->m_pServerContact->pszEmail)
                    {
                        if (lstrcmpiA(pCliOp->m_pServerContact->pszEmail, pOp->m_pClientContact->pszEmail) == 0)
                        {
                            pNewOp = Syncop_CreateConflict(pCliOp->m_pContactInfo);
                            Assert(pNewOp);

                            if (pNewOp)
                            {
                                pNewOp->m_pContactInfo->lpEID = pOp->m_pContactInfo->lpEID;
                                pNewOp->m_pContactInfo->cbEID = pOp->m_pContactInfo->cbEID;
                                pNewOp->m_pContactInfo->pszaContactIds = pOp->m_pContactInfo->pszaContactIds;
                                pNewOp->m_pContactInfo->pszaServerIds = pOp->m_pContactInfo->pszaServerIds;
                                pNewOp->m_pContactInfo->pszaModtimes = pOp->m_pContactInfo->pszaModtimes;
                                pNewOp->m_pContactInfo->pszaEmails = pOp->m_pContactInfo->pszaEmails;
                                pOp->m_pContactInfo->pszaContactIds = NULL;
                                pOp->m_pContactInfo->pszaServerIds = NULL;
                                pOp->m_pContactInfo->pszaModtimes = NULL;
                                pOp->m_pContactInfo->pszaEmails = NULL;
                                pOp->m_pContactInfo->lpEID = NULL;
                                pOp->m_pContactInfo->cbEID = 0;

                                pCliOp->m_pContactInfo = NULL;
                                pNewOp->m_pServerContact = pCliOp->m_pServerContact;
                                pCliOp->m_pServerContact = NULL;

                                Syncop_Init(pNewOp, (IHTTPMailCallback *)pWabSync, pWabSync->m_pTransport);
                                hr = Vector_AddItem(pWabSync->m_pOps, pNewOp);

                                if (dwSvrAddIndex < dwCliAddIndex)
                                    --dwCliAddIndex;
                                Vector_Remove(pWabSync->m_pOps, pOp);

                                Vector_Remove(pWabSync->m_pOps, pCliOp);
                                
                                dwOpCount = Vector_GetLength(pWabSync->m_pOps);
                                fMerged = TRUE;
                            }
                            break;
                        }
                    }
                }
            }
        }
        if (fMerged)
            -- dwCliAddIndex;
    }
}


// ****************************************************************************************************
//  V   E   C   T   O   R       "C   L   A   S   S"   
//
//  Basic vector class (resizable / sortable array of LPVOIDs).
//


HRESULT    Vector_Create(LPVECTOR *ppVector)
{
    Assert(ppVector);

    *ppVector = LocalAlloc(LMEM_ZEROINIT, sizeof(VECTOR));

    if (*ppVector)
    {
        (*ppVector)->m_dwGrowBy = 4;
        return S_OK;
    }
    else
        return E_OUTOFMEMORY;
}

/*
    Vector_Delete

    Clean up any memory that was allocated in the Vector object
*/
void    Vector_Delete(LPVECTOR pVector)
{
    Assert(pVector);

    if (pVector->m_pItems)
        LocalFree(pVector->m_pItems);
    
    if (pVector)
        LocalFree(pVector);
}

/*
    Vector_GetLength

    Get the number of items in the vector.
*/
DWORD       Vector_GetLength(LPVECTOR pVector)
{
    Assert(pVector);

    return pVector->m_cItems;
}

/*
    Vector_AddItem

    Add a item to the end of the item list.
*/
HRESULT    Vector_AddItem(LPVECTOR pVector, LPVOID lpvItem)
{
    DWORD   dwNewIndex;
    DWORD   dw;

    Assert(pVector);

    // make more room for pointers, if necessary
    if (pVector->m_cSpaces == pVector->m_cItems)
    {
        LPVOID  pNewItems;
        DWORD   dwOldSize = pVector->m_cSpaces * sizeof(char *);

        pVector->m_cSpaces += pVector->m_dwGrowBy;
        
        pNewItems = LocalAlloc(LMEM_ZEROINIT, sizeof(char *) * pVector->m_cSpaces);

        if (!pNewItems)
        {
            pVector->m_cSpaces -= pVector->m_dwGrowBy;
            return E_OUTOFMEMORY;
        }
        else
        {
            if (pVector->m_pItems)
            {
                CopyMemory(pNewItems, pVector->m_pItems, dwOldSize);
                LocalFree(pVector->m_pItems);
            }
 
            pVector->m_pItems = (LPVOID *)pNewItems;
            pVector->m_dwGrowBy = pVector->m_dwGrowBy << 1;   // double the size for the next time we grow it.
        }
    }
    
    //now put the item in the next location
    dwNewIndex = pVector->m_cItems++;
    
    pVector->m_pItems[dwNewIndex] = lpvItem;
    
    return S_OK;
}

/*
    Vector_Remove
    
    Remove a given item from the vector
*/
void        Vector_Remove(LPVECTOR pVector, LPVOID lpvItem)
{
    DWORD   dw;

    for (dw = 0; dw < pVector->m_cItems; dw++)
    {
        if (pVector->m_pItems[dw] == lpvItem)
        {
            Vector_RemoveItem(pVector, dw);
            return;
        }
    }
}

/*
    Vector_RemoveItem
    
    Remove a item at zero based index iIndex 
*/

void    Vector_RemoveItem(LPVECTOR pVector, DWORD    dwIndex)
{
    int     iCopySize;
    DWORD   dw;

    Assert(pVector);
    Assert(dwIndex < pVector->m_cItems);
 
    // move the other pItems down
    for (dw = dwIndex+1; dw < pVector->m_cItems; dw ++)
        pVector->m_pItems[dw - 1] = pVector->m_pItems[dw];

    // null out the last item in the list and decrement the counter.
    pVector->m_pItems[--pVector->m_cItems] = NULL;
}

/*
    CVector::GetItem
    
    Return the pointer to the item at zero based index iIndex.

    Return the item at the given index.  Note that the char pointer
    is still owned by the item list and should not be deleted.
*/

LPVOID    Vector_GetItem(LPVECTOR pVector, DWORD   dwIndex)
{
    Assert(pVector);
    Assert(dwIndex < pVector->m_cItems || dwIndex == 0);

    if (dwIndex < pVector->m_cItems )
        return pVector->m_pItems[dwIndex];
    else
        return NULL;
}


void    Vector_Sort(LPVECTOR pVector, FnCompareFunc lpfnCompare)
{
    qsort(pVector->m_pItems, pVector->m_cItems, sizeof(LPVOID), lpfnCompare);
}

LPHOTSYNCOP Syncop_CreateServerAdd(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_SERVER_ADD;
        pOp->m_pfnHandleResponse = Syncop_ServerAddResponse;
        pOp->m_pfnBegin = Syncop_ServerAddBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}

LPHOTSYNCOP Syncop_CreateServerDelete(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_SERVER_DELETE;
        pOp->m_pfnHandleResponse = Syncop_ServerDeleteResponse;
        pOp->m_pfnBegin = Syncop_ServerDeleteBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}
    
LPHOTSYNCOP Syncop_CreateServerChange(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_SERVER_CHANGE;
        pOp->m_pfnHandleResponse = Syncop_ServerChangeResponse;
        pOp->m_pfnBegin = Syncop_ServerChangeBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}

LPHOTSYNCOP Syncop_CreateClientAdd(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    Assert(pContactInfo);
    Assert(pOp);

    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_CLIENT_ADD;
        pOp->m_pfnHandleResponse = Syncop_ClientAddResponse;
        pOp->m_pfnBegin = Syncop_ClientAddBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}

LPHOTSYNCOP Syncop_CreateClientDelete(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_CLIENT_DELETE;
        pOp->m_pfnHandleResponse = Syncop_ClientDeleteResponse;
        pOp->m_pfnBegin = Syncop_ClientDeleteBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}

LPHOTSYNCOP Syncop_CreateClientChange(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_CLIENT_CHANGE;
        pOp->m_pfnHandleResponse = Syncop_ClientChangeResponse;
        pOp->m_pfnBegin = Syncop_ClientChangeBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}

LPHOTSYNCOP Syncop_CreateConflict(LPWABCONTACTINFO pContactInfo)
{
    LPHOTSYNCOP pOp = LocalAlloc(LMEM_ZEROINIT, sizeof(HOTSYNCOP));
    
    if (pOp)
    {
        pOp->m_bOpType = SYNCOP_CONFLICT;
        pOp->m_pfnHandleResponse = Syncop_ConflictResponse;
        pOp->m_pfnBegin = Syncop_ConflictBegin;
        pOp->m_pContactInfo = pContactInfo;
    }

    return pOp;
}


HRESULT     Syncop_Init(LPHOTSYNCOP pSyncOp, IHTTPMailCallback *pHotSync, IHTTPMailTransport     *pTransport)
{
    HRESULT hr = S_OK;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pHotSync == NULL);
    Assert(pSyncOp->m_pTransport == NULL);

    pSyncOp->m_pClientContact = NULL;
    pSyncOp->m_pHotSync = pHotSync;
    pSyncOp->m_pTransport = pTransport;
    pSyncOp->m_bState = OP_STATE_INITIALIZING;
    pSyncOp->m_fPartialSkip = FALSE;
    pSyncOp->m_dwRetries = 0;

    if (pSyncOp->m_pTransport)
        IHTTPMailTransport_AddRef(pSyncOp->m_pTransport);

    if (pSyncOp->m_pHotSync)
        IHTTPMailCallback_AddRef(pSyncOp->m_pHotSync);

    if (pSyncOp->m_bOpType == SYNCOP_SERVER_ADD ||
        pSyncOp->m_bOpType == SYNCOP_SERVER_CHANGE ||
        pSyncOp->m_bOpType == SYNCOP_CLIENT_CHANGE ||
        pSyncOp->m_bOpType == SYNCOP_CONFLICT )
    {
        pSyncOp->m_pClientContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));
        if (pSyncOp->m_pClientContact)
            hr = ContactInfo_LoadFromWAB(((LPWABSYNC)pSyncOp->m_pHotSync), 
                                            pSyncOp->m_pClientContact, 
                                            pSyncOp->m_pContactInfo,
                                            pSyncOp->m_pContactInfo->lpEID, 
                                            pSyncOp->m_pContactInfo->cbEID);
    }

    return hr;
}

HRESULT     Syncop_Delete(LPHOTSYNCOP pSyncOp)
{
    Assert(pSyncOp);

    if (pSyncOp->m_pTransport)
        IHTTPMailTransport_Release(pSyncOp->m_pTransport);

    if (pSyncOp->m_pHotSync)
        IHTTPMailCallback_Release(pSyncOp->m_pHotSync);

    if (pSyncOp->m_pServerContact)
    {
        ContactInfo_Free(pSyncOp->m_pServerContact);
        LocalFree(pSyncOp->m_pServerContact);
    }
    
    if (pSyncOp->m_pClientContact)
    {
        ContactInfo_Free(pSyncOp->m_pClientContact);
        LocalFree(pSyncOp->m_pClientContact);
    }
    
    if (pSyncOp->m_pContactInfo)
    {
        WABContact_Delete(pSyncOp->m_pContactInfo);
    }

    LocalFree(pSyncOp);
    
    return S_OK;
}

HRESULT     Syncop_HandleResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    Assert(pSyncOp);
    Assert(pSyncOp->m_pfnHandleResponse);
    Assert(pSyncOp->m_bOpType != SYNCOP_SERVER_INVALID);

    return (pSyncOp->m_pfnHandleResponse)(pSyncOp, pResponse);

}

HRESULT     Syncop_Begin(LPHOTSYNCOP pSyncOp)
{
    Assert(pSyncOp);
    Assert(pSyncOp->m_pfnBegin);
    Assert(pSyncOp->m_bOpType != SYNCOP_SERVER_INVALID);

    return (pSyncOp->m_pfnBegin)(pSyncOp);
}

HRESULT     Syncop_Abort(LPHOTSYNCOP pSyncOp)
{
    Assert(pSyncOp);

    return E_NOTIMPL;
}

HRESULT     Syncop_ServerAddResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr = S_OK;
    LPWABSYNC   pWabSync = (LPWABSYNC)(pSyncOp->m_pHotSync);

    Assert(pSyncOp);
    Assert(pWabSync);

    if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rPostContactInfo.pszHref)
    {
        pSyncOp->m_pClientContact->pszId = pResponse->rPostContactInfo.pszId;
        pResponse->rPostContactInfo.pszId = NULL;

        pSyncOp->m_pClientContact->pszModified = pResponse->rPostContactInfo.pszModified;
        pResponse->rPostContactInfo.pszModified = NULL;

        hr = ContactInfo_SaveToWAB(pWabSync, pSyncOp->m_pClientContact, pSyncOp->m_pContactInfo, 
                                        pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, FALSE);

        if (!WABSync_NextOp(pWabSync, TRUE))
            WABSync_NextState(pWabSync);

    }
    else
    {
        if (IXP_E_HTTP_CONFLICT == pResponse->rIxpResult.hrResult)
        {
            // if we get a conflict, it is probably because the nickname we 
            // generated is not unique.  Lets try to generate a new one, but
            // don't try this more than twice.
            if (pSyncOp->m_dwRetries <= 2)
            {
                pSyncOp->m_dwRetries ++;
                if (SUCCEEDED(hr = ContactInfo_GenerateNickname(pSyncOp->m_pClientContact)))
                    hr = pSyncOp->m_pTransport->lpVtbl->PostContact(pSyncOp->m_pTransport, ((LPWABSYNC)pSyncOp->m_pHotSync)->m_pszRootUrl, pSyncOp->m_pClientContact, 0);
        
            }
            else
            {   // [PaulHi] 12/3/98  After trying three different nicknames, abort this
                // synchronization operation.
                hr = pResponse->rIxpResult.hrResult;
            }
        }
        else
        {
            if (pResponse->rPostContactInfo.pszHref)
            {
                // TODO : delete the server version here?

                // we have the reference, just not the timestamp or id. Guess the id, and 
                // throw in a crappy timestamp so that it will get fixed up next time
                char *pszId = NULL, *psz;

                psz = pResponse->rPostContactInfo.pszHref;
                while (*psz)
                {
                    if ('/' == *psz)
                    {
                        if (psz[1] == 0)
                            *psz = 0;
                        else
                            pszId = ++psz;
                    }
                    else    
                        psz++;
                }
            
                if (pszId)
                {
                    pSyncOp->m_pClientContact->pszId = _StrDup(pszId);
                    pResponse->rPostContactInfo.pszId = NULL;

                    pResponse->rPostContactInfo.pszModified = _StrDup( "1993-01-01T00:00");
                    hr = ContactInfo_SaveToWAB(pWabSync, pSyncOp->m_pClientContact,  pSyncOp->m_pContactInfo,
                                                    pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, FALSE);

                    if (!WABSync_NextOp(pWabSync, TRUE))
                        WABSync_NextState(pWabSync);
                
                    return S_OK;
                }
            }
            hr = pResponse->rIxpResult.hrResult;
        }
    }
    return hr;
}


HRESULT     Syncop_ServerAddBegin(LPHOTSYNCOP pSyncOp)
{
    HRESULT hr;

    Assert(pSyncOp);

    if (!pSyncOp->m_pClientContact)
    {
        hr = E_OUTOFMEMORY;
        goto exit;
    }

    if (OP_STATE_INITIALIZING == pSyncOp->m_bState)
    {
        pSyncOp->m_bState = OP_STATE_SERVER_GET;

        if (pSyncOp->m_pClientContact->pszNickname ||  SUCCEEDED(hr = ContactInfo_GenerateNickname(pSyncOp->m_pClientContact)))
            hr = pSyncOp->m_pTransport->lpVtbl->PostContact(pSyncOp->m_pTransport, ((LPWABSYNC)pSyncOp->m_pHotSync)->m_pszRootUrl, pSyncOp->m_pClientContact, 0);
    }

exit:
    if (FAILED(hr))
    {
        if (pSyncOp->m_pClientContact)
        {
            ContactInfo_Free(pSyncOp->m_pClientContact);
            LocalFree(pSyncOp->m_pClientContact);
            pSyncOp->m_pClientContact = NULL;
        }
    }

    return hr;
}



HRESULT     Syncop_ServerDeleteResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr = pResponse->rIxpResult.hrResult;
    LPWABSYNC   pWabSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);
    
    if (SUCCEEDED(pResponse->rIxpResult.hrResult))
    {
        TCHAR   tszServerId[MAX_PATH];
        TCHAR   tszKey[MAX_PATH];
        HKEY    hkey = NULL;

        // now that the delete has completed, delete the tombstone from the registry.
        if ( FAILED(hrMakeContactId(
            tszServerId,
            MAX_PATH,
            ((LPIAB)(pWabSync->m_pAB))->szProfileID,
            pWabSync->m_pszAccountId,
            pWabSync->m_szLoginName)) )
        {
            return hr;
        }
        wnsprintf(tszKey, ARRAYSIZE(tszKey), TEXT("%s%s"), g_lpszSyncKey, tszServerId);

        if(ERROR_SUCCESS == RegOpenKeyEx(HKEY_CURRENT_USER, tszKey, 0, KEY_SET_VALUE, &hkey))
        {
            LPTSTR lpKey =
                ConvertAtoW(pSyncOp->m_pContactInfo->pszHotmailId);
            RegDeleteValue(hkey, lpKey);
            LocalFreeAndNull(&lpKey);
            RegCloseKey(hkey);
        }

        if (!WABSync_NextOp(pWabSync, TRUE))
            WABSync_NextState(pWabSync);
    }

    return hr;
}


HRESULT     Syncop_ServerDeleteBegin(LPHOTSYNCOP pSyncOp)
{
    HRESULT hr;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pContactInfo->pszHotmailHref);
    hr = pSyncOp->m_pTransport->lpVtbl->CommandDELETE(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, 0);

    return hr;
}


HRESULT     Syncop_ServerChangeResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr = pResponse->rIxpResult.hrResult;
    LPWABSYNC pWabSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);

    if (OP_STATE_SERVER_GET == pSyncOp->m_bState)
    {
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            // assume the whole struct
            Assert(pResponse->rContactInfoList.prgContactInfo);
            Assert(pResponse->rContactInfoList.cContactInfo == 1);
            
            if (!pSyncOp->m_pServerContact)
                pSyncOp->m_pServerContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));

            *pSyncOp->m_pServerContact = *pResponse->rContactInfoList.prgContactInfo;
            ContactInfo_Clear(pResponse->rContactInfoList.prgContactInfo);
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            if (!ContactInfo_Match(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact))
            {
                pSyncOp->m_bState = OP_STATE_SERVER_PUT;
                hr = ContactInfo_PreparePatch(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact);
                hr = pSyncOp->m_pTransport->lpVtbl->PatchContact(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, pSyncOp->m_pClientContact, 0);
            }
            else
                if (!WABSync_NextOp(pWabSync, TRUE))
                    WABSync_NextState(pWabSync);
        }
    }
    else if (OP_STATE_SERVER_PUT == pSyncOp->m_bState)
    {
        // if it succeeded, save the new values mod stamp, etc to the wab
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            SafeCoMemFree(pSyncOp->m_pClientContact->pszId);
            pSyncOp->m_pClientContact->pszId = pResponse->rPostContactInfo.pszId;
            pResponse->rPostContactInfo.pszId = NULL;

            SafeCoMemFree(pSyncOp->m_pClientContact->pszModified);
            pSyncOp->m_pClientContact->pszModified = pResponse->rPostContactInfo.pszModified;
            pResponse->rPostContactInfo.pszModified = NULL;

            hr = ContactInfo_SaveToWAB(pWabSync, pSyncOp->m_pClientContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, FALSE);

            if (!WABSync_NextOp(pWabSync, TRUE))
                WABSync_NextState(pWabSync);
        }
    }
    
    return hr;
}


HRESULT     Syncop_ServerChangeBegin(LPHOTSYNCOP pSyncOp)
{
    LPWABSYNC   pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;
    HRESULT     hr = S_OK;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pTransport);
    Assert(pSyncOp->m_pContactInfo);
    Assert(pSyncOp->m_pContactInfo->pszHotmailHref);
    
    if (OP_STATE_INITIALIZING == pSyncOp->m_bState)
    {
        if (pSyncOp->m_pServerContact)
        {
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            if (!ContactInfo_Match(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact))
            {
                pSyncOp->m_bState = OP_STATE_SERVER_PUT;
                hr = ContactInfo_PreparePatch(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact);

                hr = pSyncOp->m_pTransport->lpVtbl->PatchContact(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, pSyncOp->m_pClientContact, 0);
            }
            else
                if (!WABSync_NextOp(pHotSync, TRUE))
                    WABSync_NextState(pHotSync);
        }
        else
        {
            pSyncOp->m_bState = OP_STATE_SERVER_GET;
            hr = pSyncOp->m_pTransport->lpVtbl->ContactInfo(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, 0);
        }
    }

    return hr;
}



HRESULT     Syncop_ClientAddResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr = S_OK;
    LPWABSYNC pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);

    if (OP_STATE_SERVER_GET == pSyncOp->m_bState)
    {
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            // assume the whole struct
            Assert(pResponse->rContactInfoList.prgContactInfo);
            Assert(pResponse->rContactInfoList.cContactInfo == 1);
            
            if (!pSyncOp->m_pServerContact)
                pSyncOp->m_pServerContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));

            *pSyncOp->m_pServerContact = *pResponse->rContactInfoList.prgContactInfo;
            ContactInfo_Clear(pResponse->rContactInfoList.prgContactInfo);
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, NULL, NULL, 0, FALSE);

            if (!WABSync_NextOp(pHotSync, TRUE))
                WABSync_NextState(pHotSync);
        }
        else
            hr = pResponse->rIxpResult.hrResult;
    }

    return hr;
}


HRESULT     Syncop_ClientAddBegin(LPHOTSYNCOP pSyncOp)
{
    HRESULT     hr = S_OK;
    LPWABSYNC   pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pTransport);
    Assert(pSyncOp->m_pContactInfo);
    Assert(pSyncOp->m_pContactInfo->pszHotmailHref);
    
    if (OP_STATE_INITIALIZING == pSyncOp->m_bState)
    {
        if (pSyncOp->m_pServerContact)
        {
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, NULL, NULL, 0, FALSE);

            if (!WABSync_NextOp(pHotSync, TRUE))
                WABSync_NextState(pHotSync);
        }
        else
        {
            pSyncOp->m_bState = OP_STATE_SERVER_GET;
            hr = pSyncOp->m_pTransport->lpVtbl->ContactInfo(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, 0);
        }
    }

    return hr;
}



HRESULT     Syncop_ClientDeleteResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    Assert(pSyncOp);

    return E_NOTIMPL;
}


HRESULT     Syncop_ClientDeleteBegin(LPHOTSYNCOP pSyncOp)
{
    LPABCONT        lpWABCont = NULL;
    LPWABSYNC       pWabSync = (LPWABSYNC)pSyncOp->m_pHotSync;
	HRESULT         hr = S_OK;
    ULONG           cbWABEID = 0;
    LPENTRYID       lpWABEID = NULL;
    ULONG           ulObjType;
    SBinaryArray    SBA = {0};

    Assert(pSyncOp);

    if(HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->GetPAB(pWabSync->m_pAB, &cbWABEID, &lpWABEID)))
        goto exit;

    if(HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->OpenEntry(pWabSync->m_pAB,
                                  cbWABEID,     // size of EntryID to open
                                  lpWABEID,     // EntryID to open
                                  NULL,         // interface
                                  0,            // flags
                                  &ulObjType,
                                  (LPUNKNOWN *)&lpWABCont)))
        goto exit;

    if(!(SBA.lpbin = LocalAlloc(LMEM_ZEROINIT, sizeof(SBinary))))
        goto exit;

    SetSBinary(&(SBA.lpbin[0]), pSyncOp->m_pContactInfo->cbEID, (LPBYTE)pSyncOp->m_pContactInfo->lpEID);

    SBA.cValues = 1;
    
    if(HR_FAILED(hr = lpWABCont->lpVtbl->DeleteEntries( lpWABCont, (LPENTRYLIST) &SBA, 0)))
    {
        hr = S_OK;
        goto exit;
    }
exit:
    if(SBA.lpbin && SBA.cValues)
    {
        LocalFreeAndNull((LPVOID *) (&(SBA.lpbin[0].lpb)));
        LocalFreeAndNull(&SBA.lpbin);
    }

    if(lpWABCont)
        UlRelease(lpWABCont);

    if(lpWABEID)
        FreeBufferAndNull(&lpWABEID);

    if (!WABSync_NextOp(pWabSync, TRUE))
        WABSync_NextState(pWabSync);

    return hr;
}



HRESULT     Syncop_ClientChangeResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT     hr = S_OK;
    LPWABSYNC   pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);

    if (OP_STATE_SERVER_GET == pSyncOp->m_bState)
    {
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            // assume the whole struct
            Assert(pResponse->rContactInfoList.prgContactInfo);
            Assert(pResponse->rContactInfoList.cContactInfo == 1);
            
            if (!pSyncOp->m_pServerContact)
                pSyncOp->m_pServerContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));

            *pSyncOp->m_pServerContact = *pResponse->rContactInfoList.prgContactInfo;
            ContactInfo_Clear(pResponse->rContactInfoList.prgContactInfo);
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            ContactInfo_EmptyNullItems(pSyncOp->m_pServerContact);
            ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, TRUE);

            if (!WABSync_NextOp(pHotSync, TRUE))
                WABSync_NextState(pHotSync);
        }
        else
            hr = pResponse->rIxpResult.hrResult;
    }

    return hr;
}


HRESULT     Syncop_ClientChangeBegin(LPHOTSYNCOP pSyncOp)
{
    HRESULT     hr = S_OK;
    LPWABSYNC   pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pTransport);
    Assert(pSyncOp->m_pContactInfo);
    Assert(pSyncOp->m_pContactInfo->pszHotmailHref);
    
    if (OP_STATE_INITIALIZING == pSyncOp->m_bState)
    {
        if (pSyncOp->m_pServerContact)
        {
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            ContactInfo_EmptyNullItems(pSyncOp->m_pServerContact);
            ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, TRUE);

            if (!WABSync_NextOp(pHotSync, TRUE))
                WABSync_NextState(pHotSync);
        }
        else
        {
            pSyncOp->m_bState = OP_STATE_SERVER_GET;
            hr = pSyncOp->m_pTransport->lpVtbl->ContactInfo(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, 0);
        }
    }

    return hr;
}



HRESULT     Syncop_ConflictResponse(LPHOTSYNCOP pSyncOp, LPHTTPMAILRESPONSE pResponse)
{
    HRESULT hr = S_OK;
    LPWABSYNC pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);

    if (OP_STATE_SERVER_GET == pSyncOp->m_bState)
    {
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            // assume the whole struct
            Assert(pResponse->rContactInfoList.prgContactInfo);
            Assert(pResponse->rContactInfoList.cContactInfo == 1);
            
            if (!pSyncOp->m_pServerContact)
                pSyncOp->m_pServerContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));

            *pSyncOp->m_pServerContact = *pResponse->rContactInfoList.prgContactInfo;
            ContactInfo_Clear(pResponse->rContactInfoList.prgContactInfo);
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            // if the records match as far as we're concerned, we are done.
            if (ContactInfo_Match(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact))
            {
                // update the timestamp so it isn't a conflict next time.
                ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, TRUE);

                if (!WABSync_NextOp(pHotSync, TRUE))
                    WABSync_NextState(pHotSync);
            }
            else
            {
                // move this item to the end, once all conflicts are loaded, then we
                // will do the dialog
                Vector_Remove(pHotSync->m_pOps, pSyncOp);
                Vector_AddItem(pHotSync->m_pOps, pSyncOp);

                if (!WABSync_NextOp(pHotSync, FALSE))
                    WABSync_NextState(pHotSync);
            }
        }
        else
            hr = pResponse->rIxpResult.hrResult;
    }
    else if (OP_STATE_SERVER_PUT == pSyncOp->m_bState)
    {
        // if it succeeded, save the new values mod stamp, etc to the wab
        if (SUCCEEDED(pResponse->rIxpResult.hrResult) && pResponse->rContactInfoList.prgContactInfo)
        {
            SafeCoMemFree(pSyncOp->m_pClientContact->pszId);
            pSyncOp->m_pClientContact->pszId = pResponse->rPostContactInfo.pszId;
            pResponse->rPostContactInfo.pszId = NULL;

            SafeCoMemFree(pSyncOp->m_pClientContact->pszModified);
            pSyncOp->m_pClientContact->pszModified = pResponse->rPostContactInfo.pszModified;
            pResponse->rPostContactInfo.pszModified = NULL;

            if (!pSyncOp->m_fPartialSkip)
                hr = ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pClientContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, FALSE);

            if (!WABSync_NextOp(pHotSync, TRUE))
                WABSync_NextState(pHotSync);
        }
    }

    return hr;
}



HRESULT     Syncop_ConflictBegin(LPHOTSYNCOP pSyncOp)
{
    HRESULT     hr = S_OK;
    LPWABSYNC   pHotSync = (LPWABSYNC)pSyncOp->m_pHotSync;

    Assert(pSyncOp);
    Assert(pSyncOp->m_pTransport);
    Assert(pSyncOp->m_pContactInfo);
    Assert(pSyncOp->m_pContactInfo->pszHotmailHref);
    
    if (OP_STATE_INITIALIZING == pSyncOp->m_bState)
    {
        if (pSyncOp->m_pServerContact)
        {
            pSyncOp->m_bState = OP_STATE_LOADED;
            
            // if the records match as far as we're concerned, we are done.
            if (ContactInfo_Match(pSyncOp->m_pServerContact, pSyncOp->m_pClientContact))
            {
                // update the timestamp so it isn't a conflict next time.
                ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pServerContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, TRUE);

                if (!WABSync_NextOp(pHotSync, TRUE))
                    WABSync_NextState(pHotSync);
            }
            else
            {
                // move this item to the end, once all conflicts are loaded, then we
                // will do the dialog
                Vector_Remove(pHotSync->m_pOps, pSyncOp);
                Vector_AddItem(pHotSync->m_pOps, pSyncOp);

                if (!WABSync_NextOp(pHotSync, FALSE))
                    WABSync_NextState(pHotSync);
            }
        }
        else
        {
            pSyncOp->m_bState = OP_STATE_SERVER_GET;
			hr = pSyncOp->m_pTransport->lpVtbl->ContactInfo(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, 0);
        }
    }
    else if (OP_STATE_LOADED == pSyncOp->m_bState)
        WABSync_NextState(pHotSync);
    else if (OP_STATE_MERGED == pSyncOp->m_bState)
    {
        hr = ContactInfo_SaveToWAB(pHotSync, pSyncOp->m_pClientContact, pSyncOp->m_pContactInfo, pSyncOp->m_pContactInfo->lpEID, pSyncOp->m_pContactInfo->cbEID, TRUE);
        if (FAILED(hr))
            return hr;

        pSyncOp->m_bState = OP_STATE_SERVER_PUT;
        hr = pSyncOp->m_pTransport->lpVtbl->PatchContact(pSyncOp->m_pTransport, pSyncOp->m_pContactInfo->pszHotmailHref, pSyncOp->m_pServerContact, 0);
    }
    else if (OP_STATE_DONE == pSyncOp->m_bState)
    {
        if (!WABSync_NextOp(pHotSync, TRUE))
            WABSync_NextState(pHotSync);
    }

    return hr;
}

void Syncop_SetServerContactInfo(LPHOTSYNCOP pSyncOp, LPWABCONTACTINFO pWabContactInfo, LPHTTPCONTACTINFO pContactInfo)
{
    if (!pSyncOp)
        return;

    if (!pSyncOp->m_pServerContact)
        pSyncOp->m_pServerContact = LocalAlloc(LMEM_ZEROINIT, sizeof(HTTPCONTACTINFO));

    if (!pSyncOp->m_pServerContact)
        return;

    *pSyncOp->m_pServerContact = *pContactInfo;
    ContactInfo_Clear(pContactInfo);
    pSyncOp->m_pServerContact->pszId = _StrDup(pWabContactInfo->pszHotmailId);
    pSyncOp->m_pServerContact->pszModified = _StrDup(pWabContactInfo->pszModHotmail);
}

void    WABContact_Delete(LPWABCONTACTINFO pContact)
{
    Assert(pContact);

    if (pContact->pszHotmailHref)
        CoTaskMemFree(pContact->pszHotmailHref);
    
    if (pContact->pszModHotmail)
        CoTaskMemFree(pContact->pszModHotmail);

    if (pContact->pszHotmailId)
        CoTaskMemFree(pContact->pszHotmailId);

    if (pContact->pszaContactIds)
        FreeMultiValueString(pContact->pszaContactIds);

    if (pContact->pszaServerIds)
        FreeMultiValueString(pContact->pszaServerIds);

    if (pContact->pszaModtimes)
        FreeMultiValueString(pContact->pszaModtimes);

    if (pContact->pszaEmails)
        FreeMultiValueString(pContact->pszaEmails);

    if (pContact->lpEID)
        LocalFree(pContact->lpEID);

    LocalFree(pContact);
}

void ContactInfo_Clear(LPHTTPCONTACTINFO pContactInfo)
{
    ZeroMemory(pContactInfo, sizeof(HTTPCONTACTINFO));
}

void ContactInfo_Free(LPHTTPCONTACTINFO pContactInfo)
{
    DWORD  i, dwSize = ARRAYSIZE(g_ContactInfoStructure);
    if (!pContactInfo)
        return;

    for (i = 0; i < dwSize; i++)
    {
        if (CIS_STRING == CIS_GETTYPE(i))
            SafeCoMemFree(CIS_GETSTRING(pContactInfo, i));
    }
}

ULONG rgPropMap[] = {
    PR_ENTRYID,     //href
    PR_ENTRYID,     //id
    PR_ENTRYID,     //type
    PR_ENTRYID,     //modified
    PR_DISPLAY_NAME,
    PR_GIVEN_NAME,
    PR_SURNAME,
    PR_NICKNAME,
    PR_EMAIL_ADDRESS,
    PR_HOME_ADDRESS_STREET,
    PR_HOME_ADDRESS_CITY,
    PR_HOME_ADDRESS_STATE_OR_PROVINCE,
    PR_HOME_ADDRESS_POSTAL_CODE,
    PR_HOME_ADDRESS_COUNTRY,
    PR_COMPANY_NAME,
    PR_BUSINESS_ADDRESS_STREET,
    PR_BUSINESS_ADDRESS_CITY,
    PR_BUSINESS_ADDRESS_STATE_OR_PROVINCE,
    PR_BUSINESS_ADDRESS_POSTAL_CODE,
    PR_BUSINESS_ADDRESS_COUNTRY,
    PR_HOME_TELEPHONE_NUMBER,
    PR_HOME_FAX_NUMBER,
    PR_BUSINESS_TELEPHONE_NUMBER,
    PR_BUSINESS_FAX_NUMBER,
    PR_MOBILE_TELEPHONE_NUMBER,
    PR_OTHER_TELEPHONE_NUMBER,
    PR_BIRTHDAY,
    PR_PAGER_TELEPHONE_NUMBER
};

DWORD   ContactInfo_CountProperties(LPHTTPCONTACTINFO pContactInfo)
{
    DWORD cProps = 0;
    DWORD dwIndex, dwSize = ARRAYSIZE(g_ContactInfoStructure);

    // skip href
    for (dwIndex = 1; dwIndex < dwSize; dwIndex ++)
    {
#ifdef HM_GROUP_SYNCING
        // [PaulHi] Skip email name here if we are group syncing
        if ( (pContactInfo->tyContact == HTTPMAIL_CT_GROUP) && (dwIndex == idcisEmail) )
            continue;
#endif
        if (CIS_STRING == CIS_GETTYPE(dwIndex) && CIS_GETSTRING(pContactInfo, dwIndex) && *(CIS_GETSTRING(pContactInfo, dwIndex)))    
            cProps++;
    }

#ifdef HM_GROUP_SYNCING
    // [PaulHi] Group syncing
    if (pContactInfo->tyContact == HTTPMAIL_CT_GROUP)
    {
        LPTSTR   lptszEmailName = ConvertAtoW( CIS_GETSTRING(pContactInfo, idcisEmail) );
        if (lptszEmailName)
        {
            ULONG   cContacts = 0;
            ULONG   cOneOffs = 0;
            if ( SUCCEEDED(hrParseHMGroupEmail(lptszEmailName, NULL, &cContacts, NULL, &cOneOffs)) )
            {
                // One property for each set of mail user contacts or one-offs
                cProps += (cContacts != 0) ? 1 : 0;
                cProps += (cOneOffs != 0) ? 1 : 0;
            }

            LocalFreeAndNull(&lptszEmailName);
        }

        // A valid WAB DL must have a display name.  HM groups only have nicknames so we
        // need to reserve a PR_DISPLAY_NAME property.
        // [PaulHi]  Note, only do this if there is a valid Nickname field.  The ContactInfo_SaveToWAB()
        // function, which calls this function, is always in response to a server add or change.
        // The pContactInfo fields reflect whatever was changed on the server.  If there is a 
        // valid Nickname field then be sure we translate this to the WAB property DisplayName field.
        // The WAB group display name corresponds to a HM group nickname.
        if (pContactInfo->pszNickname)
            ++cProps;       // This gets translated to a DisplayName in ContactInfo_TranslateProps()
    }
    else
    {
#endif
        if (pContactInfo->pszEmail && *(pContactInfo->pszEmail))
            cProps++;       //need to make room for the PR_ADDRTYPE too
#ifdef HM_GROUP_SYNCING
    }
#endif
    return cProps;
}



HRESULT ContactInfo_SetProp(ULONG ulPropTag, LPTSTR pszValue, LPSPropValue lpPropArray, DWORD *pdwLoc)
{
    ULONG   ulLen;
    SCODE   sc;
    UNALIGNED LPTSTR  *lppszValues;
    HRESULT hr;
    LPSTR  lp = NULL;

    Assert(pszValue);

    switch (PROP_TYPE(ulPropTag))
    {
        // BUGBUG currently only works for PT_TSTRING or PT_MV_TSTRING properties
        case PT_TSTRING:
            // Get the value for this attribute
            if (ulLen = lstrlen(pszValue))
            {                
                lpPropArray[*pdwLoc].ulPropTag = ulPropTag;
                lpPropArray[*pdwLoc].dwAlignPad = 0;

                //  Allocate more space for the data
                ulLen = (ulLen + 1) * sizeof(TCHAR);
                sc = MAPIAllocateMore(ulLen, lpPropArray, (LPVOID *)&(lpPropArray[*pdwLoc].Value.LPSZ));
                if (sc)
                    goto error;
                StrCpyN(lpPropArray[*pdwLoc].Value.LPSZ, pszValue, ulLen);

                // If this is PR_EMAIL_ADDRESS, create a PR_ADDRTYPE entry as well
                if (PR_EMAIL_ADDRESS == ulPropTag)
                {
                    // Remember where the email value was, so we can add it to
                    // PR_CONTACT_EMAIL_ADDRESSES later
//                    ulPrimaryEmailIndex = *pdwLoc;
                    (*pdwLoc)++;

                    lpPropArray[*pdwLoc].ulPropTag = PR_ADDRTYPE;
                    lpPropArray[*pdwLoc].dwAlignPad = 0;
                    lpPropArray[*pdwLoc].Value.LPSZ = (LPTSTR)szSMTP;
                }
                (*pdwLoc)++;
            }
            break;

        case PT_MV_TSTRING:
            lpPropArray[*pdwLoc].ulPropTag = ulPropTag;
            lpPropArray[*pdwLoc].dwAlignPad = 0;
            lpPropArray[*pdwLoc].Value.MVSZ.cValues = 1;
            sc = MAPIAllocateMore((2)*sizeof(LPTSTR), lpPropArray, 
                (LPVOID *)&(lpPropArray[*pdwLoc].Value.MVSZ.LPPSZ));
            if (sc)
                goto error;
            lppszValues = lpPropArray[*pdwLoc].Value.MVSZ.LPPSZ;

            ulLen = sizeof(TCHAR)*(lstrlen(pszValue) + 1);
            //  Allocate more space for the email address and copy it.
            sc = MAPIAllocateMore(ulLen, lpPropArray, (LPVOID *)&(lppszValues[0]));
            if (sc)
                goto error;
            StrCpyN(lppszValues[0], pszValue, ulLen);
            lppszValues[1] = NULL;

            (*pdwLoc)++;
        
            break;
        case PT_SYSTIME:
            lp = ConvertWtoA(pszValue);
            hr = iso8601ToFileTime(lp, (FILETIME *) (&lpPropArray[*pdwLoc].Value.ft), TRUE, TRUE);
            if (SUCCEEDED(hr))
            {
                lpPropArray[*pdwLoc].ulPropTag = ulPropTag;
                lpPropArray[*pdwLoc].dwAlignPad = 0;
                (*pdwLoc)++;
            }
            LocalFreeAndNull(&lp);
            break;

        default:
            return E_INVALIDARG;
    }
    
    return S_OK;
error:

    return ResultFromScode(sc);
}

HRESULT ContactInfo_SetMVSZProp(ULONG ulPropTag, SLPSTRArray *pszaValue, LPSPropValue lpPropArray, DWORD *pdwLoc)
{
    ULONG   ulLen;
    ULONG   cbValue;
    SCODE   sc;
    UNALIGNED LPTSTR  *lppszValues;
    HRESULT hr;
    DWORD   i;
    LPTSTR  lpVal = NULL;

    Assert(pszaValue);

    switch (PROP_TYPE(ulPropTag))
    {
        case PT_MV_TSTRING:
            lpPropArray[*pdwLoc].ulPropTag = ulPropTag;
            lpPropArray[*pdwLoc].dwAlignPad = 0;
            lpPropArray[*pdwLoc].Value.MVSZ.cValues = pszaValue->cValues;
            sc = MAPIAllocateMore((pszaValue->cValues+1)*sizeof(LPTSTR), lpPropArray, 
                (LPVOID *)&(lpPropArray[*pdwLoc].Value.MVSZ.LPPSZ));
            if (sc)
                goto error;
            lppszValues = lpPropArray[*pdwLoc].Value.MVSZ.LPPSZ;

            for (i = 0; i < pszaValue->cValues; i ++)
            {
                ScAnsiToWCMore((LPALLOCATEMORE )(&MAPIAllocateMore), (LPVOID) lpPropArray, (LPSTR) (pszaValue->lppszA[i]), (LPWSTR *) (&(lppszValues[i])));
            }
            lppszValues[pszaValue->cValues] = NULL;

            (*pdwLoc)++;
        
            break;

        default:
            return E_INVALIDARG;
    }
    
    return S_OK;
error:

    return ResultFromScode(sc);
}


HRESULT ContactInfo_TranslateProps(LPWABSYNC pWabSync, LPHTTPCONTACTINFO pContactInfo, LPWABCONTACTINFO pWabContactInfo, LPSPropValue lpaProps)
{
    HRESULT hr = S_OK;
    DWORD   dwIndex, dwSize = ARRAYSIZE(rgPropMap);
    DWORD   dwPropIndex = 0, dwLoc = 0;
    TCHAR   szFullProfile[MAX_PATH];
    DWORD   dwStartIndex = 1;

    // [PaulHi]  Assemble the contact ID string
    hr = hrMakeContactId(
        szFullProfile,
        MAX_PATH,
        ((LPIAB)(pWabSync->m_pAB))->szProfileID,
        pWabSync->m_pszAccountId,
        pWabSync->m_szLoginName);
    if (FAILED(hr))
        return hr;
    
    // fix up the other prop tag array structure to take into account the variable values
    rgPropMap[1] = PR_WAB_HOTMAIL_SERVERIDS;
    rgPropMap[3] = PR_WAB_HOTMAIL_MODTIMES;


    if (pWabContactInfo && pWabContactInfo->pszaContactIds)
    {
        DWORD   i;
        BOOL    fFound = FALSE;

        // [PaulHi] 1/21/99  We are assuming that pszaModtimes and pszaServerIds 
        // pointers are valid too.  Check this.
        Assert(pWabContactInfo->pszaModtimes);
        Assert(pWabContactInfo->pszaServerIds);
        
        for (i = 0; i < pWabContactInfo->pszaContactIds->cValues; i++)
        {
            LPTSTR lpVal = 
                ConvertAtoW(pWabContactInfo->pszaContactIds->lppszA[i]);
            if (lstrcmp(szFullProfile, lpVal) == 0)
            {
                LocalFreeAndNull(&lpVal);
                fFound = TRUE;
                break;
            }
            LocalFreeAndNull(&lpVal);
        }

        if (fFound)
        {
            SCODE sc;
            ULONG cchSize = lstrlenA(CIS_GETSTRING(pContactInfo, idcisModified))+1;

            // Allocate new memory for the string, sure the old memory we still be allocated but
            // it will still be freed via the magic of MAPIAllocate* once the whole array gets freed.
            sc = MAPIAllocateMore(sizeof(CHAR) * cchSize, pWabContactInfo->pszaModtimes, 
                (LPVOID *)&pWabContactInfo->pszaModtimes->lppszA[i]);
            if (!sc)
            {
                // update the mod time
                StrCpyNA(pWabContactInfo->pszaModtimes->lppszA[i], CIS_GETSTRING(pContactInfo, idcisModified), cchSize);
            }
        }
        else
        {
            if (CIS_GETSTRING(pContactInfo, idcisId) && CIS_GETSTRING(pContactInfo, idcisModified))
            {
                // add this one to the list at the end
                LPSTR lpValA = 
                    ConvertWtoA(szFullProfile);
                AppendToMultiValueString(pWabContactInfo->pszaContactIds, lpValA);
                LocalFreeAndNull(&lpValA);
                AppendToMultiValueString(pWabContactInfo->pszaServerIds, CIS_GETSTRING(pContactInfo, idcisId));
                AppendToMultiValueString(pWabContactInfo->pszaModtimes, CIS_GETSTRING(pContactInfo, idcisModified));
            }
        }
        
        ContactInfo_SetMVSZProp(PR_WAB_HOTMAIL_CONTACTIDS, pWabContactInfo->pszaContactIds, lpaProps, &dwLoc);
        ContactInfo_SetMVSZProp(PR_WAB_HOTMAIL_SERVERIDS, pWabContactInfo->pszaServerIds, lpaProps, &dwLoc);
        ContactInfo_SetMVSZProp(PR_WAB_HOTMAIL_MODTIMES, pWabContactInfo->pszaModtimes, lpaProps, &dwLoc);

        dwStartIndex = 4;
    }
    else
        hr = ContactInfo_SetProp(PR_WAB_HOTMAIL_CONTACTIDS, szFullProfile, lpaProps, &dwLoc);

#ifdef HM_GROUP_SYNCING
    if (!pWabSync->m_fSyncGroups)   
    {
        // [PaulHi] Normal contact email addresses
#endif
        // Set the other e-mail address fields
        if (pWabContactInfo && pWabContactInfo->pszaEmails && CIS_GETSTRING(pContactInfo, idcisEmail))
        {
            DWORD dw, cStrs;
            BOOL  fFound = FALSE;

            cStrs = pWabContactInfo->pszaEmails->cValues;

            for (dw = 0; dw < cStrs; dw ++)
            {
                if (lstrcmpiA(pWabContactInfo->pszaEmails->lppszA[dw], CIS_GETSTRING(pContactInfo, idcisEmail)) == 0)
                {
                    pWabContactInfo->dwEmailIndex = dw;
                    fFound = TRUE;
                    break;
                }
            }

            if (!fFound)
            {
                SetMultiValueStringValue(pWabContactInfo->pszaEmails, CIS_GETSTRING(pContactInfo, idcisEmail), pWabContactInfo->dwEmailIndex);
            }

            ContactInfo_SetMVSZProp(PR_CONTACT_EMAIL_ADDRESSES, pWabContactInfo->pszaEmails, lpaProps, &dwLoc);
            //set the index
            lpaProps[dwLoc].ulPropTag = PR_CONTACT_DEFAULT_ADDRESS_INDEX;
            lpaProps[dwLoc].dwAlignPad = 0;
            lpaProps[dwLoc].Value.ul = pWabContactInfo->dwEmailIndex;
            dwLoc ++;
        }
#ifdef HM_GROUP_SYNCING
    }
    else
    {
        // [PaulHi] Implement group syncing.  If we are synchronizing groups then the HM contact
        // email string is a series of contact nicknames and one-off email names.  Parse this
        // string and add each group contact.
        LPTSTR lptszEmailName = ConvertAtoW( CIS_GETSTRING(pContactInfo, idcisEmail) );
        if (lptszEmailName)
        {
            LPTSTR * atszContacts = NULL;
            LPTSTR * atszOneOffs = NULL;
            ULONG    cContacts = 0;
            ULONG    cOneOffs = 0;
            ULONG    ul;

            // The atszContacts and atszOneOffs arrays are just pointers into the lptszEmailName
            // buffer.  So these arrays are only valid as long as lptszEmailName is valid.
            hr = hrParseHMGroupEmail(lptszEmailName, &atszContacts, &cContacts, &atszOneOffs, &cOneOffs);
            if (FAILED(hr))
            {
                LocalFreeAndNull(&lptszEmailName);
                goto out;
            }

            // Add multi-value property tags as appropriate
            if (cContacts)
                hrCreateGroupMVBin(pWabSync, PR_WAB_DL_ENTRIES, atszContacts, cContacts, lpaProps, &dwLoc);
            if (cOneOffs)
                hrCreateGroupMVBin(pWabSync, PR_WAB_DL_ONEOFFS, atszOneOffs, cOneOffs, lpaProps, &dwLoc);

            // cleanup
            LocalFreeAndNull((LPVOID *)&atszContacts);
            LocalFreeAndNull((LPVOID *)&atszOneOffs);
            LocalFreeAndNull(&lptszEmailName);
        }
    }
#endif

    // skip the first ones since we just did them
    for (dwIndex = dwStartIndex; dwIndex < dwSize; dwIndex ++)
    {
        if (CIS_STRING == CIS_GETTYPE(dwIndex) && CIS_GETSTRING(pContactInfo, dwIndex))    
        {
            LPTSTR  lptsz = ConvertAtoW(CIS_GETSTRING(pContactInfo, dwIndex));

#ifdef HM_GROUP_SYNCING
            // [PaulHi] Special group syncing logic
            if (pContactInfo->tyContact == HTTPMAIL_CT_GROUP)
            {
                // Don't add email name for groups
                if (dwIndex == idcisEmail)
                    continue;

                // Copy the nickname to the display name property.  All WAB DL items
                // MUST have a PR_DISPLAY_NAME property.  Since HM groups only contain
                // a nickname use the nickname as the display name.
                if (dwIndex == idcisNickName)
                {
                    hr = ContactInfo_SetProp(PR_DISPLAY_NAME, lptsz, lpaProps, &dwLoc);
                    if (FAILED(hr))
                    {
                        LocalFreeAndNull(&lptsz);
                        break;
                    }
                }
            }
#endif

            hr = ContactInfo_SetProp(rgPropMap[dwIndex], lptsz, lpaProps, &dwLoc);
            LocalFreeAndNull(&lptsz);
            if (FAILED(hr))
                break;
        }
    }

#ifdef HM_GROUP_SYNCING
out:
#endif

    return hr;
}

static LONG   _FindPropTag(ULONG ulPropTag)
{
    LONG lIndex, lSize = ARRAYSIZE(rgPropMap);

    // skip href
    for (lIndex = 1; lIndex < lSize; lIndex ++)
    {
        if (rgPropMap[lIndex] == ulPropTag)
            return lIndex;
    }
    return -1;
}


HRESULT ContactInfo_DetermineDeleteProps(LPHTTPCONTACTINFO pContactInfo, LPSPropTagArray prgRemoveProps)
{
    LPSTR  *pProps = (LPSTR *)pContactInfo;
    LONG    lSize = ARRAYSIZE(rgPropMap);
    LONG    dwIndex;

    prgRemoveProps->cValues = 0;
    
    for (dwIndex = CIS_FIRST_DATA_FIELD; dwIndex < lSize; dwIndex ++)
    {
        if (CIS_STRING == CIS_GETTYPE(dwIndex) && CIS_GETSTRING(pContactInfo, dwIndex) && *(CIS_GETSTRING(pContactInfo, dwIndex)) == 0)
        {
            prgRemoveProps->aulPropTag[prgRemoveProps->cValues++] = rgPropMap[dwIndex];
        }
    }
    return S_OK;
}


HRESULT ContactInfo_PopulateProps(
    LPWABSYNC           pWabSync,
    LPHTTPCONTACTINFO   pContactInfo,
    LPWABCONTACTINFO    pWabContactInfo,
    LPSPropValue        lpaProps,
    ULONG               ulcProps,
    ULONG               ulObjectType)
{
    HRESULT     hr = S_OK;
    LONG        lSize = ARRAYSIZE(rgPropMap);
    DWORD       dwPropIndex = 0, dwLoc = 0;
    ULONG       i, ulPropTag;
    LONG        lIndex;
    char        szBuffer[255];
    ULONG       ulIndServerIDs = -1, ulIndContactIDs = -1, ulIndModtimes = -1, ulIndEmails = -1;
    LPSTR       lpszA = NULL;

    // fix up the other prop tag array structure to take into account the variable values
    // @todo [PaulHi] Instead of using explict numbers create an enum for the array
    // indices so we can remain consistent.
    rgPropMap[1] = PR_WAB_HOTMAIL_SERVERIDS;
    rgPropMap[3] = PR_WAB_HOTMAIL_MODTIMES;

    ZeroMemory(pContactInfo, sizeof(HTTPCONTACTINFO));

#ifdef HM_GROUP_SYNCING
    // [PaulHi] Set the contact type flag (mail user or group contact)
    if (ulObjectType == MAPI_DISTLIST)
    {
        // group contact
        pContactInfo->tyContact = HTTPMAIL_CT_GROUP;
        pWabContactInfo->ulContactType = HTTPMAIL_CT_GROUP;
    }
    else
    {
        // mail user contact
        pContactInfo->tyContact = HTTPMAIL_CT_CONTACT;
        pWabContactInfo->ulContactType = HTTPMAIL_CT_CONTACT;
    }
#endif

    for (i = 0; i < ulcProps; i++)
    {
        ulPropTag = lpaProps[i].ulPropTag;
        
        lIndex = _FindPropTag(ulPropTag);

#ifdef HM_GROUP_SYNCING
        if (lIndex >= 0 && lIndex != 2) // The index==2 array position is tyContact, which we set above.
#else
        if (lIndex >= 0)
#endif
        {
            Assert(lIndex < lSize);
            
            SafeCoMemFree(CIS_GETSTRING(pContactInfo, lIndex));

            switch (PROP_TYPE(ulPropTag))
            {
                case PT_TSTRING:
                    Assert(CIS_STRING == CIS_GETTYPE(lIndex));
                    if (CIS_GETSTRING(pContactInfo, lIndex))
                        SafeCoMemFree(CIS_GETSTRING(pContactInfo, lIndex));

                    lpszA = 
                        ConvertWtoA(lpaProps[i].Value.LPSZ);
                    CIS_GETSTRING(pContactInfo, lIndex) = _StrDup(lpszA);
                    LocalFreeAndNull(&lpszA);
                    if (!CIS_GETSTRING(pContactInfo, lIndex))
                    {
                        hr = E_OUTOFMEMORY;
                        goto exit;
                    }
                    break;

                case PT_SYSTIME:
                    Assert(CIS_STRING == CIS_GETTYPE(lIndex));
                    if (SUCCEEDED(FileTimeToiso8601((FILETIME *) (&lpaProps[i].Value.ft), szBuffer)))
                    {
                        CIS_GETSTRING(pContactInfo, lIndex) = _StrDup(szBuffer);
                        if (!CIS_GETSTRING(pContactInfo, lIndex))
                        {
                            hr = E_OUTOFMEMORY;
                            goto exit;
                        }
                    }
                    else
                    {
                        hr = E_INVALIDARG;
                        goto exit;
                    }
                    if (PR_BIRTHDAY == ulPropTag && CIS_GETSTRING(pContactInfo, lIndex))
                    {
                        // fix it up to be a hotmail formatted date
                        _FixHotmailDate(CIS_GETSTRING(pContactInfo, lIndex));
                    }
                    break;

                case PT_MV_TSTRING:
                    if (ulPropTag == PR_WAB_HOTMAIL_SERVERIDS)
                        ulIndServerIDs = i;
                    else if (ulPropTag == PR_WAB_HOTMAIL_MODTIMES)
                        ulIndModtimes = i;
                    break;
            }
        }
        else
        {
            if (ulPropTag == PR_WAB_HOTMAIL_CONTACTIDS)
                ulIndContactIDs = i;
            else if (ulPropTag == PR_CONTACT_EMAIL_ADDRESSES)
                ulIndEmails = i;
            else if (ulPropTag == PR_CONTACT_DEFAULT_ADDRESS_INDEX)
                pWabContactInfo->dwEmailIndex = lpaProps[i].Value.ul;
#ifdef HM_GROUP_SYNCING
            else if ( (ulObjectType == MAPI_DISTLIST) && 
                      (ulPropTag == PR_WAB_DL_ENTRIES) || (ulPropTag == PR_WAB_DL_ONEOFFS) )
            {
                LPSTR   lpszNewEmailName = CIS_GETSTRING(pContactInfo, idcisEmail);
                hr = hrAppendGroupContact(pWabSync,
                                          ulPropTag,
                                          &lpaProps[i],
                                          &lpszNewEmailName);
                CIS_GETSTRING(pContactInfo, idcisEmail) = lpszNewEmailName;

                if (FAILED(hr))
                    goto exit;
            }
#endif
        }
    }

#ifdef HM_GROUP_SYNCING
    // [PaulHi] Group syncing.  HM group contact information consists only of an email and nickname.  
    // The WAB group display name becomes the HM group nickname.
    if (ulObjectType == MAPI_DISTLIST)
    {
        LPSTR   lpszDisplayName = CIS_GETSTRING(pContactInfo, idcisDisplayName);
        LPSTR   lpszNickName = CIS_GETSTRING(pContactInfo, idcisNickName);

        if (lpszDisplayName)
        {
            if (lpszNickName)
                CoTaskMemFree(lpszNickName);

            CIS_GETSTRING(pContactInfo, idcisDisplayName) = NULL;

            // [PaulHi]
            // A HM group nickname cannot contain certain characters.  So we remove all
            // invalid characters in the name string.  This change will be reflected 
            // in the WAB group name too (yuck).
            hrStripInvalidChars(lpszDisplayName);
            CIS_GETSTRING(pContactInfo,idcisNickName) = lpszDisplayName;
        }
    }
    else
#endif
    {
        // Likewise email contact nicknames cannot contain certain characters or
        // the post to HM server will fail.
        LPSTR   lpszNickName = CIS_GETSTRING(pContactInfo, idcisNickName);

        if (lpszNickName)
            hrStripInvalidChars(lpszNickName);
    }


    if (ulIndEmails != -1)
    {
        if (pWabContactInfo->pszaEmails)
            FreeMultiValueString(pWabContactInfo->pszaEmails);
        hr = CopyMultiValueString((SWStringArray *) (&lpaProps[ulIndEmails].Value.MVSZ), &pWabContactInfo->pszaEmails);
    }    

    // If we have the indexes to all of the multivalues that we care about,
    // try to get the appropriate values for the current identity.
    if (ulIndContactIDs != -1 && ulIndModtimes != -1 && ulIndServerIDs != -1)
    {
        ULONG   ulMVIndex = -1;
        UNALIGNED LPTSTR  *lppszValues;
        TCHAR   szFullProfile[MAX_PATH];

        // [PaulHi]  Assemble the contact ID string
        hr = hrMakeContactId(
            szFullProfile,
            MAX_PATH,
            ((LPIAB)(pWabSync->m_pAB))->szProfileID,
            pWabSync->m_pszAccountId,
            pWabSync->m_szLoginName);
        if (FAILED(hr))
            goto exit;

        // sanity check, all three multi values must contain the same number
        // of values.  If not they are out of sync and not to be trusted.

        if (lpaProps[ulIndContactIDs].Value.MVSZ.cValues != lpaProps[ulIndModtimes].Value.MVSZ.cValues ||
            lpaProps[ulIndModtimes].Value.MVSZ.cValues != lpaProps[ulIndServerIDs].Value.MVSZ.cValues)
        {
            Assert(FALSE);
            goto exit;
        }

        if (pWabContactInfo->pszaContactIds)
            FreeMultiValueString(pWabContactInfo->pszaContactIds);
        hr = CopyMultiValueString((SWStringArray *) (&lpaProps[ulIndContactIDs].Value.MVSZ), &pWabContactInfo->pszaContactIds);
        
        if (pWabContactInfo->pszaServerIds)
            FreeMultiValueString(pWabContactInfo->pszaServerIds);
        hr = CopyMultiValueString((SWStringArray *) (&lpaProps[ulIndServerIDs].Value.MVSZ), &pWabContactInfo->pszaServerIds);

        if (pWabContactInfo->pszaModtimes)
            FreeMultiValueString(pWabContactInfo->pszaModtimes);
        hr = CopyMultiValueString((SWStringArray *) (&lpaProps[ulIndModtimes].Value.MVSZ), &pWabContactInfo->pszaModtimes);

        if (PROP_TYPE(lpaProps[ulIndContactIDs].ulPropTag) == PT_MV_TSTRING)
        {
            lppszValues = lpaProps[ulIndContactIDs].Value.MVSZ.LPPSZ;
            
            // find the index for this identity
            for (i = 0; i < lpaProps[ulIndContactIDs].Value.MVSZ.cValues; i++)
            {
                if (lstrcmp(szFullProfile, lppszValues[i]) == 0)
                {
                    ulMVIndex = i;
                    break;
                }
            }

            if (ulMVIndex != -1)
            {
                ULONG ulLen;
                LPSTR lpVal = NULL;
                lpVal = ConvertWtoA(lpaProps[ulIndServerIDs].Value.MVSZ.LPPSZ[ulMVIndex]);
                //Copy the values for this identity to the structure
                pContactInfo->pszId = _StrDup(lpVal);
                LocalFreeAndNull(&lpVal);
                if (!pContactInfo->pszId)
                {
                    hr = E_OUTOFMEMORY;
                    goto exit;
                }

                lpVal = ConvertWtoA(lpaProps[ulIndModtimes].Value.MVSZ.LPPSZ[ulMVIndex]);
                pContactInfo->pszModified = _StrDup(lpVal);
                LocalFreeAndNull(&lpVal);
                if (!pContactInfo->pszModified)
                {
                    hr = E_OUTOFMEMORY;
                    goto exit;
                }
            }
        }
    }

exit:
    if (FAILED(hr))
    {
        ContactInfo_Free(pContactInfo);
    }

    return hr;
}



HRESULT ContactInfo_SaveToWAB(LPWABSYNC pWabSync, 
                              LPHTTPCONTACTINFO pContactInfo, 
                              LPWABCONTACTINFO pWabContactInfo,
                              LPENTRYID   lpEntryID, 
                              ULONG cbEntryID,
                              BOOL  fDeleteProps)
{
    LPENTRYID       pEntryID = NULL;
    ULONG           cbLocEntryID = 0;
    HRESULT         hr;
    LPMAILUSER      lpMailUser = NULL;   
    LPSPropValue    lpaProps = NULL;
    ULONG           ulcProps = 0;
    ULONG           ulObjectType;
    SCODE           sc;
    SBinary         sBinary;
    ULONG           uli;

    Assert(pWabSync);
    Assert(pContactInfo);
    Assert(pWabSync->m_pAB);

    if (HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->GetPAB(pWabSync->m_pAB, &sBinary.cb, (LPENTRYID*)&sBinary.lpb)))
    {
        DebugPrintError(( TEXT("GetPAB Failed\n")));
        goto out;
    }
    
    Assert(sBinary.lpb);

    if (lpEntryID)
    {
        if (HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->OpenEntry(pWabSync->m_pAB, cbEntryID,     // size of EntryID to open
                                                lpEntryID,    // EntryID to open
                                                NULL,         // interface
                                                MAPI_MODIFY,  // flags
                                                &ulObjectType,
                                                (LPUNKNOWN *) &lpMailUser)))
        {
            DebugPrintError(( TEXT("OpenEntry Failed\n")));
            goto out;
        }
    }
    else
    {
#ifdef HM_GROUP_SYNCING
        ULONG   ulObjectType = (pWabSync->m_fSyncGroups) ? MAPI_DISTLIST : MAPI_MAILUSER;
#else
        ULONG   ulObjectType = MAPI_MAILUSER;
#endif

        fDeleteProps = FALSE;
        if (HR_FAILED(hr = HrCreateNewObject(pWabSync->m_pAB, 
                                             &sBinary, 
                                             ulObjectType,
                                             CREATE_CHECK_DUP_STRICT, 
                                             (LPMAPIPROP *) &lpMailUser)))
        {
            DebugPrintError(( TEXT("HRCreateNewObject Failed\n")));
            goto out;
        }
    }

    Assert(lpMailUser);
        
    //Add one for the contact's identity id
    ulcProps = ContactInfo_CountProperties(pContactInfo) + 1;

    // make room for PR_CONTACT_DEFAULT_ADDRESS_INDEX and PR_CONTACT_EMAIL_ADDRESSES 
    // if we have the data to put in them
    if (pWabContactInfo && pWabContactInfo->pszaEmails && CIS_GETSTRING(pContactInfo, idcisEmail))
        ulcProps += 2;

    // [PaulHi] @review  1/21/99
    // make room for PR_WAB_HOTMAIL_SERVERIDS and PR_WAB_HOTMAIL_MODTIMES
    // This part is ugly - only if these have not already been accounted for in pContactInfo
    if (pWabContactInfo && pWabContactInfo->pszaContactIds)
    {
        if (!pContactInfo->pszModified)
            ulcProps += 1;
        if (!pContactInfo->pszId)
            ulcProps += 1;
    }

    // Allocate a new buffer for the MAPI property array.
    sc = MAPIAllocateBuffer(ulcProps * sizeof(SPropValue),
                            (LPVOID *)&lpaProps);
    if (sc)
    {
        hr = ResultFromScode(sc);
        goto out;
    }

    // Initialize the Property array
    ZeroMemory(lpaProps, (ulcProps*sizeof(SPropValue)));
    for (uli=0; uli<ulcProps; uli++)
        lpaProps[uli].ulPropTag = PR_NULL;

    if(HR_FAILED(hr = ContactInfo_TranslateProps(pWabSync, pContactInfo, pWabContactInfo, lpaProps)))
    {
        DebugPrintError(( TEXT("ContactInfo_TranslateProps Failed\n")));
        goto out;
    }

    // Set the old guys props on the new guy - note that this overwrites any common props on 
    // potential duplicates when calling savechanges
    if(HR_FAILED(hr = lpMailUser->lpVtbl->SetProps(lpMailUser, ulcProps, lpaProps, NULL)))
    {
        DebugPrintError(( TEXT("SetProps Failed\n")));
        goto out;
    }

    if (fDeleteProps)
    {
        SizedSPropTagArray(ARRAYSIZE(rgPropMap), rgRemoveProps) = {0};

        ContactInfo_DetermineDeleteProps(pContactInfo, (LPSPropTagArray)&rgRemoveProps);

        if (rgRemoveProps.cValues > 0)
            hr = lpMailUser->lpVtbl->DeleteProps(lpMailUser, (LPSPropTagArray)&rgRemoveProps, NULL);
    }

    // SaveChanges
    if(HR_FAILED(hr = lpMailUser->lpVtbl->SaveChanges(lpMailUser, KEEP_OPEN_READONLY)))
    {
        DebugPrintError(( TEXT("SaveChanges Failed\n")));

        if (!lpEntryID && HR_FAILED(hr = ContactInfo_BlendNewContact(pWabSync, pContactInfo)))
            DebugPrintError(( TEXT("ContactInfo_BlendNewContact Failed\n")));
        goto out;
    }

out:
    if (sBinary.lpb)
    	MAPIFreeBuffer(sBinary.lpb);

    if (lpMailUser)
        UlRelease(lpMailUser);

    if (lpaProps)
        MAPIFreeBuffer(lpaProps);

    return hr;
}

HRESULT ContactInfo_BlendNewContact(LPWABSYNC pWabSync, 
                                    LPHTTPCONTACTINFO pContactInfo)
{
    LPSPropValue    lpaProps = NULL;
    SizedADRLIST(1, rAdrList) = {0};
    SCODE           sc;
    HRESULT         hr = S_OK;
    DWORD           cbValue;
    DWORD           cCount = 0;
    ULONG           j = 0;

    if (pContactInfo->pszDisplayName)
        cCount++;

    if (pContactInfo->pszEmail)
        cCount++;

    if (!cCount)
        return MAPI_E_INVALID_PARAMETER;

    // Allocate a new buffer for the MAPI property array.
    sc = MAPIAllocateBuffer(cCount * sizeof(SPropValue),
                            (LPVOID *)&lpaProps);
    if (sc)
    {
        hr = ResultFromScode(sc);
        goto out;
    }

    cCount = 0;
    if (pContactInfo->pszDisplayName)
    {
        lpaProps[cCount].ulPropTag = PR_DISPLAY_NAME;
        lpaProps[cCount].dwAlignPad = 0;
        if(sc = ScAnsiToWCMore((LPALLOCATEMORE )(&MAPIAllocateMore),(LPVOID) lpaProps, (LPSTR) pContactInfo->pszDisplayName, (LPWSTR *) (&(lpaProps[cCount].Value.LPSZ))))
            goto out;
        cCount++;
    }
  
    if (pContactInfo->pszEmail)
    {
        lpaProps[cCount].ulPropTag = PR_EMAIL_ADDRESS;
        lpaProps[cCount].dwAlignPad = 0;
        if(sc = ScAnsiToWCMore((LPALLOCATEMORE )(&MAPIAllocateMore),(LPVOID) lpaProps, (LPSTR) pContactInfo->pszEmail,(LPWSTR *) (&(lpaProps[cCount].Value.LPSZ))))
            goto out;
        cCount++;
    }

    rAdrList.cEntries = 1;
    rAdrList.aEntries[0].cValues = cCount;
    rAdrList.aEntries[0].rgPropVals = lpaProps;

    hr = pWabSync->m_pAB->lpVtbl->ResolveName(pWabSync->m_pAB, (ULONG_PTR)pWabSync->m_hWnd, 
                WAB_RESOLVE_LOCAL_ONLY | WAB_RESOLVE_USE_CURRENT_PROFILE,
                 TEXT(""), (LPADRLIST)(&rAdrList));

    lpaProps = NULL;        //it was freed in ResolveName (!)

    if (HR_FAILED(hr))
        goto out;

    for(j=0; j<rAdrList.aEntries[0].cValues; j++)
    {
        if(rAdrList.aEntries[0].rgPropVals[j].ulPropTag == PR_ENTRYID && 
            rAdrList.aEntries[0].rgPropVals[j].Value.bin.lpb)
        {
            hr = ContactInfo_SaveToWAB(pWabSync, 
                                    pContactInfo, 
                                    NULL,
                                    (LPENTRYID)rAdrList.aEntries[0].rgPropVals[j].Value.bin.lpb, 
                                    rAdrList.aEntries[0].rgPropVals[j].Value.bin.cb,
                                    FALSE);
            break;
        }
    }

    for (j = 0; j < rAdrList.cEntries; j++)
        MAPIFreeBuffer(rAdrList.aEntries[j].rgPropVals);

out:

    if (lpaProps)
        MAPIFreeBuffer(lpaProps);
    
    return hr;
}

void UpdateSynchronizeMenus(HMENU hMenu, LPIAB lpIAB)
{
    DWORD           cItems, dwIndex;
    MENUITEMINFO    mii;
    TCHAR           szLogoffString[255];
    TCHAR           szRes[255];

    if (!IsHTTPMailEnabled(lpIAB))
    {
        // loop through the other menu items looking for logoff
        cItems = GetMenuItemCount(hMenu);
    
        mii.cbSize = sizeof(MENUITEMINFO);
        mii.fMask = MIIM_ID;

        for (dwIndex = cItems; dwIndex > 0; --dwIndex)
        {
            GetMenuItemInfo(hMenu, dwIndex, TRUE, &mii);

            // if this is the logoff item, delete it and the separator 
            // line that follows
            if (mii.wID == IDM_TOOLS_SYNCHRONIZE_NOW)
            {
                DeleteMenu(hMenu, dwIndex - 1, MF_BYPOSITION);
                DeleteMenu(hMenu, IDM_TOOLS_SYNCHRONIZE_NOW, MF_BYCOMMAND);
                break;
            }
        }
    }
    else
    {
        // if there are no http mail accounts, disable the menu item
        if (CountHTTPMailAccounts(lpIAB) == 0)
            EnableMenuItem(hMenu, IDM_TOOLS_SYNCHRONIZE_NOW, MF_BYCOMMAND | MF_GRAYED);
    }
}

HRESULT ContactInfo_LoadFromWAB(LPWABSYNC pWabSync, 
                              LPHTTPCONTACTINFO pContactInfo,
                              LPWABCONTACTINFO  pWabContact,
                              LPENTRYID   lpEntryID, 
                              ULONG cbEntryID)
{
    LPENTRYID       pEntryID = NULL;
    ULONG           cbLocEntryID = 0;
    HRESULT         hr;
    LPMAILUSER      lpMailUser = NULL;   
    LPSPropValue    lpaProps = NULL;
    ULONG           ulcProps = 0;
    ULONG           ulObjectType;
    SCODE           sc;

    Assert(pWabSync);
    Assert(pContactInfo);
    Assert(lpEntryID);
    Assert(pWabSync->m_pAB);

    if(HR_FAILED(hr = pWabSync->m_pAB->lpVtbl->OpenEntry(pWabSync->m_pAB, cbEntryID, lpEntryID, NULL, 0, &ulObjectType, (LPUNKNOWN *) &lpMailUser)))
    {
        DebugPrintError(( TEXT("OpenEntry Failed\n")));
        goto out;
    }
    
    if(HR_FAILED(hr = lpMailUser->lpVtbl->GetProps(lpMailUser, (LPSPropTagArray)(&ptaEidCSync), MAPI_UNICODE, 
        &ulcProps, &lpaProps)))
    {
        DebugPrintError(( TEXT("GetProps Failed\n")));
        goto out;
    }

    if (HR_FAILED(hr = ContactInfo_PopulateProps(pWabSync, pContactInfo, pWabContact, lpaProps, ulcProps, ulObjectType)))
    {
        DebugPrintError(( TEXT("ContactInfo_PopulateProps Failed\n")));
        goto out;
    }

#ifdef HM_GROUP_SYNCING
    // [PaulHi] Group sync.  Don't break out a group display name
    if ( (pContactInfo->tyContact == HTTPMAIL_CT_CONTACT) && pContactInfo->pszDisplayName && 
         (!pContactInfo->pszGivenName || !pContactInfo->pszSurname) )
#else
    if ( pContactInfo->pszDisplayName && (!pContactInfo->pszGivenName || !pContactInfo->pszSurname) )
#endif
    {
        LPVOID  pBuffer;
        LPTSTR  pszFirstName = NULL, pszLastName = NULL;
        LPTSTR  lpName = 
                    ConvertAtoW(pContactInfo->pszDisplayName);
        if (ParseDisplayName(lpName, &pszFirstName, &pszLastName, NULL, &pBuffer))
        {
            LPSTR lp = NULL;
            if (pszFirstName && !pContactInfo->pszGivenName)
            {
                lp = ConvertWtoA(pszFirstName);
                pContactInfo->pszGivenName = _StrDup(lp);
                LocalFreeAndNull(&lp);
            }
            if (pszLastName && !pContactInfo->pszSurname)
            {
                lp = ConvertWtoA(pszLastName);
                pContactInfo->pszSurname = _StrDup(lp);
                LocalFreeAndNull(&lp);
            }

            LocalFree(pBuffer);
        }
        LocalFreeAndNull(&lpName);
    }
            
out:
    if (lpMailUser)
        UlRelease(lpMailUser);

    if (lpaProps)
        MAPIFreeBuffer(lpaProps);

    return hr;
}


static BOOL _IsLegitNicknameChar(TCHAR ch)
{
    if (ch >= 'A' && ch <= 'Z')
        return TRUE;
    if (ch >= 'a' && ch <= 'z')
        return TRUE;
    if (ch >= '0' && ch <= '9')
        return TRUE;
    if (ch == '-' || ch == '_')
        return TRUE;
    return FALSE;
}

HRESULT ContactInfo_GenerateNickname(LPHTTPCONTACTINFO pContactInfo)
{
    HRESULT hr = S_OK;
    LPSTR   pszStr;

    if (NULL == pContactInfo->pszNickname)
    {
        if (pContactInfo->pszEmail)
        {
            pContactInfo->pszNickname = _StrDup(pContactInfo->pszEmail);
        }
        else if (pContactInfo->pszDisplayName)
        {
            pContactInfo->pszNickname = _StrDup(pContactInfo->pszDisplayName);
        }
        else 
        {
            char szNickname[25], szFmt[25];
            
            LoadStringA(hinstMapiX, idsNicknameFmt, szFmt, sizeof(szFmt));
            if (*szFmt == 0)
                StrCpyNA(szFmt,  "Nickname%d", ARRAYSIZE(szFmt));

            wnsprintfA(szNickname, ARRAYSIZE(szNickname), szFmt, ((DWORD)GetTickCount() & 0x0000FFFF));
            pContactInfo->pszNickname = _StrDup(szNickname);
        }

        if (!pContactInfo->pszNickname)
            return E_OUTOFMEMORY;

        pszStr = pContactInfo->pszNickname;
        while (*pszStr)
        {
            // e-mail address should be unique enough...(?)
            if (*pszStr == '@')
            {
                *pszStr = 0;
                break;
            }

            if (!_IsLegitNicknameChar(*pszStr))
                *pszStr = '_';
            
            pszStr++;
        }
    }
    else
    {
        char szNickname[25], szFmt[25];
        
        SafeCoMemFree(pContactInfo->pszNickname);
        LoadStringA(hinstMapiX, idsNicknameFmt, szFmt, sizeof(szFmt));
        if (*szFmt == 0)
            StrCpyNA(szFmt,  "Nickname%d", ARRAYSIZE(szFmt));

        wnsprintfA(szNickname, ARRAYSIZE(szNickname), szFmt, ((DWORD)GetTickCount() & 0x0000FFFF));
        pContactInfo->pszNickname = _StrDup(szNickname);
    }
    
    return hr;
}


BOOL ContactInfo_Match(LPHTTPCONTACTINFO pciServer, LPHTTPCONTACTINFO pciClient)
{
    LONG    i, lSize = ARRAYSIZE(g_ContactInfoStructure);
    BOOL    fResult = TRUE;

    if (!pciServer)
        return FALSE;

    if (!pciClient) 
        return FALSE;

    for (i = CIS_FIRST_DATA_FIELD; i < lSize; i ++)
    {
        if (CIS_GETSTRING(pciServer, i) && CIS_GETSTRING(pciClient, i))
        {
            if (lstrcmpA(CIS_GETSTRING(pciServer, i), CIS_GETSTRING(pciClient, i)))
                return FALSE;
        }
        else if (CIS_GETSTRING(pciServer, i) || CIS_GETSTRING(pciClient, i))
        {
            if (idcisNickName == i && CIS_GETSTRING(pciServer, i))
                fResult = FALSE;
            else
                return FALSE;
        }
    }

    // if the only reason they don't match is the lack of local nickname and 
    // there is a server one, just copy the nickname locally
    if (!fResult)
    {
        CIS_GETSTRING(pciClient, idcisNickName) = _StrDup(CIS_GETSTRING(pciServer, idcisNickName));
        fResult = TRUE;
    }
    return fResult;
}

HRESULT ContactInfo_PreparePatch(LPHTTPCONTACTINFO pciFrom, LPHTTPCONTACTINFO pciTo)
{
    HRESULT hr = S_OK;
    LONG    i, lSize = ARRAYSIZE(g_ContactInfoStructure);
    
    for (i = CIS_FIRST_DATA_FIELD; i < lSize; i ++)
    {
        if (CIS_GETSTRING(pciFrom, i) && !CIS_GETSTRING(pciTo, i))
        {
            CIS_GETSTRING(pciTo, i) = _StrDup("");
            if (!CIS_GETSTRING(pciTo, i))
            {
                hr = E_OUTOFMEMORY;
                goto exit;
            }
        }

        if (CIS_GETSTRING(pciFrom, i) && CIS_GETSTRING(pciTo, i) && lstrcmpA(CIS_GETSTRING(pciFrom, i), CIS_GETSTRING(pciTo, i)) == 0)
            SafeCoMemFree(CIS_GETSTRING(pciTo, i));
    }
exit:
    return hr;
}

HRESULT ContactInfo_EmptyNullItems(LPHTTPCONTACTINFO pci)
{
    HRESULT hr = S_OK;
    LONG    i, lSize = ARRAYSIZE(g_ContactInfoStructure);

    for (i = CIS_FIRST_DATA_FIELD; i < lSize; i ++)
    {
        if (CIS_GETSTRING(pci, i) == NULL)
            CIS_GETSTRING(pci, i) = _StrDup("");
    }
    return S_OK;
}


HRESULT ContactInfo_BlendResults(LPHTTPCONTACTINFO pciServer, LPHTTPCONTACTINFO pciClient, CONFLICT_DECISION *prgDecisions)
{
    HRESULT hr = S_OK;
    LONG    i, lSize = ARRAYSIZE(g_ContactInfoStructure);
    
    for (i = CIS_FIRST_DATA_FIELD; i < lSize; i ++)
    {
        if (prgDecisions[i] == CONFLICT_SERVER)
        {
            SafeCoMemFree(CIS_GETSTRING(pciClient, i) );
            if (CIS_GETSTRING(pciServer, i))
            {
                CIS_GETSTRING(pciClient, i) = _StrDup(CIS_GETSTRING(pciServer, i));
                SafeCoMemFree(CIS_GETSTRING(pciServer, i));
            }
            else
                CIS_GETSTRING(pciClient, i) = _StrDup("");
        }
        else if (prgDecisions[i] == CONFLICT_CLIENT)
        {
            SafeCoMemFree(CIS_GETSTRING(pciServer, i));
            if (CIS_GETSTRING(pciClient, i))
                CIS_GETSTRING(pciServer, i) = _StrDup(CIS_GETSTRING(pciClient, i));
            else
                CIS_GETSTRING(pciServer, i) = _StrDup("");
        }
        else
        {
            SafeCoMemFree(CIS_GETSTRING(pciClient, i));
            SafeCoMemFree(CIS_GETSTRING(pciServer, i));
        }
    }

    return hr;
}





INT_PTR CALLBACK SyncProgressDlgProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    // Locals
    LPWABSYNC   pWabSync = (LPWABSYNC)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    
    switch (uMsg)
    {
        case WM_INITDIALOG:
            pWabSync = (LPWABSYNC)lParam;
            if (!pWabSync)
            {
                Assert (FALSE);
                return 1;
            }
#ifdef HM_GROUP_SYNCING
            // [PaulHi] Implement group syncing.  Identify what is currently
            // being synchronized, email contacts or groups.
            {
                TCHAR   rgtchCaption[MAX_PATH];
                UINT    uids = pWabSync->m_fSyncGroups ? idsSyncGroupsTitle : idsSyncContactsTitle;
                    
                rgtchCaption[0] = '\0';
                LoadString(hinstMapiX, uids, rgtchCaption, MAX_PATH-1);
                SetWindowText(hwnd, rgtchCaption);
            }
#endif
            CenterDialog (hwnd);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM) pWabSync);
            return 1;

        case WM_SYNC_NEXTSTATE:
            _WABSync_NextState(pWabSync);
            break;

        case WM_SYNC_NEXTOP:
            if (!_WABSync_NextOp(pWabSync, (0 != wParam)))
                WABSync_NextState(pWabSync);
            break;

        case WM_TIMER:
            break;

        case WM_COMMAND:
            switch(GET_WM_COMMAND_ID(wParam,lParam))
            {
                case IDCANCEL:
                    if (pWabSync)
                    {
                        EnableWindow ((HWND)lParam, FALSE);
                        WABSync_Abort(pWabSync, E_UserCancel);
                    }
                    return 1;
            }
            break;

        case WM_DESTROY:
//            KillTimer(hwnd, IDT_PROGRESS_DELAY);
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LPARAM) NULL);
            break;
    }

    // Done
    return 0;
}

HRESULT CopyMultiValueString(
                             SWStringArray *pInArray,
                             SLPSTRArray **ppOutArray)
{
    SLPSTRArray    *pResult = NULL;
    SCODE           sc;
    HRESULT         hr;
    DWORD           i, cb;

    *ppOutArray = NULL;

    sc = MAPIAllocateBuffer(sizeof(SLPSTRArray),
                            (LPVOID *)&pResult);
    if (sc)
        goto fail;

    pResult->cValues = pInArray->cValues;
    
    sc = MAPIAllocateMore(sizeof(LPSTR) * pResult->cValues, pResult,
      (LPVOID *)&(pResult->lppszA));
    if (sc)
        goto fail;

    for (i = 0; i < pResult->cValues; i ++)
    {
        if(sc = ScWCToAnsiMore((LPALLOCATEMORE ) (&MAPIAllocateMore),(LPVOID) pResult, (LPWSTR) pInArray->LPPSZ[i], (LPSTR *) (&(pResult->lppszA[i]))))
            goto fail;
    }
    
    *ppOutArray = pResult;
    return S_OK;

fail:
    hr = ResultFromScode(sc);
    FreeMultiValueString(pResult);

    return hr;
}

HRESULT AppendToMultiValueString(SLPSTRArray *pInArray, LPSTR szStr)
{   
    LPSTR          *ppStrA;
    SCODE           sc;
    HRESULT         hr;
    DWORD           i, cb;

    ppStrA = pInArray->lppszA;
    sc = MAPIAllocateMore(sizeof(LPSTR) * (pInArray->cValues + 1), pInArray,
      (LPVOID *)&(pInArray->lppszA));
    if (sc)
    {   
        pInArray->lppszA = ppStrA;
        goto fail;
    }

    CopyMemory(pInArray->lppszA, ppStrA, pInArray->cValues * sizeof(LPSTR));

    cb = lstrlenA(szStr);

    sc = MAPIAllocateMore(cb + 1, pInArray,
      (LPVOID *)&(pInArray->lppszA[pInArray->cValues]));
    if (sc)
        goto fail;

    StrCpyNA(pInArray->lppszA[pInArray->cValues], szStr, cb + 1);
    pInArray->cValues++;
    return S_OK;

fail:
    hr = ResultFromScode(sc);
    return hr;
}

HRESULT SetMultiValueStringValue(SLPSTRArray *pInArray, LPSTR szStr, DWORD dwIndex)
{   
    LPSTR          *ppStrA;
    SCODE           sc;
    HRESULT         hr;
    DWORD           i, cb;

    if (dwIndex >= pInArray->cValues)
        return E_FAIL;

    ppStrA = pInArray->lppszA;

    cb = lstrlenA(szStr);

    sc = MAPIAllocateMore(cb + 1, pInArray,
      (LPVOID *)&(pInArray->lppszA[dwIndex]));
    if (sc)
        goto fail;

    StrCpyNA(pInArray->lppszA[dwIndex], szStr, cb + 1);
    return S_OK;

fail:
    hr = ResultFromScode(sc);
    return hr;
}


HRESULT FreeMultiValueString(SLPSTRArray *pInArray)
{
    if (pInArray)
        MAPIFreeBuffer(pInArray);

    return S_OK;
}