1956 lines
60 KiB
C
1956 lines
60 KiB
C
/*
|
|
* Profiles.C - Stuff dealing with WAB Profile Handling
|
|
*
|
|
*/
|
|
|
|
|
|
#include <_apipch.h>
|
|
|
|
enum {
|
|
proDisplayName=0,
|
|
proObjectType,
|
|
proFolderEntries,
|
|
proFolderShared,
|
|
proFolderOwner, // upto this many props are common to all folders
|
|
proUserSubFolders,
|
|
proUserProfileID, // these are used by User Folders only
|
|
proUserFolderMax,
|
|
};
|
|
|
|
#define proFolderMax proUserSubFolders
|
|
|
|
|
|
/*
|
|
- helper function for quick saving of folder props
|
|
-
|
|
*/
|
|
HRESULT HrSaveFolderProps(LPADRBOOK lpAdrBook, BOOL bCreateUserFolder, ULONG ulcProps, LPSPropValue lpProps, LPMAPIPROP * lppObject)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPMAPIPROP lpObject = NULL;
|
|
ULONG ulFlags = CREATE_CHECK_DUP_STRICT;
|
|
BOOL bTryAgain = FALSE;
|
|
|
|
TryAgain:
|
|
|
|
// Create a new mailuser for this entry
|
|
if(HR_FAILED(hr = HrCreateNewObject(lpAdrBook, NULL, MAPI_MAILUSER, ulFlags, &lpObject)))
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = lpObject->lpVtbl->SetProps( lpObject, ulcProps, lpProps,NULL)))
|
|
goto out;
|
|
|
|
if(bCreateUserFolder)
|
|
{
|
|
// if we are creating a user folder, we can't rely on the currently loaded folder-
|
|
// container info so we will forcibly reset the parent folder item on the MailUser/Folder
|
|
// object we are savign
|
|
((LPMailUser)lpObject)->pmbinOlk = NULL;
|
|
}
|
|
|
|
// SaveChanges
|
|
if(HR_FAILED(hr = lpObject->lpVtbl->SaveChanges(lpObject, KEEP_OPEN_READWRITE)))
|
|
{
|
|
if(!bCreateUserFolder || hr != MAPI_E_COLLISION)
|
|
goto out;
|
|
|
|
// If something already exists with this same exact name, we want to merge with it
|
|
// without losing any info on it, since most likely, the original dupe is also a contact
|
|
if(!bTryAgain)
|
|
{
|
|
bTryAgain = TRUE;
|
|
ulFlags |= CREATE_REPLACE | CREATE_MERGE;
|
|
lpObject->lpVtbl->Release(lpObject);
|
|
lpObject = NULL;
|
|
lpProps[proFolderEntries].ulPropTag = PR_NULL; // don't overwrite the folder's contents
|
|
goto TryAgain;
|
|
}
|
|
}
|
|
|
|
if(lppObject)
|
|
{
|
|
*lppObject = lpObject;
|
|
lpObject = NULL;
|
|
}
|
|
out:
|
|
if(lpObject)
|
|
lpObject->lpVtbl->Release(lpObject);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
-
|
|
- FreeProfileContainerInfo(lpIAB)
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
void FreeProfileContainerInfo(LPIAB lpIAB)
|
|
{
|
|
if( lpIAB &&
|
|
lpIAB->cwabci &&
|
|
lpIAB->rgwabci)
|
|
{
|
|
//ULONG i = 0;
|
|
//for(i=0;i<lpIAB->cwabci;i++)
|
|
// LocalFreeAndNull(&(lpIAB->rgwabci[i].lpszName));
|
|
if( lpIAB->rgwabci[0].lpEntryID &&
|
|
!lpIAB->rgwabci[0].lpEntryID->cb &&
|
|
!lpIAB->rgwabci[0].lpEntryID->lpb &&
|
|
lpIAB->rgwabci[0].lpszName &&
|
|
lstrlen(lpIAB->rgwabci[0].lpszName))
|
|
{
|
|
LocalFree(lpIAB->rgwabci[0].lpEntryID);
|
|
LocalFree(lpIAB->rgwabci[0].lpszName);
|
|
}
|
|
|
|
LocalFreeAndNull(&(lpIAB->rgwabci));
|
|
lpIAB->cwabci = 0;
|
|
}
|
|
}
|
|
|
|
/*
|
|
-
|
|
- FindWABFolder - Searches the list of cached folders for a specific WAB folder
|
|
-
|
|
* The search is based on either the EID or the Name or the ProfileID
|
|
* If ProfileID is specified, we only search for user folders
|
|
*
|
|
*/
|
|
LPWABFOLDER FindWABFolder(LPIAB lpIAB, LPSBinary lpsb, LPTSTR lpName, LPTSTR lpProfileID)
|
|
{
|
|
LPWABFOLDER lpFolder = lpIAB->lpWABFolders;
|
|
BOOL bUserFolders = FALSE;
|
|
|
|
if(!lpFolder || lpProfileID)
|
|
{
|
|
lpFolder = lpIAB->lpWABUserFolders;
|
|
bUserFolders = TRUE;
|
|
}
|
|
while(lpFolder)
|
|
{
|
|
if(lpsb)
|
|
{
|
|
if( lpsb->cb == lpFolder->sbEID.cb &&
|
|
!memcmp(lpsb->lpb, lpFolder->sbEID.lpb, lpsb->cb) )
|
|
return lpFolder;
|
|
}
|
|
else
|
|
if(lpName)
|
|
{
|
|
if(!lstrcmpi(lpFolder->lpFolderName, lpName))
|
|
return lpFolder;
|
|
}
|
|
else
|
|
if(lpProfileID)
|
|
{
|
|
if( lpFolder->lpProfileID &&
|
|
!lstrcmpi(lpFolder->lpProfileID, lpProfileID))
|
|
return lpFolder;
|
|
}
|
|
lpFolder = lpFolder->lpNext;
|
|
if(!lpFolder && !bUserFolders)
|
|
{
|
|
lpFolder = lpIAB->lpWABUserFolders;
|
|
bUserFolders = TRUE;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
-
|
|
- HrGetWABProfileContainerInfo
|
|
*
|
|
* Looks up all the folders for the current user and tabulates
|
|
* them into a list of container names and entry ids for easy access
|
|
* similar to Outlook ...
|
|
* If there is no current user, we'll include all the folders for now
|
|
*
|
|
*/
|
|
HRESULT HrGetWABProfileContainerInfo(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
ULONG j = 0, i = 0, cVal = 0, cUserFolders = 0, cOtherFolders = 0;
|
|
LPWABFOLDER lpFolder = NULL;
|
|
LPWABFOLDERLIST lpFolderItem = NULL;
|
|
|
|
if(lpIAB->cwabci)
|
|
FreeProfileContainerInfo(lpIAB);
|
|
|
|
if(!bIsThereACurrentUser(lpIAB))
|
|
{
|
|
// No specific user specified .. need to add ALL folders
|
|
|
|
// Count all the folders
|
|
lpFolder = lpIAB->lpWABUserFolders;
|
|
while(lpFolder)
|
|
{
|
|
cUserFolders++;
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
cOtherFolders++;
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
|
|
cVal = cUserFolders + cOtherFolders + 1; // +1 for Virtual PAB
|
|
}
|
|
else
|
|
{
|
|
// For a user, we add all the user's folders except shared ones followed by
|
|
// all the shared folders...
|
|
lpFolderItem = lpIAB->lpWABCurrentUserFolder->lpFolderList;
|
|
while(lpFolderItem)
|
|
{
|
|
if(!lpFolderItem->lpFolder->bShared)
|
|
cVal++;
|
|
lpFolderItem = lpFolderItem->lpNext;
|
|
}
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
if(lpFolder->bShared)
|
|
cVal++;
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
cVal++; // add 1 for the user folder itself
|
|
cVal++; // add 1 for a virtual root item for this user TEXT("All Contacts")
|
|
}
|
|
|
|
if(cVal)
|
|
{
|
|
if(!(lpIAB->rgwabci = LocalAlloc(LMEM_ZEROINIT, sizeof(struct _OlkContInfo)*cVal)))
|
|
{
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto out;
|
|
}
|
|
cUserFolders = 0;
|
|
// Add the TEXT("All Contacts") item to the root - entryid is 0, NULL
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
ULONG cchSize;
|
|
int nID = (bDoesThisWABHaveAnyUsers(lpIAB)) ? idsSharedContacts : idsContacts;
|
|
LoadString(hinstMapiX, nID, sz, CharSizeOf(sz));
|
|
cchSize = lstrlen(sz)+1;
|
|
if(!(lpIAB->rgwabci[cUserFolders].lpszName = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize)))
|
|
{
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
goto out;
|
|
}
|
|
StrCpyN(lpIAB->rgwabci[cUserFolders].lpszName, sz, cchSize);
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = LocalAlloc(LMEM_ZEROINIT, sizeof(SBinary));
|
|
cUserFolders++;
|
|
}
|
|
if(!lpIAB->lpWABCurrentUserFolder)
|
|
{
|
|
lpFolder = lpIAB->lpWABUserFolders;
|
|
while(lpFolder)
|
|
{
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = &(lpFolder->sbEID);
|
|
lpIAB->rgwabci[cUserFolders].lpszName = lpFolder->lpFolderName;
|
|
cUserFolders++;
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = &(lpFolder->sbEID);
|
|
lpIAB->rgwabci[cUserFolders].lpszName = lpFolder->lpFolderName;
|
|
cUserFolders++;
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Add the first folder and then find the other folders one by one
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = &(lpIAB->lpWABCurrentUserFolder->sbEID);
|
|
lpIAB->rgwabci[cUserFolders].lpszName = lpIAB->lpWABCurrentUserFolder->lpFolderName;
|
|
cUserFolders++;
|
|
lpFolderItem = lpIAB->lpWABCurrentUserFolder->lpFolderList;
|
|
while(lpFolderItem)
|
|
{
|
|
if(!lpFolderItem->lpFolder->bShared)
|
|
{
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = &(lpFolderItem->lpFolder->sbEID);
|
|
lpIAB->rgwabci[cUserFolders].lpszName = lpFolderItem->lpFolder->lpFolderName;
|
|
cUserFolders++;
|
|
}
|
|
lpFolderItem = lpFolderItem->lpNext;
|
|
}
|
|
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
if(lpFolder->bShared)
|
|
{
|
|
lpIAB->rgwabci[cUserFolders].lpEntryID = &(lpFolder->sbEID);
|
|
lpIAB->rgwabci[cUserFolders].lpszName = lpFolder->lpFolderName;
|
|
cUserFolders++;
|
|
}
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
}
|
|
|
|
lpIAB->cwabci = cUserFolders;
|
|
}
|
|
hr = S_OK;
|
|
|
|
out:
|
|
if(HR_FAILED(hr) && lpIAB->rgwabci)
|
|
FreeProfileContainerInfo(lpIAB);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
- FreeWABFoldersList
|
|
-
|
|
-
|
|
* Clears up existing Profile Folders info from the IAB object
|
|
*/
|
|
void FreeFolderItem(LPWABFOLDER lpFolder)
|
|
{
|
|
LPWABFOLDERLIST lpFolderItem = NULL;
|
|
if(!lpFolder)
|
|
return;
|
|
LocalFreeAndNull(&lpFolder->lpFolderName);
|
|
LocalFreeAndNull(&lpFolder->lpProfileID);
|
|
LocalFreeAndNull((LPVOID *) (&lpFolder->sbEID.lpb));
|
|
LocalFreeAndNull(&lpFolder->lpFolderOwner);
|
|
lpFolderItem = lpFolder->lpFolderList;
|
|
while(lpFolderItem)
|
|
{
|
|
lpFolder->lpFolderList = lpFolderItem->lpNext;
|
|
LocalFree(lpFolderItem);
|
|
lpFolderItem = lpFolder->lpFolderList;
|
|
}
|
|
LocalFree(lpFolder);
|
|
}
|
|
void FreeWABFoldersList(LPIAB lpIAB)
|
|
{
|
|
LPWABFOLDER lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
lpIAB->lpWABFolders = lpFolder->lpNext;
|
|
FreeFolderItem(lpFolder);
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
}
|
|
lpFolder = lpIAB->lpWABUserFolders;
|
|
while(lpFolder)
|
|
{
|
|
lpIAB->lpWABFolders = lpFolder->lpNext;
|
|
FreeFolderItem(lpFolder);
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
}
|
|
lpIAB->lpWABUserFolders = NULL;
|
|
lpIAB->lpWABCurrentUserFolder = NULL;
|
|
lpIAB->lpWABFolders = NULL;
|
|
}
|
|
|
|
|
|
/*
|
|
- SetCurrentUserFolder - scans list and updates pointer
|
|
-
|
|
*
|
|
*/
|
|
void SetCurrentUserFolder(LPIAB lpIAB, LPTSTR lpszProfileID)
|
|
{
|
|
LPWABUSERFOLDER lpFolder = lpIAB->lpWABUserFolders;
|
|
|
|
while(lpFolder && lpszProfileID && lstrlen(lpszProfileID))
|
|
{
|
|
if(!lstrcmpi(lpFolder->lpProfileID, lpszProfileID))
|
|
{
|
|
lpIAB->lpWABCurrentUserFolder = lpFolder;
|
|
break;
|
|
}
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
}
|
|
|
|
/*
|
|
-
|
|
- CreateUserFolderName
|
|
*
|
|
*/
|
|
void CreateUserFolderName(LPTSTR lpProfile, LPTSTR * lppszName)
|
|
{
|
|
LPTSTR lpName = NULL;
|
|
TCHAR sz[MAX_PATH];
|
|
LoadString(hinstMapiX, idsUsersContacts, sz, CharSizeOf(sz));
|
|
FormatMessage(FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_ARGUMENT_ARRAY,
|
|
sz, 0, 0, (LPTSTR)&lpName, 0, (va_list *)&lpProfile);
|
|
*lppszName = lpName;
|
|
}
|
|
|
|
|
|
/*
|
|
- HrLinkOrphanFoldersToDefaultUser(lpIAB)
|
|
-
|
|
* If there are any folders that are associated with deleted users or that have
|
|
* no parent and are orphaned, we want to associate them with the default user
|
|
*
|
|
* This function is dependent on lpFolder->bOwned being correctly set in the
|
|
* HrLinkUserFoldersToWABFolders
|
|
*
|
|
*/
|
|
HRESULT HrLinkOrphanFoldersToDefaultUser(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWABUSERFOLDER lpDefUser = NULL;
|
|
LPWABFOLDER lpFolder = NULL;
|
|
TCHAR szDefProfile[MAX_PATH + 1];
|
|
|
|
// First detect the user folder corresponding to the Default User
|
|
*szDefProfile = '\0';
|
|
if( HR_FAILED(hr = HrGetDefaultIdentityInfo(lpIAB, DEFAULT_ID_PROFILEID, NULL, szDefProfile, ARRAYSIZE(szDefProfile), NULL, 0)))
|
|
{
|
|
if(hr == 0x80040154) // E_CLASS_NOT_REGISTERD means no IDentity Manager
|
|
hr = S_OK;
|
|
else
|
|
goto out;
|
|
}
|
|
|
|
if(lstrlen(szDefProfile))
|
|
{
|
|
lpDefUser = FindWABFolder(lpIAB, NULL, NULL, szDefProfile);
|
|
}
|
|
else
|
|
{
|
|
// can't find the default user so just fall back to picking someone at random
|
|
lpDefUser = lpIAB->lpWABUserFolders;
|
|
}
|
|
|
|
// see if there are any orphan folders
|
|
// To qualify as an orphan, the lpFolder->bOwned should be FALSE and the folder must
|
|
// also not be shared because if it's shared it will show up as part of Shared Contacts
|
|
lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
if(!lpFolder->bOwned && !lpFolder->bShared)
|
|
{
|
|
LPWABUSERFOLDER lpOwnerFolder = lpDefUser;
|
|
if(lpFolder->lpFolderOwner)
|
|
{
|
|
// Someone created this folder .. we need to make sure this is associated back to that original
|
|
// creator and only if that doesn't work should we append it to the default user
|
|
if(!(lpOwnerFolder = FindWABFolder(lpIAB, NULL, NULL, lpFolder->lpFolderOwner)))
|
|
lpOwnerFolder = lpDefUser;
|
|
}
|
|
|
|
if(lpOwnerFolder)
|
|
{
|
|
if(HR_FAILED(hr = HrAddRemoveFolderFromUserFolder( lpIAB, lpDefUser,
|
|
&lpFolder->sbEID, NULL, FALSE ) ))
|
|
goto out;
|
|
}
|
|
}
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
|
|
out:
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
- HrLinkUserFoldersToWABFolders
|
|
-
|
|
*
|
|
* Cross-links the user folder contents with the regular folders
|
|
* This makes accessing folder info much easier ..
|
|
*/
|
|
HRESULT HrLinkUserFoldersToWABFolders(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPWABUSERFOLDER lpUserFolder = NULL;
|
|
LPWABFOLDER lpFolder = NULL;
|
|
ULONG ulcPropCount = 0, i = 0, j = 0;
|
|
LPSPropValue lpProp = NULL;
|
|
|
|
if(!lpIAB->lpWABUserFolders || !lpIAB->lpWABFolders)
|
|
goto out;
|
|
|
|
lpUserFolder = lpIAB->lpWABUserFolders;
|
|
while(lpUserFolder)
|
|
{
|
|
if(HR_FAILED(hr = ReadRecord(lpIAB->lpPropertyStore->hPropertyStore, &lpUserFolder->sbEID,
|
|
0, &ulcPropCount, &lpProp)))
|
|
goto out;
|
|
|
|
for(i=0;i<ulcPropCount;i++)
|
|
{
|
|
if(lpProp[i].ulPropTag == PR_WAB_USER_SUBFOLDERS)
|
|
{
|
|
for(j=0;j<lpProp[i].Value.MVbin.cValues;j++)
|
|
{
|
|
lpFolder = FindWABFolder(lpIAB, &(lpProp[i].Value.MVbin.lpbin[j]), NULL, NULL);
|
|
if(lpFolder)
|
|
{
|
|
LPWABFOLDERLIST lpFolderItem = LocalAlloc(LMEM_ZEROINIT, sizeof(WABFOLDERLIST));
|
|
if(lpFolderItem)
|
|
{
|
|
lpFolderItem->lpFolder = lpFolder;
|
|
lpFolder->bOwned = TRUE;
|
|
lpFolderItem->lpNext = lpUserFolder->lpFolderList;
|
|
lpUserFolder->lpFolderList = lpFolderItem;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
ReadRecordFreePropArray(NULL, ulcPropCount, &lpProp);
|
|
ulcPropCount = 0;
|
|
lpProp = NULL;
|
|
lpUserFolder = lpUserFolder->lpNext;
|
|
}
|
|
|
|
out:
|
|
ReadRecordFreePropArray(NULL, ulcPropCount, &lpProp);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
- HrGetFolderInfo()
|
|
-
|
|
* Reads a folder name directly from the prop store
|
|
* Also checks if this is a user folder and what the profile is
|
|
* Returns LocalAlloced LPTSTRs which caller needs to free
|
|
*/
|
|
HRESULT HrGetFolderInfo(LPIAB lpIAB, LPSBinary lpsbEID, LPWABFOLDER lpFolder)
|
|
{
|
|
LPTSTR lpName = NULL, lpProfileID = NULL, lpOwner = NULL;
|
|
HRESULT hr = S_OK;
|
|
ULONG ulcPropCount = 0, j=0;
|
|
LPSPropValue lpProp = NULL;
|
|
BOOL bShared = FALSE;
|
|
|
|
if(!bIsWABSessionProfileAware(lpIAB) || !lpsbEID)
|
|
goto out;
|
|
|
|
if(!lpsbEID->cb && !lpsbEID->lpb)
|
|
{
|
|
// special case - read the address book item
|
|
lpName = LocalAlloc(LMEM_ZEROINIT, MAX_PATH);
|
|
if(lpName)
|
|
LoadString(hinstMapiX, idsContacts/*IDS_ADDRBK_CAPTION*/, lpName, MAX_PATH-1);
|
|
}
|
|
else
|
|
{
|
|
hr = ReadRecord(lpIAB->lpPropertyStore->hPropertyStore, lpsbEID,
|
|
0, &ulcPropCount, &lpProp);
|
|
if(HR_FAILED(hr))
|
|
goto out;
|
|
|
|
for(j=0;j<ulcPropCount;j++)
|
|
{
|
|
ULONG cchSize;
|
|
if(lpProp[j].ulPropTag == PR_DISPLAY_NAME)
|
|
{
|
|
cchSize = lstrlen(lpProp[j].Value.LPSZ)+1;
|
|
if(lpName = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize))
|
|
StrCpyN(lpName, lpProp[j].Value.LPSZ, cchSize);
|
|
else
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
}
|
|
if(lpProp[j].ulPropTag == PR_WAB_USER_PROFILEID)
|
|
{
|
|
cchSize = lstrlen(lpProp[j].Value.LPSZ)+1;
|
|
if(lpProfileID = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize))
|
|
StrCpyN(lpProfileID, lpProp[j].Value.LPSZ, cchSize);
|
|
else
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
}
|
|
if(lpProp[j].ulPropTag == PR_WAB_FOLDEROWNER)
|
|
{
|
|
TCHAR szName[CCH_IDENTITY_NAME_MAX_LENGTH];
|
|
*szName = '\0';
|
|
if( !HR_FAILED(HrGetIdentityName(lpIAB, lpProp[j].Value.LPSZ, szName, ARRAYSIZE(szName))) &&
|
|
lstrlen(szName))
|
|
{
|
|
cchSize = lstrlen(szName)+1;
|
|
if(lpOwner = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize))
|
|
StrCpyN(lpOwner, szName, cchSize);
|
|
else
|
|
hr = MAPI_E_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
if(lpProp[j].ulPropTag == PR_WAB_SHAREDFOLDER)
|
|
{
|
|
bShared = (lpProp[j].Value.l==FOLDER_SHARED?TRUE:FALSE);
|
|
}
|
|
}
|
|
|
|
// ideally, we should be reading in a new name for all user folders at this point
|
|
//if(lpProfileID && lstrlen(lpProfileID))
|
|
//{
|
|
// if(lpName)
|
|
// LocalFree(lpName);
|
|
// CreateUserFolderName(lpProfileID, &lpName);
|
|
//}
|
|
}
|
|
lpFolder->lpFolderName = lpName;
|
|
lpFolder->lpProfileID = lpProfileID;
|
|
lpFolder->bShared = bShared;
|
|
lpFolder->lpFolderOwner = lpOwner;
|
|
|
|
out:
|
|
|
|
ReadRecordFreePropArray(NULL, ulcPropCount, &lpProp);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
- HrLoadWABFolders
|
|
-
|
|
* Gets a list of all the folders from the WAB and sorts them out based on
|
|
* whether they are user folders or ordinary folders
|
|
*
|
|
*/
|
|
HRESULT HrLoadWABFolders(LPIAB lpIAB)
|
|
{
|
|
SCODE sc;
|
|
HRESULT hr = E_FAIL;
|
|
SPropertyRestriction PropRes = {0};
|
|
SPropValue sp = {0};
|
|
ULONG ulCount = 0;
|
|
LPSBinary rgsbEntryIDs = NULL;
|
|
ULONG i = 0;
|
|
int nID = IDM_VIEW_FOLDERS1;
|
|
|
|
// Now we will search the WAB for all objects of PR_OBJECT_TYPE = MAPI_ABCONT
|
|
//
|
|
sp.ulPropTag = PR_OBJECT_TYPE;
|
|
sp.Value.l = MAPI_ABCONT;
|
|
|
|
PropRes.ulPropTag = PR_OBJECT_TYPE;
|
|
PropRes.relop = RELOP_EQ;
|
|
PropRes.lpProp = &sp;
|
|
|
|
hr = FindRecords( lpIAB->lpPropertyStore->hPropertyStore,
|
|
NULL, 0, TRUE,
|
|
&PropRes, &ulCount, &rgsbEntryIDs);
|
|
|
|
if (HR_FAILED(hr))
|
|
goto out;
|
|
|
|
if(ulCount && rgsbEntryIDs)
|
|
{
|
|
for(i=0;i<ulCount;i++)
|
|
{
|
|
ULONG cb = 0;
|
|
LPENTRYID lpb = NULL;
|
|
LPWABFOLDER lpFolder = NULL;
|
|
|
|
lpFolder = LocalAlloc(LMEM_ZEROINIT, sizeof(WABFOLDER));
|
|
if(!lpFolder)
|
|
goto out;
|
|
|
|
if(HR_FAILED(HrGetFolderInfo(lpIAB, &rgsbEntryIDs[i], lpFolder)))
|
|
goto out;
|
|
|
|
if(!HR_FAILED(CreateWABEntryID( WAB_CONTAINER,
|
|
rgsbEntryIDs[i].lpb, NULL, NULL,
|
|
rgsbEntryIDs[i].cb, 0,
|
|
NULL, &cb, &lpb)))
|
|
{
|
|
// Add the entryids to this prop - ignore errors
|
|
SetSBinary(&(lpFolder->sbEID), cb, (LPBYTE)lpb);
|
|
MAPIFreeBuffer(lpb);
|
|
}
|
|
|
|
if(lpFolder->lpProfileID)
|
|
{
|
|
// this is a user folder
|
|
lpFolder->lpNext = lpIAB->lpWABUserFolders;
|
|
lpIAB->lpWABUserFolders = lpFolder;
|
|
}
|
|
else
|
|
{
|
|
lpFolder->lpNext = lpIAB->lpWABFolders;
|
|
lpFolder->nMenuCmdID = nID++;
|
|
lpIAB->lpWABFolders = lpFolder;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(HR_FAILED(hr = HrLinkUserFoldersToWABFolders(lpIAB)))
|
|
goto out;
|
|
|
|
HrLinkOrphanFoldersToDefaultUser(lpIAB); // we can ignore errors in this call since it's not life-and-death
|
|
|
|
out:
|
|
if(ulCount && rgsbEntryIDs)
|
|
{
|
|
FreeEntryIDs(lpIAB->lpPropertyStore->hPropertyStore,
|
|
ulCount,
|
|
rgsbEntryIDs);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
-
|
|
- HrCreateNewFolder
|
|
*
|
|
* Takes a profile ID, uses it to create a folder in the WAB
|
|
* and sticks the new user folder onto the IAB
|
|
* Can create a user folder or an ordinary folder
|
|
* For ordinary folders, we can also specify a parent folder to which the item can be added
|
|
*
|
|
*/
|
|
HRESULT HrCreateNewFolder(LPIAB lpIAB, LPTSTR lpName, LPTSTR lpProfileID, BOOL bUserFolder,
|
|
LPWABFOLDER lpParentFolder, BOOL bShared, LPSBinary lpsbNew)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
SPropValue spv[proUserFolderMax];
|
|
LPSBinary lpsb = NULL;
|
|
SBinary sb = {0};
|
|
LPMAPIPROP lpObject = NULL;
|
|
ULONG ulcProps = 0, j = 0;
|
|
LPSPropValue lpProps = NULL;
|
|
LPWABFOLDER lpFolder = NULL;
|
|
ULONG ulPropCount = 0;
|
|
ULONG cchSize;
|
|
|
|
if(!(lpFolder = LocalAlloc(LMEM_ZEROINIT, sizeof(WABFOLDER))))
|
|
return MAPI_E_NOT_ENOUGH_MEMORY;
|
|
|
|
if(bUserFolder)
|
|
{
|
|
CreateUserFolderName(lpName ? lpName : lpProfileID, &lpFolder->lpFolderName);
|
|
cchSize = lstrlen(lpProfileID)+1;
|
|
if(!(lpFolder->lpProfileID = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize)))
|
|
return MAPI_E_NOT_ENOUGH_MEMORY;
|
|
StrCpyN(lpFolder->lpProfileID, lpProfileID, cchSize);
|
|
}
|
|
else
|
|
{
|
|
cchSize = lstrlen(lpName)+1;
|
|
if(!(lpFolder->lpFolderName = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize)))
|
|
return MAPI_E_NOT_ENOUGH_MEMORY;
|
|
StrCpyN(lpFolder->lpFolderName, lpName, cchSize);
|
|
}
|
|
|
|
// if there isn't a current user, all new folders should go into the shared contacts folder
|
|
if(!bIsThereACurrentUser(lpIAB) && !lpProfileID && !lpParentFolder)
|
|
bShared = TRUE;
|
|
|
|
spv[ulPropCount].ulPropTag = PR_DISPLAY_NAME;
|
|
spv[ulPropCount++].Value.LPSZ = lpFolder->lpFolderName;
|
|
|
|
spv[ulPropCount].ulPropTag = PR_OBJECT_TYPE;
|
|
spv[ulPropCount++].Value.l = MAPI_ABCONT;
|
|
|
|
spv[ulPropCount].ulPropTag = PR_WAB_FOLDER_ENTRIES;
|
|
spv[ulPropCount].Value.MVbin.cValues = 1;
|
|
spv[ulPropCount++].Value.MVbin.lpbin = &sb;
|
|
|
|
spv[ulPropCount].ulPropTag = PR_WAB_SHAREDFOLDER;
|
|
spv[ulPropCount++].Value.l = (bUserFolder ? FOLDER_PRIVATE : (bShared ? FOLDER_SHARED : FOLDER_PRIVATE));
|
|
|
|
if(lpProfileID)
|
|
{
|
|
spv[ulPropCount].ulPropTag = PR_WAB_FOLDEROWNER;
|
|
spv[ulPropCount++].Value.LPSZ = lpProfileID;
|
|
}
|
|
|
|
if(bUserFolder)
|
|
{
|
|
spv[ulPropCount].ulPropTag = PR_WAB_USER_SUBFOLDERS;
|
|
spv[ulPropCount].Value.MVbin.cValues = 1;
|
|
spv[ulPropCount++].Value.MVbin.lpbin = &sb;
|
|
|
|
spv[ulPropCount].ulPropTag = PR_WAB_USER_PROFILEID;
|
|
spv[ulPropCount++].Value.LPSZ = lpFolder->lpProfileID;
|
|
}
|
|
|
|
if(HR_FAILED(hr = HrSaveFolderProps((LPADRBOOK)lpIAB, bUserFolder,
|
|
ulPropCount,
|
|
spv, &lpObject)))
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = lpObject->lpVtbl->GetProps(lpObject, NULL, MAPI_UNICODE, &ulcProps, &lpProps)))
|
|
goto out;
|
|
|
|
for(j=0;j<ulcProps;j++)
|
|
{
|
|
if(lpProps[j].ulPropTag == PR_ENTRYID)
|
|
{
|
|
lpsb = &(lpProps[j].Value.bin);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(lpsb)
|
|
{
|
|
ULONG cb = 0;
|
|
LPENTRYID lpb = NULL;
|
|
if(!HR_FAILED(CreateWABEntryID( WAB_CONTAINER,
|
|
lpsb->lpb, NULL, NULL,
|
|
lpsb->cb, 0,
|
|
NULL, &cb, &lpb)))
|
|
{
|
|
// Add the entryids to this prop - ignore errors
|
|
SetSBinary(&(lpFolder->sbEID), cb, (LPBYTE) lpb);
|
|
MAPIFreeBuffer(lpb);
|
|
}
|
|
}
|
|
|
|
if(bUserFolder)
|
|
{
|
|
lpFolder->lpNext = lpIAB->lpWABUserFolders;
|
|
lpIAB->lpWABUserFolders = lpFolder;
|
|
}
|
|
else
|
|
{
|
|
lpFolder->lpNext = lpIAB->lpWABFolders;
|
|
lpIAB->lpWABFolders = lpFolder;
|
|
// Add this folder to the current user's profile
|
|
HrAddRemoveFolderFromUserFolder(lpIAB, lpParentFolder, &(lpFolder->sbEID), NULL, FALSE);
|
|
}
|
|
|
|
if(lpsbNew)
|
|
SetSBinary(lpsbNew, lpFolder->sbEID.cb, lpFolder->sbEID.lpb);
|
|
|
|
hr = HrGetWABProfiles(lpIAB);
|
|
|
|
out:
|
|
if(lpObject)
|
|
lpObject->lpVtbl->Release(lpObject);
|
|
|
|
FreeBufferAndNull(&lpProps);
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
- HrAddAllContactsToFolder
|
|
-
|
|
* Adds all existing contacts and groups to the current user folder
|
|
*
|
|
*/
|
|
HRESULT HrAddAllContactsToFolder(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = 0;
|
|
SPropertyRestriction PropRes;
|
|
LPSBinary rgsbEntryIDs = NULL;
|
|
ULONG ulCount = 0, i,j;
|
|
ULONG rgObj[] = {MAPI_MAILUSER, MAPI_DISTLIST};
|
|
// This can be a labor intesive process
|
|
HCURSOR hOldC = NULL;
|
|
|
|
if(!bIsThereACurrentUser(lpIAB))
|
|
return hr;
|
|
|
|
hOldC = SetCursor(LoadCursor(NULL, IDC_WAIT));
|
|
|
|
//for(j=0;j<2;j++)
|
|
{
|
|
SPropValue sp = {0};
|
|
sp.ulPropTag = PR_WAB_FOLDER_PARENT;
|
|
//sp.Value.l = rgObj[j];
|
|
|
|
PropRes.ulPropTag = PR_WAB_FOLDER_PARENT;
|
|
PropRes.relop = RELOP_NE;
|
|
PropRes.lpProp = &sp;
|
|
|
|
// Find stuff that isn't in any folder
|
|
if(!HR_FAILED(hr = FindRecords( lpIAB->lpPropertyStore->hPropertyStore,
|
|
NULL, AB_MATCH_PROP_ONLY, TRUE, &PropRes, &ulCount, &rgsbEntryIDs)))
|
|
{
|
|
for(i=0;i<ulCount;i++)
|
|
{
|
|
AddEntryToFolder((LPADRBOOK)lpIAB,NULL,
|
|
lpIAB->lpWABCurrentUserFolder->sbEID.cb,
|
|
(LPENTRYID) lpIAB->lpWABCurrentUserFolder->sbEID.lpb,
|
|
rgsbEntryIDs[i].cb,
|
|
(LPENTRYID) rgsbEntryIDs[i].lpb);
|
|
}
|
|
|
|
FreeEntryIDs(lpIAB->lpPropertyStore->hPropertyStore, ulCount, rgsbEntryIDs);
|
|
}
|
|
}
|
|
|
|
if(hOldC)
|
|
SetCursor(hOldC);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
/*
|
|
- UpdateCurrentUserFolderName
|
|
-
|
|
*
|
|
*/
|
|
void UpdateCurrentUserFolderName(LPIAB lpIAB)
|
|
{
|
|
LPTSTR lpsz = NULL;
|
|
CreateUserFolderName(lpIAB->szProfileName, &lpsz);
|
|
if(lstrcmpi(lpsz, lpIAB->lpWABCurrentUserFolder->lpFolderName))
|
|
{
|
|
LocalFree(lpIAB->lpWABCurrentUserFolder->lpFolderName);
|
|
lpIAB->lpWABCurrentUserFolder->lpFolderName = lpsz;
|
|
HrUpdateFolderInfo(lpIAB, &lpIAB->lpWABCurrentUserFolder->sbEID, FOLDER_UPDATE_NAME, FALSE, lpIAB->lpWABCurrentUserFolder->lpFolderName);
|
|
}
|
|
else
|
|
LocalFree(lpsz);
|
|
}
|
|
|
|
|
|
/*
|
|
- HrGetWABProfiles
|
|
-
|
|
* Collates information about the WAB User Folders etc from the WAB
|
|
* Creates a list of User Folders and generic Folders and caches these on the Address Book
|
|
* Matches the provided profile to the user folders .. if it matches, points to the
|
|
* corresponding folder .. if it doesn't match, creates a new User Folder for the
|
|
* Profile ID.
|
|
*
|
|
* <TBD> when the account manager is profile ready, use the profile ID to pull in the
|
|
* users name from the account manager and then use that to call it TEXT("UserName's Contacts")
|
|
* For now, we'll just use the profile id to do that
|
|
*/
|
|
HRESULT HrGetWABProfiles(LPIAB lpIAB)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
|
|
EnterCriticalSection(&lpIAB->cs);
|
|
|
|
if(!bIsWABSessionProfileAware(lpIAB))
|
|
goto out;
|
|
|
|
if(!lstrlen(lpIAB->szProfileID))
|
|
HrGetUserProfileID(&lpIAB->guidCurrentUser, lpIAB->szProfileID, CharSizeOf(lpIAB->szProfileID));
|
|
|
|
if(!lstrlen(lpIAB->szProfileName))
|
|
HrGetIdentityName(lpIAB, NULL, lpIAB->szProfileName, ARRAYSIZE(lpIAB->szProfileName));
|
|
|
|
// Clear out old data
|
|
if(lpIAB->lpWABUserFolders || lpIAB->lpWABFolders)
|
|
FreeWABFoldersList(lpIAB);
|
|
|
|
// Get a list of all the folders in the WAB
|
|
if(HR_FAILED(hr = HrLoadWABFolders(lpIAB)))
|
|
goto out;
|
|
|
|
SetCurrentUserFolder(lpIAB, lpIAB->szProfileID);
|
|
|
|
if(!bIsThereACurrentUser(lpIAB) && lstrlen(lpIAB->szProfileID) && lstrlen(lpIAB->szProfileName))
|
|
{
|
|
// Not Found!!!
|
|
// Create a new user folder ..
|
|
BOOL bFirstUser = bDoesThisWABHaveAnyUsers(lpIAB) ? FALSE : TRUE;
|
|
|
|
if(HR_FAILED(hr = HrCreateNewFolder(lpIAB, lpIAB->szProfileName, lpIAB->szProfileID, TRUE, NULL, FALSE, NULL)))
|
|
goto out;
|
|
|
|
SetCurrentUserFolder(lpIAB, lpIAB->szProfileID);
|
|
|
|
if(bFirstUser)
|
|
{
|
|
if(lpIAB->lpWABFolders)
|
|
{
|
|
// we want to put all existing folders under this user
|
|
LPWABFOLDER lpFolder = lpIAB->lpWABFolders;
|
|
while(lpFolder)
|
|
{
|
|
// There is a weird case where a preexisting folder with the same name as
|
|
// a user's folder becomes nested under itself .. so don't add this folder to the
|
|
// User Folder
|
|
if(lstrcmpi(lpIAB->lpWABCurrentUserFolder->lpFolderName, lpFolder->lpFolderName))
|
|
HrAddRemoveFolderFromUserFolder(lpIAB, NULL, &lpFolder->sbEID, NULL, FALSE);
|
|
lpFolder = lpFolder->lpNext;
|
|
}
|
|
hr = HrLinkUserFoldersToWABFolders(lpIAB);
|
|
}
|
|
//We also want to put all existing contacts into this user folder
|
|
hr = HrAddAllContactsToFolder(lpIAB);
|
|
}
|
|
}
|
|
|
|
if( lpIAB->szProfileID && lstrlen(lpIAB->szProfileID) && lpIAB->szProfileName && lstrlen(lpIAB->szProfileName) && bIsThereACurrentUser(lpIAB))
|
|
{
|
|
// Use the latest name for this entry
|
|
UpdateCurrentUserFolderName(lpIAB);
|
|
}
|
|
|
|
if(HR_FAILED(hr = HrGetWABProfileContainerInfo(lpIAB)))
|
|
goto out;
|
|
|
|
hr = S_OK;
|
|
out:
|
|
LeaveCriticalSection(&lpIAB->cs);
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
- bIsProfileMember
|
|
-
|
|
*
|
|
*/
|
|
BOOL bIsProfileMember(LPIAB lpIAB, LPSBinary lpsb, LPWABFOLDER lpWABFolder, LPWABUSERFOLDER lpUserFolder)
|
|
{
|
|
LPWABFOLDERLIST lpFolderItem = NULL;
|
|
LPWABFOLDER lpFolder = lpWABFolder;
|
|
|
|
if(!lpUserFolder && !lpIAB->lpWABCurrentUserFolder)
|
|
return FALSE;
|
|
|
|
lpFolderItem = lpUserFolder ? lpUserFolder->lpFolderList : lpIAB->lpWABCurrentUserFolder->lpFolderList;
|
|
|
|
if(!lpFolder && lpsb)
|
|
lpFolder = FindWABFolder(lpIAB, lpsb, NULL, NULL);
|
|
|
|
while(lpFolderItem && lpFolder)
|
|
{
|
|
if(lpFolderItem->lpFolder == lpFolder)
|
|
return TRUE;
|
|
lpFolderItem = lpFolderItem->lpNext;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/*
|
|
- bDoesEntryNameAlreadyExist
|
|
-
|
|
* Checks if a given name already exists in the WAB
|
|
* Used for preventing duplicate folder and group names
|
|
*/
|
|
BOOL bDoesEntryNameAlreadyExist(LPIAB lpIAB, LPTSTR lpsz)
|
|
{
|
|
SPropertyRestriction PropRes;
|
|
SPropValue Prop = {0};
|
|
LPSBinary rgsbEntryIDs = NULL;
|
|
ULONG ulCount = 0;
|
|
BOOL bRet = FALSE;
|
|
|
|
// Verify that the new name doesn't actually exist
|
|
Prop.ulPropTag = PR_DISPLAY_NAME;
|
|
Prop.Value.LPSZ = lpsz;
|
|
PropRes.lpProp = &Prop;
|
|
PropRes.relop = RELOP_EQ;
|
|
PropRes.ulPropTag = PR_DISPLAY_NAME;
|
|
|
|
if (HR_FAILED(FindRecords(lpIAB->lpPropertyStore->hPropertyStore,
|
|
NULL, // pmbinFolder
|
|
0, // ulFlags
|
|
TRUE, // Always TRUE
|
|
&PropRes, // Propertyrestriction
|
|
&ulCount, // IN: number of matches to find, OUT: number found
|
|
&rgsbEntryIDs)))
|
|
goto out;
|
|
|
|
FreeEntryIDs(lpIAB->lpPropertyStore->hPropertyStore, ulCount, rgsbEntryIDs);
|
|
|
|
if(ulCount >=1)
|
|
bRet = TRUE;
|
|
out:
|
|
return bRet;
|
|
}
|
|
|
|
/*
|
|
- UpdateFolderName
|
|
-
|
|
*
|
|
*/
|
|
HRESULT HrUpdateFolderInfo(LPIAB lpIAB, LPSBinary lpsbEID, ULONG ulFlags, BOOL bShared, LPTSTR lpsz)
|
|
{
|
|
LPSPropValue lpProp = NULL, lpPropNew = NULL;
|
|
ULONG ulcPropCount = 0, i =0, ulcPropNew = 0;
|
|
HRESULT hr = S_OK;
|
|
BOOL bUpdate = FALSE, bFoundShare = FALSE;//, bOldShareState = FALSE;
|
|
ULONG cchSize;
|
|
|
|
if(!lpsbEID || !lpsbEID->cb || !lpsbEID->lpb)
|
|
return MAPI_E_INVALID_PARAMETER;
|
|
|
|
if(!HR_FAILED(hr = ReadRecord( lpIAB->lpPropertyStore->hPropertyStore,
|
|
lpsbEID, 0, &ulcPropCount, &lpProp)))
|
|
{
|
|
for(i=0;i<ulcPropCount;i++)
|
|
{
|
|
if( (ulFlags & FOLDER_UPDATE_NAME) &&
|
|
lpProp[i].ulPropTag == PR_DISPLAY_NAME)
|
|
{
|
|
BOOL bCaseChangeOnly = (!lstrcmpi(lpsz, lpProp[i].Value.LPSZ) &&
|
|
lstrcmp(lpsz, lpProp[i].Value.LPSZ) );
|
|
LocalFree(lpProp[i].Value.LPSZ);
|
|
cchSize = lstrlen(lpsz)+1;
|
|
lpProp[i].Value.LPSZ = LocalAlloc(LMEM_ZEROINIT, sizeof(TCHAR)*cchSize);
|
|
if(lpProp[i].Value.LPSZ)
|
|
{
|
|
StrCpyN(lpProp[i].Value.LPSZ, lpsz, cchSize);
|
|
if(!bCaseChangeOnly) // if this isn't just a case change, look for the name (if it's a case change, there will be a spurious error) //bug 33067
|
|
{
|
|
if(bDoesEntryNameAlreadyExist(lpIAB, lpProp[i].Value.LPSZ))
|
|
{
|
|
hr = MAPI_E_COLLISION;
|
|
goto out;
|
|
}
|
|
}
|
|
bUpdate = TRUE;
|
|
}
|
|
}
|
|
if( (ulFlags & FOLDER_UPDATE_SHARE) &&
|
|
lpProp[i].ulPropTag == PR_WAB_SHAREDFOLDER)
|
|
{
|
|
bFoundShare = TRUE;
|
|
//bOldShareState = (lpProp[i].Value.l == FOLDER_SHARED) ? TRUE : FALSE;
|
|
lpProp[i].Value.l = bShared ? FOLDER_SHARED : FOLDER_PRIVATE;
|
|
bUpdate = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bFoundShare && (ulFlags & FOLDER_UPDATE_SHARE)) // this value doesnt already exist on the contact so update it
|
|
{
|
|
SPropValue Prop = {0};
|
|
Prop.ulPropTag = PR_WAB_SHAREDFOLDER;
|
|
Prop.Value.l = bShared ? FOLDER_SHARED : FOLDER_PRIVATE;
|
|
|
|
// Create a new prop array with this additional property
|
|
if(!(ScMergePropValues( 1, &Prop, ulcPropCount, lpProp,
|
|
&ulcPropNew, &lpPropNew)))
|
|
{
|
|
ReadRecordFreePropArray(NULL, ulcPropCount, &lpProp);
|
|
ulcPropCount = ulcPropNew;
|
|
lpProp = lpPropNew;
|
|
bUpdate = TRUE;
|
|
}
|
|
}
|
|
|
|
if(bUpdate)
|
|
{
|
|
if(HR_FAILED(hr = HrSaveFolderProps((LPADRBOOK)lpIAB, FALSE, ulcPropCount, lpProp, NULL)))
|
|
goto out;
|
|
}
|
|
|
|
|
|
out:
|
|
if(lpProp)
|
|
{
|
|
if(lpProp == lpPropNew)
|
|
FreeBufferAndNull(&lpProp);
|
|
else
|
|
ReadRecordFreePropArray(NULL, ulcPropCount, &lpProp);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
/*
|
|
- HrAddRemoveFolderFromCurrentUserFolder
|
|
-
|
|
* Given a folder EID, adds or removes the folder EID from the current users
|
|
* user folder
|
|
* If there is no current user folder then use the lpUserFolder provided
|
|
* else return
|
|
*
|
|
* lpUFolder - parent folder to / from which to add / remove
|
|
* lpsbEID - EID of folder we want to add / remove
|
|
* lpName - Name to look for if we don't have an EID
|
|
*/
|
|
HRESULT HrAddRemoveFolderFromUserFolder(LPIAB lpIAB, LPWABFOLDER lpUFolder,
|
|
LPSBinary lpsbEID, LPTSTR lpName,
|
|
BOOL bRefreshProfiles)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
ULONG ulcPropsNew = 0, ulcProps = 0, i = 0;
|
|
LPSPropValue lpPropArrayNew = NULL;
|
|
LPSPropValue lpProps = NULL;
|
|
LPWABFOLDER lpUserFolder = NULL;
|
|
|
|
if(!lpsbEID && lpName)
|
|
{
|
|
LPWABFOLDER lpFolder = FindWABFolder(lpIAB, NULL, lpName, NULL);
|
|
lpsbEID = &lpFolder->sbEID;
|
|
}
|
|
|
|
if(lpIAB->lpWABCurrentUserFolder)
|
|
lpUserFolder = lpIAB->lpWABCurrentUserFolder;
|
|
else if(lpUFolder)
|
|
lpUserFolder = lpUFolder;
|
|
else
|
|
goto out;
|
|
|
|
{
|
|
// open the current user folder
|
|
if(!HR_FAILED(hr = ReadRecord(lpIAB->lpPropertyStore->hPropertyStore, &(lpUserFolder->sbEID),
|
|
0, &ulcProps, &lpProps)))
|
|
{
|
|
SPropValue spv = {0};
|
|
spv.ulPropTag = PR_NULL;
|
|
// Copy the props into a MAPI proparray
|
|
if(!(ScMergePropValues( 1, &spv, ulcProps, lpProps,
|
|
&ulcPropsNew, &lpPropArrayNew)))
|
|
{
|
|
for(i=0;i<ulcPropsNew;i++)
|
|
{
|
|
if(lpProps[i].ulPropTag == PR_WAB_USER_SUBFOLDERS)
|
|
{
|
|
if(bIsProfileMember(lpIAB, lpsbEID, NULL, lpUserFolder))
|
|
RemovePropFromMVBin( lpPropArrayNew, ulcPropsNew, i, lpsbEID->lpb, lpsbEID->cb);
|
|
else
|
|
AddPropToMVPBin( lpPropArrayNew, i, lpsbEID->lpb, lpsbEID->cb, TRUE);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if(HR_FAILED(hr = HrSaveFolderProps((LPADRBOOK)lpIAB, FALSE, ulcPropsNew, lpPropArrayNew, NULL)))
|
|
goto out;
|
|
}
|
|
}
|
|
|
|
if(bRefreshProfiles)
|
|
hr = HrGetWABProfiles(lpIAB);
|
|
|
|
out:
|
|
ReadRecordFreePropArray(NULL, ulcProps, &lpProps);
|
|
MAPIFreeBuffer(lpPropArrayNew);
|
|
return hr;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
-
|
|
- bDoesThisWABHaveAnyUsers
|
|
*
|
|
* TRUE if some user folders exist .. FALSE if NO user folders exist
|
|
*/
|
|
BOOL bDoesThisWABHaveAnyUsers(LPIAB lpIAB)
|
|
{
|
|
return (lpIAB->lpWABUserFolders != NULL);
|
|
}
|
|
|
|
/*
|
|
-
|
|
- bIsThereACurrentUser
|
|
*
|
|
* TRUE if there is a current user .. FALSE if not
|
|
*/
|
|
BOOL bIsThereACurrentUser(LPIAB lpIAB)
|
|
{
|
|
// Don't change this test since success of this test implies that lpIAB->lpWABCurrentUserFolder is not NULL
|
|
// and can be dereferenced
|
|
return (lpIAB->lpWABCurrentUserFolder != NULL);
|
|
}
|
|
|
|
/*
|
|
-
|
|
- bAreWABAPIProfileAware
|
|
*
|
|
* TRUE if the WAB API should behave with profile-awareness, false if they should revert to old behaviour
|
|
*/
|
|
BOOL bAreWABAPIProfileAware(LPIAB lpIAB)
|
|
{
|
|
return (lpIAB->bProfilesAPIEnabled);
|
|
}
|
|
|
|
/*
|
|
-
|
|
- bIsWABSessionProfileAware
|
|
*
|
|
* TRUE if the WAB should behave with profile-awareness, false if they should revert to old behaviour
|
|
* This is also used to differentiate between Outlook sessions which are not at all profile aware
|
|
*/
|
|
BOOL bIsWABSessionProfileAware(LPIAB lpIAB)
|
|
{
|
|
return (lpIAB->bProfilesEnabled);
|
|
}
|
|
|
|
|
|
|
|
|
|
/**************************************/
|
|
/******* Identity Manager Stuff *******/
|
|
|
|
// Global place to store the account manager object
|
|
//IUserIdentityManager * g_lpUserIdentityManager = NULL;
|
|
//BOOL fCoInitUserIdentityManager = FALSE;
|
|
//ULONG cIdentInit = 0;
|
|
|
|
|
|
//*******************************************************************
|
|
//
|
|
// FUNCTION: HrWrappedCreateIdentityManager
|
|
//
|
|
// PURPOSE: Load identity manager dll and create the object.
|
|
//
|
|
// PARAMETERS: lppIdentityManager -> returned pointer to Identity manager
|
|
// object.
|
|
//
|
|
// RETURNS: HRESULT
|
|
//
|
|
//*******************************************************************
|
|
HRESULT HrWrappedCreateUserIdentityManager(LPIAB lpIAB, IUserIdentityManager **lppUserIdentityManager)
|
|
{
|
|
HRESULT hResult = E_FAIL;
|
|
|
|
if (! lppUserIdentityManager) {
|
|
return(ResultFromScode(E_INVALIDARG));
|
|
}
|
|
|
|
*lppUserIdentityManager = NULL;
|
|
|
|
if (CoInitialize(NULL) == S_FALSE)
|
|
{
|
|
// Already initialized, undo the extra.
|
|
CoUninitialize();
|
|
} else
|
|
{
|
|
lpIAB->fCoInitUserIdentityManager = TRUE;
|
|
}
|
|
|
|
if (HR_FAILED(hResult = CoCreateInstance(&CLSID_UserIdentityManager,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
&IID_IUserIdentityManager,
|
|
(LPVOID *)lppUserIdentityManager)))
|
|
{
|
|
DebugTrace(TEXT("CoCreateInstance(IID_IUserIdentityManager) -> %x\n"), GetScode(hResult));
|
|
}
|
|
|
|
return(hResult);
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
//
|
|
// FUNCTION: InitUserIdentityManager
|
|
//
|
|
// PURPOSE: Load and initialize the account manager
|
|
//
|
|
// PARAMETERS: lppUserIdentityManager -> returned pointer to account manager
|
|
// object.
|
|
//
|
|
// RETURNS: HRESULT
|
|
//
|
|
// COMMENTS: The first time through here, we will save the hResult.
|
|
// On subsequent calls, we will check this saved value
|
|
// and return it right away if there was an error, thus
|
|
// preventing repeated time consuming LoadLibrary calls.
|
|
//
|
|
//*******************************************************************
|
|
HRESULT InitUserIdentityManager(LPIAB lpIAB, IUserIdentityManager ** lppUserIdentityManager)
|
|
{
|
|
static hResultSave = hrSuccess;
|
|
HRESULT hResult = hResultSave;
|
|
|
|
if (! lpIAB->lpUserIdentityManager && ! HR_FAILED(hResultSave))
|
|
{
|
|
#ifdef DEBUG
|
|
DWORD dwTickCount = GetTickCount();
|
|
DebugTrace(TEXT(">>>>> Initializing User Identity Manager...\n"));
|
|
#endif // DEBUG
|
|
|
|
if (hResult = HrWrappedCreateUserIdentityManager(lpIAB, &lpIAB->lpUserIdentityManager))
|
|
{
|
|
DebugTrace(TEXT("HrWrappedCreateUserIdentityManager -> %x\n"), GetScode(hResult));
|
|
goto end;
|
|
}
|
|
Assert(lpIAB->lpUserIdentityManager);
|
|
|
|
lpIAB->cIdentInit++; // +1 here to match the release in IAB_Neuter
|
|
|
|
#ifdef DEBUG
|
|
DebugTrace( TEXT(">>>>> Done Initializing User Identity Manager... %u milliseconds\n"), GetTickCount() - dwTickCount);
|
|
#endif // DEBUG
|
|
}
|
|
|
|
lpIAB->cIdentInit++;
|
|
|
|
end:
|
|
if (HR_FAILED(hResult))
|
|
{
|
|
*lppUserIdentityManager = NULL;
|
|
// Save the result
|
|
hResultSave = hResult;
|
|
} else
|
|
{
|
|
*lppUserIdentityManager = lpIAB->lpUserIdentityManager;
|
|
}
|
|
|
|
|
|
return(hResult);
|
|
}
|
|
|
|
|
|
//*******************************************************************
|
|
//
|
|
// FUNCTION: UninitUserIdentityManager
|
|
//
|
|
// PURPOSE: Release and unLoad the account manager
|
|
//
|
|
// PARAMETERS: none
|
|
//
|
|
// RETURNS: none
|
|
//
|
|
//*******************************************************************
|
|
void UninitUserIdentityManager(LPIAB lpIAB)
|
|
{
|
|
lpIAB->cIdentInit--;
|
|
if (lpIAB->lpUserIdentityManager && lpIAB->cIdentInit==0) {
|
|
#ifdef DEBUG
|
|
DWORD dwTickCount = GetTickCount();
|
|
DebugTrace( TEXT(">>>>> Uninitializing Account Manager...\n"));
|
|
#endif // DEBUG
|
|
|
|
lpIAB->lpUserIdentityManager->lpVtbl->Release(lpIAB->lpUserIdentityManager);
|
|
lpIAB->lpUserIdentityManager = NULL;
|
|
|
|
if (lpIAB->fCoInitUserIdentityManager)
|
|
CoUninitialize();
|
|
#ifdef DEBUG
|
|
DebugTrace( TEXT(">>>>> Done Uninitializing Account Manager... %u milliseconds\n"), GetTickCount() - dwTickCount);
|
|
#endif // DEBUG
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
- HrGetDefaultIdentityInfo
|
|
-
|
|
* Get's the hKey corresponding to the default identity
|
|
*/
|
|
HRESULT HrGetDefaultIdentityInfo(LPIAB lpIAB, ULONG ulFlags, HKEY * lphKey, LPTSTR lpProfileID, ULONG cchProfileID, LPTSTR lpName, ULONG cchName)
|
|
{
|
|
IUserIdentityManager * lpUserIdentityManager = NULL;
|
|
IUserIdentity * lpUserIdentity = NULL;
|
|
HRESULT hr = S_OK;
|
|
BOOL fInit = FALSE;
|
|
|
|
if(HR_FAILED(hr = InitUserIdentityManager(lpIAB, &lpUserIdentityManager)))
|
|
goto out;
|
|
|
|
fInit = TRUE;
|
|
|
|
Assert(lpUserIdentityManager);
|
|
|
|
if(HR_FAILED(hr = lpUserIdentityManager->lpVtbl->GetIdentityByCookie(lpUserIdentityManager,
|
|
(GUID *)&UID_GIBC_DEFAULT_USER,
|
|
&lpUserIdentity)))
|
|
goto out;
|
|
|
|
Assert(lpUserIdentity);
|
|
|
|
if(ulFlags & DEFAULT_ID_HKEY && lphKey)
|
|
{
|
|
if(HR_FAILED(hr = lpUserIdentity->lpVtbl->OpenIdentityRegKey(lpUserIdentity,
|
|
KEY_ALL_ACCESS,
|
|
lphKey)))
|
|
goto out;
|
|
}
|
|
if(ulFlags & DEFAULT_ID_PROFILEID && lpProfileID)
|
|
{
|
|
GUID guidCookie = {0};
|
|
TCHAR sz[MAX_PATH];
|
|
// update this key for the account manager
|
|
if(HR_FAILED(hr = lpUserIdentity->lpVtbl->GetCookie(lpUserIdentity, &guidCookie)))
|
|
goto out;
|
|
if(HR_FAILED(hr = HrGetUserProfileID(&guidCookie, sz, CharSizeOf(sz))))
|
|
goto out;
|
|
StrCpyN(lpProfileID, sz, cchProfileID);
|
|
}
|
|
if(ulFlags & DEFAULT_ID_NAME && lpName && lpProfileID)
|
|
{
|
|
if(HR_FAILED(hr = HrGetIdentityName(lpIAB, lpProfileID, lpName, cchName)))
|
|
goto out;
|
|
}
|
|
|
|
out:
|
|
if(lpUserIdentity)
|
|
lpUserIdentity->lpVtbl->Release(lpUserIdentity);
|
|
|
|
if(fInit)
|
|
UninitUserIdentityManager(lpIAB);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
- HrGetIdentityName
|
|
-
|
|
* Gets the name string corresponding to the current user unless a specific profile ID is specified
|
|
* (which is nothing but a string version of the GUID to use)
|
|
* szName - buffer long enough for the user name (CCH_IDENTITY_NAME_MAX_LENGTH)
|
|
*/
|
|
HRESULT HrGetIdentityName(LPIAB lpIAB, LPTSTR lpID, LPTSTR szUserName, ULONG cchUserName)
|
|
{
|
|
IUserIdentityManager * lpUserIdentityManager = NULL;
|
|
IUserIdentity * lpUserIdentity = NULL;
|
|
WCHAR szNameW[CCH_IDENTITY_NAME_MAX_LENGTH];
|
|
TCHAR szName[CCH_IDENTITY_NAME_MAX_LENGTH];
|
|
HRESULT hr = S_OK;
|
|
GUID guidCookie = {0};
|
|
BOOL fInit = FALSE;
|
|
|
|
if(!lpID && !bAreWABAPIProfileAware(lpIAB))
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = InitUserIdentityManager(lpIAB, &lpUserIdentityManager)))
|
|
goto out;
|
|
|
|
fInit = TRUE;
|
|
|
|
Assert(lpUserIdentityManager);
|
|
|
|
if(lpIAB && !lpID)
|
|
memcpy(&guidCookie, &lpIAB->guidCurrentUser, sizeof(GUID));
|
|
else
|
|
{
|
|
if( (HR_FAILED(hr = CLSIDFromString(lpID, &guidCookie))) )
|
|
goto out;
|
|
}
|
|
|
|
if(HR_FAILED(hr = lpUserIdentityManager->lpVtbl->GetIdentityByCookie(lpUserIdentityManager, &guidCookie, &lpUserIdentity)))
|
|
goto out;
|
|
|
|
Assert(lpUserIdentity);
|
|
|
|
if(HR_FAILED(hr = lpUserIdentity->lpVtbl->GetName(lpUserIdentity, szNameW, CharSizeOf(szNameW))))
|
|
goto out;
|
|
StrCpyN(szName, szNameW, ARRAYSIZE(szName));
|
|
|
|
if(!lstrcmp(szUserName, szName))
|
|
{
|
|
hr = E_FAIL;
|
|
goto out;
|
|
}
|
|
|
|
StrCpyN(szUserName, szName, cchUserName);
|
|
|
|
out:
|
|
if(fInit)
|
|
UninitUserIdentityManager(lpIAB);
|
|
|
|
if(lpUserIdentity)
|
|
lpUserIdentity->lpVtbl->Release(lpUserIdentity);
|
|
|
|
if(HR_FAILED(hr))
|
|
szUserName[0] = TEXT('\0');
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
/*
|
|
- HrGetUserProfileID
|
|
-
|
|
* Gets the profile string corresponding to the current user
|
|
* The profile ID is nothing but a string represenatation of the user's Cookie (GUID)
|
|
*
|
|
* szProfileID - buffer long enough for the user name
|
|
*/
|
|
HRESULT HrGetUserProfileID(LPGUID lpguidUser, LPTSTR szProfileID, ULONG cbProfileID)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
LPOLESTR lpszW= 0 ;
|
|
|
|
if (HR_FAILED(hr = StringFromCLSID(lpguidUser, &lpszW)))
|
|
goto out;
|
|
|
|
StrCpyN(szProfileID,(LPCWSTR)lpszW,cbProfileID);
|
|
|
|
out:
|
|
if (lpszW)
|
|
{
|
|
LPMALLOC pMalloc = NULL;
|
|
CoGetMalloc(1, &pMalloc);
|
|
if (pMalloc) {
|
|
pMalloc->lpVtbl->Free(pMalloc, lpszW);
|
|
pMalloc->lpVtbl->Release(pMalloc);
|
|
}
|
|
}
|
|
if(HR_FAILED(hr))
|
|
szProfileID[0] = TEXT('\0');
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
-
|
|
- HrLogonAndGetCurrentUserProfile - Inits the User Identity Manger and calls into the Logon ..
|
|
- Gets a user, either by showing UI or getting the current user and then gets a
|
|
- profile ID ( TEXT("Cookie")) for that user ..
|
|
*
|
|
* bForceUI - forces the Logon dialog so user can switch users .. TRUE only when user wants to switch
|
|
*
|
|
* bSwitchUser - True only after user has switched .. tells us to refresh and get details ont he new user
|
|
*
|
|
*/
|
|
HRESULT HrLogonAndGetCurrentUserProfile(HWND hWndParent, LPIAB lpIAB, BOOL bForceUI, BOOL bSwitchUser)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
IUserIdentityManager * lpUserIdentityManager = NULL;
|
|
IUserIdentity * lpUserIdentity = NULL;
|
|
GUID guidCookie = {0};
|
|
BOOL fInit = FALSE;
|
|
if(!bAreWABAPIProfileAware(lpIAB))
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = InitUserIdentityManager(lpIAB, &lpUserIdentityManager)))
|
|
goto out;
|
|
|
|
fInit = TRUE;
|
|
|
|
Assert(lpUserIdentityManager);
|
|
|
|
// Logon will get the currently logged on user, or if there is a single user, it will return
|
|
// that user, or if there are multiple users, it will prompt for a logon
|
|
//
|
|
if(!bSwitchUser)
|
|
{
|
|
hr = lpUserIdentityManager->lpVtbl->Logon(lpUserIdentityManager,
|
|
hWndParent,
|
|
bForceUI ? UIL_FORCE_UI : 0,
|
|
&lpUserIdentity);
|
|
|
|
#ifdef NEED
|
|
if(hr == S_IDENTITIES_DISABLED)
|
|
hr = E_FAIL;
|
|
#endif
|
|
|
|
if(HR_FAILED(hr))
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
// just switching users, thats all
|
|
if(HR_FAILED(hr = lpUserIdentityManager->lpVtbl->GetIdentityByCookie(lpUserIdentityManager,
|
|
(GUID *)&UID_GIBC_CURRENT_USER,
|
|
&lpUserIdentity)))
|
|
goto out;
|
|
|
|
}
|
|
|
|
Assert(lpUserIdentity);
|
|
|
|
if(lpIAB->hKeyCurrentUser)
|
|
RegCloseKey(lpIAB->hKeyCurrentUser);
|
|
|
|
// get the identity's hkey for the wab
|
|
if(HR_FAILED(hr = lpUserIdentity->lpVtbl->OpenIdentityRegKey(lpUserIdentity, KEY_ALL_ACCESS, &lpIAB->hKeyCurrentUser)))
|
|
goto out;
|
|
|
|
// get anothor one for the account manager (it will free it)
|
|
if(HR_FAILED(hr = lpUserIdentity->lpVtbl->GetCookie(lpUserIdentity, &guidCookie)))
|
|
goto out;
|
|
else
|
|
{
|
|
IImnAccountManager2 * lpAccountManager = NULL;
|
|
// [PaulHi] 1/13/99 Changed to initialize the account manager with
|
|
// user guid cookie inside the InitAccountManager() function.
|
|
InitAccountManager(lpIAB, &lpAccountManager, &guidCookie);
|
|
}
|
|
|
|
if(!memcmp(&lpIAB->guidCurrentUser, &guidCookie, sizeof(GUID)))
|
|
{
|
|
//current user is identical to the one we have so don't update anything here
|
|
return S_OK;
|
|
}
|
|
|
|
memcpy(&lpIAB->guidCurrentUser, &guidCookie, sizeof(GUID));
|
|
|
|
lpIAB->szProfileID[0] = TEXT('\0');
|
|
lpIAB->szProfileName[0] = TEXT('\0');
|
|
|
|
HrGetIdentityName(lpIAB, NULL, lpIAB->szProfileName, ARRAYSIZE(lpIAB->szProfileName));
|
|
HrGetUserProfileID(&lpIAB->guidCurrentUser, lpIAB->szProfileID, CharSizeOf(lpIAB->szProfileID));
|
|
/*
|
|
//register for changes
|
|
if( !bSwitchUser && !bForceUI && !lpIAB->lpWABIDCN
|
|
//&& !memcmp(&lpIAB->guidPSExt, &MPSWab_GUID_V4, sizeof(GUID))
|
|
) // register for notifications only if this is the WAB.exe process
|
|
{
|
|
HrRegisterUnregisterForIDNotifications( lpIAB, TRUE);
|
|
}
|
|
*/
|
|
out:
|
|
if(fInit)
|
|
UninitUserIdentityManager(lpIAB);
|
|
|
|
if(lpUserIdentity)
|
|
lpUserIdentity->lpVtbl->Release(lpUserIdentity);
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/*
|
|
- HRESULT HrRegisterUnregisterForIDNotifications()
|
|
-
|
|
* Creates/Releases a WABIDENTITYCHANGENOTIFY object
|
|
*
|
|
*/
|
|
HRESULT HrRegisterUnregisterForIDNotifications( LPIAB lpIAB, BOOL bRegister)
|
|
{
|
|
|
|
HRESULT hr = S_OK;
|
|
IUserIdentityManager * lpUserIdentityManager = NULL;
|
|
IConnectionPoint * lpConnectionPoint = NULL;
|
|
BOOL fInit = FALSE;
|
|
|
|
// Need to register for notifications even if running under Outlook
|
|
// Assume that relevant tests have occured before this is called ....
|
|
// if(bRegister && !bAreWABAPIProfileAware(lpIAB))
|
|
// goto out;
|
|
|
|
if( (!bRegister && !lpIAB->lpWABIDCN) ||
|
|
(bRegister && lpIAB->lpWABIDCN) )
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = InitUserIdentityManager(lpIAB, &lpUserIdentityManager)))
|
|
goto out;
|
|
|
|
fInit = TRUE;
|
|
|
|
Assert(lpUserIdentityManager);
|
|
|
|
if(HR_FAILED(hr = lpUserIdentityManager->lpVtbl->QueryInterface(lpUserIdentityManager,
|
|
&IID_IConnectionPoint,
|
|
(LPVOID *)&lpConnectionPoint)))
|
|
goto out;
|
|
|
|
if(bRegister)
|
|
{
|
|
if(lpIAB->lpWABIDCN)
|
|
{
|
|
lpIAB->lpWABIDCN->lpVtbl->Release(lpIAB->lpWABIDCN);
|
|
lpIAB->lpWABIDCN = NULL;
|
|
}
|
|
|
|
if(HR_FAILED(hr = HrCreateIdentityChangeNotifyObject(lpIAB, &lpIAB->lpWABIDCN)))
|
|
goto out;
|
|
|
|
if(HR_FAILED(hr = lpConnectionPoint->lpVtbl->Advise(lpConnectionPoint, (LPUNKNOWN) lpIAB->lpWABIDCN, &lpIAB->dwWABIDCN)))
|
|
goto out;
|
|
}
|
|
else
|
|
{
|
|
if(lpIAB->lpWABIDCN)
|
|
{
|
|
if(HR_FAILED(hr = lpConnectionPoint->lpVtbl->Unadvise(lpConnectionPoint, lpIAB->dwWABIDCN)))
|
|
goto out;
|
|
lpIAB->dwWABIDCN = 0;
|
|
lpIAB->lpWABIDCN->lpVtbl->Release(lpIAB->lpWABIDCN);
|
|
lpIAB->lpWABIDCN = NULL;
|
|
}
|
|
}
|
|
out:
|
|
if(fInit)
|
|
UninitUserIdentityManager(lpIAB);
|
|
|
|
if(lpConnectionPoint)
|
|
lpConnectionPoint->lpVtbl->Release(lpConnectionPoint);
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*--------------------------------------------------------------------------------------------------*/
|
|
|
|
WAB_IDENTITYCHANGENOTIFY_Vtbl vtblWABIDENTITYCHANGENOTIFY = {
|
|
VTABLE_FILL
|
|
WAB_IDENTITYCHANGENOTIFY_QueryInterface,
|
|
WAB_IDENTITYCHANGENOTIFY_AddRef,
|
|
WAB_IDENTITYCHANGENOTIFY_Release,
|
|
WAB_IDENTITYCHANGENOTIFY_QuerySwitchIdentities,
|
|
WAB_IDENTITYCHANGENOTIFY_SwitchIdentities,
|
|
WAB_IDENTITYCHANGENOTIFY_IdentityInformationChanged
|
|
};
|
|
|
|
/*
|
|
- HrCreateIdentityChangeNotifyObject
|
|
-
|
|
* The ChangeNotificationObject is created only on the LPIAB object and on the
|
|
* main browse window. Depending on where it's called from, we will pass in either the
|
|
* lpIAB pointer or the hWnd of the Window.
|
|
* THen when we get the callback notification, we can figure out what we want to do
|
|
* based on which of the 2 are available to us ..
|
|
*
|
|
*/
|
|
HRESULT HrCreateIdentityChangeNotifyObject(LPIAB lpIAB, LPWABIDENTITYCHANGENOTIFY * lppWABIDCN)
|
|
{
|
|
LPWABIDENTITYCHANGENOTIFY lpIWABIDCN = NULL;
|
|
SCODE sc;
|
|
HRESULT hr = hrSuccess;
|
|
|
|
//
|
|
// Allocate space for the IAB structure
|
|
//
|
|
if (FAILED(sc = MAPIAllocateBuffer(sizeof(WABIDENTITYCHANGENOTIFY), (LPVOID *) &lpIWABIDCN)))
|
|
{
|
|
hr = ResultFromScode(sc);
|
|
goto err;
|
|
}
|
|
|
|
MAPISetBufferName(lpIWABIDCN, TEXT("WAB IdentityChangeNotify Object"));
|
|
|
|
ZeroMemory(lpIWABIDCN, sizeof(WABIDENTITYCHANGENOTIFY));
|
|
|
|
lpIWABIDCN->lpVtbl = &vtblWABIDENTITYCHANGENOTIFY;
|
|
|
|
lpIWABIDCN->lpIAB = lpIAB;
|
|
|
|
lpIWABIDCN->lpVtbl->AddRef(lpIWABIDCN);
|
|
|
|
*lppWABIDCN = lpIWABIDCN;
|
|
|
|
return(hrSuccess);
|
|
|
|
err:
|
|
|
|
FreeBufferAndNull(&lpIWABIDCN);
|
|
return(hr);
|
|
}
|
|
|
|
void ReleaseWABIdentityChangeNotifyObj(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN)
|
|
{
|
|
MAPIFreeBuffer(lpIWABIDCN);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
WAB_IDENTITYCHANGENOTIFY_AddRef(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN)
|
|
{
|
|
return(++(lpIWABIDCN->lcInit));
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG)
|
|
WAB_IDENTITYCHANGENOTIFY_Release(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN)
|
|
{
|
|
ULONG ulc = (--(lpIWABIDCN->lcInit));
|
|
if(ulc==0)
|
|
ReleaseWABIdentityChangeNotifyObj(lpIWABIDCN);
|
|
return(ulc);
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
WAB_IDENTITYCHANGENOTIFY_QueryInterface(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN,
|
|
REFIID lpiid,
|
|
LPVOID * lppNewObj)
|
|
{
|
|
LPVOID lp = NULL;
|
|
|
|
if(!lppNewObj)
|
|
return MAPI_E_INVALID_PARAMETER;
|
|
|
|
*lppNewObj = NULL;
|
|
|
|
if(IsEqualIID(lpiid, &IID_IUnknown))
|
|
lp = (LPVOID) lpIWABIDCN;
|
|
|
|
if(IsEqualIID(lpiid, &IID_IIdentityChangeNotify))
|
|
lp = (LPVOID) lpIWABIDCN;
|
|
|
|
if(!lp)
|
|
return E_NOINTERFACE;
|
|
|
|
((LPWABIDENTITYCHANGENOTIFY) lp)->lpVtbl->AddRef((LPWABIDENTITYCHANGENOTIFY) lp);
|
|
|
|
*lppNewObj = lp;
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
WAB_IDENTITYCHANGENOTIFY_QuerySwitchIdentities(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DebugTrace( TEXT("WAB: IDChangeNotify::QuerySwitchIdentities: 0x%.8x\n"), GetCurrentThreadId());
|
|
if(lpIWABIDCN->lpIAB->hWndBrowse)
|
|
{
|
|
// if this relates to a window, then just make sure that the window is not deactivated
|
|
// because that would imply that the window has a dialog in front of it.
|
|
if (!IsWindowEnabled(lpIWABIDCN->lpIAB->hWndBrowse))
|
|
{
|
|
Assert(IsWindowVisible(lpIWABIDCN->lpIAB->hWndBrowse));
|
|
return E_PROCESS_CANCELLED_SWITCH;
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// MAJOR HACK WARNING
|
|
// [PaulHi] 12/22/98 See comment below. We need to disable the "close WAB window
|
|
// on identity switch for when the client is OE5. We don't want to change this code
|
|
// at this point for other clients. I copied the OE5 PSExt GUID from the OE5 code
|
|
// base.
|
|
static const GUID OEBAControl_GUID =
|
|
{ 0x233a9694, 0x667e, 0x11d1, { 0x9d, 0xfb, 0x00, 0x60, 0x97, 0xd5, 0x04, 0x08 } };
|
|
|
|
|
|
STDMETHODIMP
|
|
WAB_IDENTITYCHANGENOTIFY_SwitchIdentities(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DebugTrace( TEXT("WAB: IDChangeNotify::SwitchIdentities: 0x%.8x\n"), GetCurrentThreadId());
|
|
|
|
if(memcmp(&lpIWABIDCN->lpIAB->guidPSExt, &MPSWab_GUID_V4, sizeof(GUID)) ) //if not a wab.exe process .. shutdown
|
|
{
|
|
// [PaulHi] 12/22/98 Raid #63231, 48054
|
|
// Don't close the WAB window here when OE is the host. OE needs to shut
|
|
// down the WAB in the correct order during identity switches or serious problems occur.
|
|
if ( memcmp(&lpIWABIDCN->lpIAB->guidPSExt, &OEBAControl_GUID , sizeof(GUID)) != 0 )
|
|
SendMessage(lpIWABIDCN->lpIAB->hWndBrowse, WM_CLOSE, 0, 0);
|
|
return S_OK;
|
|
}
|
|
if(!HR_FAILED(HrLogonAndGetCurrentUserProfile(NULL, lpIWABIDCN->lpIAB, FALSE, TRUE)))
|
|
HrGetWABProfiles(lpIWABIDCN->lpIAB);
|
|
else //they did a logoff
|
|
{
|
|
SendMessage(lpIWABIDCN->lpIAB->hWndBrowse, WM_CLOSE, 0, 0);
|
|
return S_OK;
|
|
}
|
|
|
|
if(lpIWABIDCN->lpIAB->hWndBrowse) //hWndBrowse could be any window (main or find)
|
|
SendMessage(lpIWABIDCN->lpIAB->hWndBrowse, WM_COMMAND, (WPARAM) IDM_NOTIFY_REFRESHUSER, 0);
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP
|
|
WAB_IDENTITYCHANGENOTIFY_IdentityInformationChanged(LPWABIDENTITYCHANGENOTIFY lpIWABIDCN, DWORD dwType)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DebugTrace( TEXT("WAB: IDChangeNotify::IdentityInformationChanged: %d 0x%.8x\n"), dwType, GetCurrentThreadId());
|
|
if(dwType == IIC_CURRENT_IDENTITY_CHANGED)
|
|
{
|
|
// only thing we care about is a change in the name
|
|
if(!HR_FAILED(HrGetIdentityName(lpIWABIDCN->lpIAB, NULL, lpIWABIDCN->lpIAB->szProfileName, ARRAYSIZE(lpIWABIDCN->lpIAB->szProfileName))))
|
|
{
|
|
UpdateCurrentUserFolderName(lpIWABIDCN->lpIAB);
|
|
if(lpIWABIDCN->lpIAB->hWndBrowse)
|
|
SendMessage(lpIWABIDCN->lpIAB->hWndBrowse, WM_COMMAND, (WPARAM) IDM_NOTIFY_REFRESHUSER, 0);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|