able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/admt/workobj/exchange.cpp

1644 lines
50 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "stdafx.h"
#include "exchange.hpp"
#include "common.hpp"
#include "err.hpp"
#include "ErrDct.hpp"
#include "UString.hpp"
#include "sidcache.hpp"
#include "sd.hpp"
#include "SecObj.hpp"
#include "MAPIProf.hpp"
#include "exldap.h"
#include "Mcs.h"
extern TErrorDct err;
#define NOT_PT_ERROR(x) ( PROP_TYPE(x.ulPropTag) != PT_ERROR )
#define LDAP_PortNumber_DN_Part L"/cn=Protocols/cn=LDAP"
#define ATT_OBJ_CLASS L"Obj-Class"
#define ATT_DIST_NAME L"Obj-Dist-Name"
#define ATT_LDAP_PORT L"Port-Number"
#define LDAP_USE_SITE_VALUES L"Use-Site-Values"
// Stuff related to dynamic loading of DAPI.DLL
HINSTANCE hDapi = NULL;
LPDAPISTART pDAPIStart = NULL;
LPDAPIEND pDAPIEnd = NULL;
LPDAPIREAD pDAPIRead = NULL;
LPDAPIWRITE pDAPIWrite = NULL;
LPDAPIFREEMEMORY pDAPIFreeMemory = NULL;
LPBATCHEXPORT pBatchExport = NULL;
BOOL LoadDAPI()
{
BOOL success = TRUE;
if ( ! hDapi )
{
success = FALSE;
hDapi = LoadLibrary(_T("DAPI.DLL"));
if ( hDapi )
{
do { // once
pDAPIStart = (LPDAPISTART)GetProcAddress(hDapi,"DAPIStartW@8");
if ( ! pDAPIStart )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIStart");
break;
}
pDAPIEnd = (LPDAPIEND)GetProcAddress(hDapi,"DAPIEnd@4");
if ( ! pDAPIEnd )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIEnd");
break;
}
pDAPIRead = (LPDAPIREAD)GetProcAddress(hDapi,"DAPIReadW@24");
if ( ! pDAPIRead )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIRead");
break;
}
pDAPIWrite = (LPDAPIWRITE)GetProcAddress(hDapi,"DAPIWriteW@28");
if ( ! pDAPIWrite )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIWrite");
break;
}
pDAPIFreeMemory = (LPDAPIFREEMEMORY)GetProcAddress(hDapi,"DAPIFreeMemory@4");
if ( ! pDAPIFreeMemory )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"DAPIFreeMemory");
break;
}
pBatchExport = (LPBATCHEXPORT)GetProcAddress(hDapi,"BatchExportA@4");
if ( ! pBatchExport )
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_ENTRY_POINT_NOT_FOUND_S,L"BatchExport");
break;
}
success = TRUE;
} while (false);
}
else
{
err.MsgWrite(ErrE,DCT_MSG_DAPI_LOAD_LIBRARY_FAILED);
}
}
if ( ! success )
{
ReleaseDAPI();
}
return success;
}
void ReleaseDAPI()
{
if ( hDapi )
{
FreeLibrary(hDapi);
hDapi = NULL;
pDAPIStart = NULL;
pDAPIEnd = NULL;
pDAPIRead = NULL;
pDAPIWrite = NULL;
pDAPIFreeMemory = NULL;
pBatchExport = NULL;
}
}
TGlobalDirectory::TGlobalDirectory()
{
m_stat = NULL;
m_bUseDefaultMapiProfile = FALSE; // Whether to use MAPI profile listed in Registry.
m_bPromptForMapiProfile = TRUE; // Whether to prompt for MAPI profile.
m_pszMapiProfile = NULL; // MAPI profile to use.
// MAPI
m_bMapiInitialized = FALSE; // TRUE if initialization was successful.
m_pMapiSession = NULL; // MAPI session handle.
m_pAdrBook = NULL; // The master AB.
m_pGlobalList = NULL;
m_pGlobalTable = NULL;
m_pGlobalPropertyTags = NULL;
m_pGlobalRows = NULL;
m_pRootRows = NULL;
m_pContainer = NULL;
m_pContainerTable = NULL;
}
TGlobalDirectory::~TGlobalDirectory()
{
delete [] m_pszMapiProfile;
CloseGlobalList();
EndMapiSession();
}
LPTSTR TGlobalDirectory::GetMapiProfile() const
{
return m_pszMapiProfile;
}
BOOL TGlobalDirectory::DoUseDefaultMapiProfile() const
{
return m_bUseDefaultMapiProfile;
}
BOOL TGlobalDirectory::DoPromptForMapiProfile() const
{
return m_bPromptForMapiProfile;
}
///////////////////////////////////////////////////////////////////////////////
// Log a MAPI warning or error.
void
TGlobalDirectory::LogMapiError(
int iSeverity, // in - Severity (i.e. ErrW, ErrE, etc)
LPCTSTR pszEntryPoint, // in - API that generated the error
HRESULT hr // in - error code
)
{
if (hr != 0)
err.MsgWrite(iSeverity,DCT_MSG_GENERIC_HRESULT_SD, pszEntryPoint, hr);
else
err.MsgWrite(iSeverity,DCT_MSG_GENERIC_S, pszEntryPoint);
}
void
TGlobalDirectory::LogDapiError(
int iSeverity, // in - severity of error (i.e. ErrW, ErrE, etc.)
LPCTSTR pszUserMessage, // in - message describing the action that failed
DAPI_EVENT * pResult // in - DAPIEvent error structure returned from Exchange
)
{
WCHAR strMsg[1000];
DWORD dimMsg = DIM(strMsg);
DWORD lenMsg;
DAPI_EVENT * pEvt;
WCHAR msg[2000];
if ( !pResult )
return;
safecopy(msg,pszUserMessage);
for ( pEvt = pResult ; pEvt ; pEvt = pEvt->pNextEvent )
{
strMsg[0] = 0;
lenMsg = FormatMessageW(
FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
pEvt->hinstDAPI,
pEvt->dwDAPIError,
0,
strMsg,
dimMsg,
(va_list*)pEvt->rgpszSubst
);
UStrCpy(msg+UStrLen(msg),strMsg,DIM(msg)-UStrLen(msg));
}
err.MsgWrite(iSeverity,DCT_MSG_GENERIC_S,&*msg);
}
///////////////////////////////////////////////////////////////////////////////
// Start a MAPI session.
// Tries to use the profile specified on the command line.
BOOL TGlobalDirectory::StartMapiSession()
{
//ASSERT(m_bMapiInitialized == FALSE);
MCSASSERT(m_pMapiSession == NULL);
HRESULT hr;
if ( !m_bMapiInitialized )
{
hr = (*pMAPIInitialize)(NULL);
if (FAILED(hr))
{
LogMapiError(ErrE, TEXT("MAPIInitialize"), hr);
return FALSE;
}
m_bMapiInitialized = TRUE;
}
FLAGS fLogonOptions = MAPI_NEW_SESSION | MAPI_NO_MAIL;
LPTSTR pszMapiProfile;
if (DoUseDefaultMapiProfile()) {
fLogonOptions |= MAPI_USE_DEFAULT;
pszMapiProfile = NULL;
}
else if (DoPromptForMapiProfile()) {
fLogonOptions |= MAPI_LOGON_UI | MAPI_EXPLICIT_PROFILE;
pszMapiProfile = NULL;
}
else {
fLogonOptions |= MAPI_EXPLICIT_PROFILE ;
pszMapiProfile = GetMapiProfile();
}
hr = (*pMAPILogonEx)(0, pszMapiProfile, NULL, fLogonOptions | MAPI_UNICODE, &m_pMapiSession);
if (FAILED(hr)) {
switch (hr) {
case MAPI_E_USER_CANCEL:
break;
default:
err.SysMsgWrite(ErrE,hr,DCT_MSG_NO_MAPI_SESSION_D,hr);
break;
}
return FALSE;
}
m_bLoggedFailedClose = FALSE;
return TRUE;
} /* TGlobalDirectory::StartMapiSession() */
///////////////////////////////////////////////////////////////////////////////
// Terminate a MAPI session.
// No-op if there's not one open.
void TGlobalDirectory::EndMapiSession()
{
if (m_pMapiSession) {
HRESULT hr = m_pMapiSession->Logoff(0, 0, 0);
if (SUCCEEDED(hr))
m_pMapiSession = NULL;
else if (!m_bLoggedFailedClose) {
err.SysMsgWrite(ErrW,hr,DCT_MSG_MAPI_LOGOFF_FAILED_D,hr);
}
// NOTE: If this fails once, it may fail twice.
// The second failure will come on the dtor.
// This is on purpose. It's a retry. But we report it only once.
}
if (m_bMapiInitialized)
{
(*pMAPIUninitialize)();
m_bMapiInitialized = FALSE;
}
} /* TGlobalDirectory::EndMapiSession() */
///////////////////////////////////////////////////////////////////////////////
// Open the Address Book and get an interface to the Global List.
// The Global List contains the Distribution Lists.
BOOL TGlobalDirectory::OpenGlobalList()
{
// Open the Address Book.
if ( ! m_pMapiSession )
return FALSE;
HRESULT hr = m_pMapiSession->OpenAddressBook(0, NULL, AB_NO_DIALOG , &m_pAdrBook);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_NO_ADDRBOOK_D,hr);
return FALSE;
}
// Get the GAL entry ID.
ULONG cbEntryId;
LPENTRYID pEntryId;
hr = HrFindExchangeGlobalAddressList(m_pAdrBook, &cbEntryId, &pEntryId);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_OPEN_GAL_D,hr);
return FALSE;
}
// Load the GAL from the AB.
ULONG ulObjType;
hr = m_pAdrBook->OpenEntry(cbEntryId, pEntryId, NULL, 0, &ulObjType, (LPUNKNOWN*)&m_pGlobalList);
(*pMAPIFreeBuffer)(pEntryId);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_RETRIEVE_GAL_FAILED_D,hr);
return FALSE;
}
// Get a list of the contents of the Global List.
hr = m_pGlobalList->GetContentsTable(0, &m_pGlobalTable);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_RETRIEVE_GAL_FAILED_D,hr);
return FALSE;
}
return TRUE;
} /* TEaSyncCommand::OpenGlobalList() */
///////////////////////////////////////////////////////////////////////////////
// Release the interfaces to the Global List and the Address Book.
void TGlobalDirectory::CloseGlobalList()
{
if (m_pGlobalTable != NULL)
{
m_pGlobalTable->Release();
m_pGlobalTable = NULL;
}
if (m_pGlobalList != NULL)
{
m_pGlobalList->Release();
m_pGlobalList = NULL;
}
if (m_pAdrBook != NULL)
{
m_pAdrBook->Release();
m_pAdrBook = NULL;
}
} /* TGlobalDirectory::CloseGlobalList() */
BOOL
TGlobalDirectory::UpdateEntry(
LPMAPIPROP pUserEntry, // in - interface to mail recipient object
ULONG ulType, // in - type of object
SecurityTranslatorArgs * args // in - translation settings
)
{
// Prepare to get the columns that interest us.
// For DCT, we probably only care about ASSOC_NT_ACCOUNT, and possibly PR_EMS_AB_NT_SECURITY_DESCRIPTOR
HRESULT hr;
BOOL anychange = FALSE;
BOOL verbose = args->LogVerbose();
MCSASSERT(pUserEntry);
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
SizedSPropTagArray(5, oPropertiesToGet) =
{
5,
{
PR_DISPLAY_NAME,
PR_EMS_AB_ASSOC_NT_ACCOUNT, // SID
PR_ENTRYID,
PR_EMS_AB_NT_SECURITY_DESCRIPTOR, // SD
PR_DISPLAY_TYPE
}
};
ULONG ulPropsReturned = 0;
LPSPropValue pUserProperties = NULL;
hr = pUserEntry->GetProps((SPropTagArray *)&oPropertiesToGet,
0, &ulPropsReturned, &pUserProperties);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_SECURITY_FOR_RECIP_FAILED_D,hr);
pUserEntry->Release();
pUserEntry = NULL;
return FALSE;
}
if (ulPropsReturned != oPropertiesToGet.cValues)
{
err.MsgWrite(ErrE,DCT_MSG_GET_SECURITY_FOR_RECIP_FAILED_D,hr);
pUserEntry->Release();
pUserEntry = NULL;
return FALSE;
}
// 1. Translate the PR_EMS_AB_ASSOC_NT_ACCOUNT property
WCHAR name[MAX_PATH];
safecopy(name,pUserProperties[0].Value.lpszW);
if ( m_stat )
{
m_stat->DisplayPath(name);
m_stat->IncrementExamined(mailbox);
}
PISID pSid = (PISID)pUserProperties[1].Value.bin.lpb;
if (pSid != NULL)
{
LPSPropValue pNewPropValues = NULL;
LPSPropProblemArray pProblems = NULL;
// check if the sid is one we need to change
//TRACE (_T("DisplayName = %s "),pUserProperties[0].Value.lpszW);
PSID newSid = 0;
TAcctNode * node;
if ( IsValidSid(pSid) )
{
node = args->Cache()->Lookup(pSid);
if ( m_stat )
{
m_stat->IncrementOwnerExamined();
if ( verbose )
err.MsgWrite(0,DCT_MSG_EXAMINED_S,pUserProperties[0].Value.lpszW);
}
if ( node == (TAcctNode*)-1 && m_stat )
m_stat->IncrementOwnerNoTarget();
if ( node && (node != (TAcctNode *)-1) && node->IsValidOnTgt() )
newSid = args->Cache()->GetTgtSid(node);
else
newSid = NULL;
}
else
{
newSid = NULL;
}
if ( newSid )
{
//TRACE (_T("needs to be translated\n"));
// update the entry, or maybe put it into a list of entries to be updated
// Allocate a buffer to set the property.
MCSASSERT ( IsValidSid(newSid) );
PSID pMapiSid;
DWORD dwSidLength = GetLengthSid(newSid);
hr = ResultFromScode((*pMAPIAllocateBuffer)((sizeof SPropValue) * 1, (void **)&pNewPropValues));
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
goto exit_update_sid;
}
// Allocate a buffer for the SID
hr = ResultFromScode((*pMAPIAllocateBuffer)(dwSidLength, (void **)&pMapiSid));
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
goto exit_update_sid;
}
// Copy the SID.
CopySid(dwSidLength,pMapiSid,newSid);
// Write the SID
pNewPropValues[0].ulPropTag = PR_EMS_AB_ASSOC_NT_ACCOUNT;
pNewPropValues[0].Value.bin.lpb = (UCHAR *)pMapiSid;
pNewPropValues[0].Value.bin.cb = dwSidLength;
MCSASSERT (IsValidSid (pMapiSid) );
if ( m_stat )
{
m_stat->IncrementOwnerChange(node,mailbox,NULL);
}
anychange = TRUE;
if ( ! args->NoChange() )
{
hr = pUserEntry->SetProps(1, pNewPropValues, &pProblems);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_UPDATE_ACCOUNT_FAILED_D, hr);
pProblems = NULL; // Don't try to free this if SetProps fails.
goto exit_update_sid;
}
// Save changes.
hr = pUserEntry->SaveChanges(KEEP_OPEN_READWRITE);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_SAVE_CHANGES_FAILED_D, hr);
goto exit_update_sid;
}
}
exit_update_sid:
if (pMapiSid != NULL)
(*pMAPIFreeBuffer)(pMapiSid);
if (pProblems != NULL)
(*pMAPIFreeBuffer)(pProblems);
if (pNewPropValues != NULL)
(*pMAPIFreeBuffer)(pNewPropValues);
}
}
// 2. Translate the PR_EMS_AB_NT_SECURITY_DESCRIPTOR property
PSECURITY_DESCRIPTOR pSD = (PSECURITY_DESCRIPTOR)pUserProperties[3].Value.bin.lpb;
if ( pSD && PR_EMS_AB_NT_SECURITY_DESCRIPTOR == pUserProperties[3].ulPropTag )
{
TMapiSD tMailbox((SECURITY_DESCRIPTOR *)pSD);
tMailbox.SetName(pUserProperties[0].Value.lpszW);
if ( tMailbox.HasSecurity() )
{
TSD * pSD = tMailbox.GetSecurity();
bool changes = tMailbox.ResolveSDInternal(args->Cache(),m_stat,verbose,args->TranslationMode(),mailbox, FALSE);
if ( changes )
{
anychange = TRUE;
// need to write the changes
LPSPropValue pNewPropValues = NULL;
LPSPropProblemArray pProblems = NULL;
// update the entry
// Allocate a buffer to set the property.
SECURITY_DESCRIPTOR * pMapiSD;
SECURITY_DESCRIPTOR * pRelSD = (SECURITY_DESCRIPTOR *)pSD->MakeRelSD();
DWORD dwSDLength = GetSecurityDescriptorLength(pRelSD);
if ( ! pRelSD )
{
goto exit_update_sd;
}
hr = ResultFromScode((*pMAPIAllocateBuffer)((sizeof SPropValue) * 1, (void **)&pNewPropValues));
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
goto exit_update_sd;
}
// Allocate a buffer for the SD
hr = ResultFromScode((*pMAPIAllocateBuffer)(dwSDLength, (void **)&pMapiSD));
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_FAILED_TO_ALLOCATE_BUFFER_D,hr);
goto exit_update_sd;
}
// Copy the SD.
memcpy(pMapiSD,pRelSD,dwSDLength );
// Write the SD
free(pRelSD);
pNewPropValues[0].ulPropTag = PR_EMS_AB_NT_SECURITY_DESCRIPTOR;
pNewPropValues[0].Value.bin.lpb = (UCHAR *)pMapiSD;
pNewPropValues[0].Value.bin.cb = dwSDLength;
if ( ! args->NoChange() )
{
hr = pUserEntry->SetProps(1, pNewPropValues, &pProblems);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_SD_WRITE_FAILED_SD,pUserProperties[0].Value.lpszW,hr);
pProblems = NULL; // Don't try to free this if SetProps fails.
goto exit_update_sd;
}
// Save changes.
hr = pUserEntry->SaveChanges(KEEP_OPEN_READONLY);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_SD_SAVE_FAILED_SD,pUserProperties[0].Value.lpszW,hr);
goto exit_update_sd;
}
}
exit_update_sd:
if (pMapiSD != NULL)
(*pMAPIFreeBuffer)(pMapiSD);
if (pProblems != NULL)
(*pMAPIFreeBuffer)(pProblems);
if (pNewPropValues != NULL)
(*pMAPIFreeBuffer)(pNewPropValues);
}
}
}
if ( anychange && m_stat )
{
m_stat->IncrementChanged(mailbox);
if ( args->LogFileDetails() )
err.MsgWrite(0,DCT_MSG_CHANGED_S,pUserProperties[0].Value.lpszW);
}
(*pMAPIFreeBuffer)(pUserProperties);
pUserProperties = NULL;
return TRUE;
}
BOOL
TGlobalDirectory::Scan(
SecurityTranslatorArgs * args, // in - translation settings
WCHAR const * container // in - distinguished name or display name of container to process
)
{
LPABCONT pRootEntry = NULL; // root of AB
ULONG ulObjectType = 0;
HRESULT hr;
// TAccountCache * cache = args->Cache();
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
if ( ! m_pAdrBook )
{
OpenGlobalList();
}
if ( ! m_pAdrBook )
{
return FALSE;
}
/* SizedSPropTagArray(3, rgPropTags) =
{
3,
{
PR_ENTRYID,
PR_DISPLAY_NAME,
PR_DEPTH,
}
};
*/
// Open the root entry.
hr = m_pAdrBook->OpenEntry(0, NULL, NULL, 0, &ulObjectType, (LPUNKNOWN*)&pRootEntry);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_AB_ROOT_FAILED_D,hr);
return FALSE;
}
ScanHierarchy(pRootEntry,args,container);
return TRUE;
}
BOOL
TGlobalDirectory::ScanHierarchy(
LPABCONT pContainer, // in - interface pointer to address book
SecurityTranslatorArgs * args, // in - translation settings
WCHAR const * container // in - distinguished name or display name of container
)
{
HRESULT hr;
LPMAPITABLE pContainerTable = NULL;
LPSRowSet pContainerRows = NULL;
LPABCONT pEntry = NULL;
ULONG ulObjectType = 0;
BOOL foundContainer = FALSE;
MCSASSERT(pContainer);
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
// Get its hierarchical table.
SizedSPropTagArray(4, rgPropTags) =
{
4,
{
PR_ENTRYID,
PR_DISPLAY_NAME_A, // I tried to get the display name in unicode format, but it did not work.
PR_OBJECT_TYPE,
PR_EMS_AB_OBJ_DIST_NAME_A
}
};
hr = pContainer->GetHierarchyTable(CONVENIENT_DEPTH, &pContainerTable);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_HIER_TABLE_FAILED_D,hr);
return FALSE;
}
// Get a list of all rows.
hr = (*pHrQueryAllRows)(pContainerTable, (LPSPropTagArray)&rgPropTags, NULL, NULL, 0, &pContainerRows);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_TABLE_CONTENTS_FAILED_D,hr);
pContainerTable->Release();
return FALSE;
}
for (ULONG ulRow = (ULONG)0; ulRow < pContainerRows->cRows; ++ulRow)
{
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
hr = m_pAdrBook->OpenEntry(pContainerRows->aRow[ulRow].lpProps[0].Value.bin.cb,
(LPENTRYID)pContainerRows->aRow[ulRow].lpProps[0].Value.bin.lpb,
NULL,
MAPI_MODIFY, // or 0 if nochange mode
&ulObjectType,
(LPUNKNOWN *)&pEntry);
if (!SUCCEEDED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_OPEN_CONTAINER_FAILED_SD,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW,hr);
return FALSE;
}
else
{
// LPMAPITABLE pContainerTable = NULL; // container table
UCHAR containerA[LEN_DistName];
safecopy(containerA,container);
// look for the specified container
if ( NOT_PT_ERROR(pContainerRows->aRow[ulRow].lpProps[1] )
&& !UStrICmp(containerA,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszA) )
{
foundContainer = TRUE;
break;
}
if ( container && container[0]== '/' )
{
// Check the distinguished name
LPSPropValue props;
ULONG ulCount;
HRESULT hr2;
hr2 = pEntry->GetProps((LPSPropTagArray)&rgPropTags,0,&ulCount,&props);
if ( SUCCEEDED(hr) )
{
if ( ulCount >= 4 && NOT_PT_ERROR(props[3]) )
{
if ( !UStrICmp(props[3].Value.lpszA,containerA) )
{
foundContainer = TRUE;
}
}
(*pMAPIFreeBuffer)(props);
props = NULL;
}
else
{
err.SysMsgWrite(ErrE,hr2,DCT_MSG_GET_CONTAINER_INFO_FAILED_D,hr2);
}
if ( foundContainer )
break;
}
}
}
// if we found the container, process it's contents
if ( foundContainer )
{
if ( args->LogFileDetails() )
err.MsgWrite(0,DCT_MSG_EXAMINING_CONTENTS_S,pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW);
// Get its contents table.
hr = pEntry->GetContentsTable(0, &pContainerTable);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_CONTAINER_INFO_FAILED_D,hr);
pEntry->Release();
pEntry = NULL;
return FALSE;
}
// need to scan contents and hierarchy for this item
m_pContainer = pEntry;
m_name = pContainerRows->aRow[ulRow].lpProps[1].Value.lpszW;
ScanContents(pContainerTable,args);
}
else
{
err.MsgWrite(ErrW,DCT_MSG_CONTAINER_NOT_FOUND_S,container);
}
(*pFreeProws)(pContainerRows);
pContainerRows = NULL;
pContainerTable->Release();
return TRUE;
}
///////////////////////////////////////////////////////////////////////////////
// Scan the contents of the Container for sids that need to be converted.
BOOL
TGlobalDirectory::ScanContents(
LPMAPITABLE pContainerTable, // in - contents table for container
SecurityTranslatorArgs * args // in - translation settings
)
{
ULONG ulDLEntries;
// WCHAR em[500] = L"";
MCSASSERT (pContainerTable);
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
HRESULT hr = pContainerTable->GetRowCount(0, &ulDLEntries);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_COUNT_CONTAINER_FAILED_SD,m_name,hr);
return FALSE;
}
// Determine which column of the table has the Entry ID.
LPSPropTagArray pDLPropTags = NULL;
hr = pContainerTable->QueryColumns(0, &pDLPropTags);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_CONTAINER_CORRUPTED_SD,m_name,hr);
return FALSE;
}
ULONG ulEntryIdColumn;
BOOL bFoundEntryId = FALSE;
for (UINT ulCol = 0; ulCol < pDLPropTags->cValues; ++ulCol)
{
if (pDLPropTags->aulPropTag[ulCol] == PR_ENTRYID)
{
ulEntryIdColumn = ulCol;
bFoundEntryId = TRUE;
break;
}
}
(*pMAPIFreeBuffer)(pDLPropTags);
pDLPropTags = NULL;
if (!bFoundEntryId)
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_CONTAINER_CORRUPTED_SD,m_name,hr);
return FALSE;
}
// Peruse the rows for the SIDs and names.
LPSRowSet pDLRows = NULL;
LPMAPIPROP pUserEntry = NULL;
for (ULONG ulRow = 0; ulRow < ulDLEntries; ++ulRow)
{
if ( args->Cache()->IsCancelled() )
{
break;
}
hr = pContainerTable->SeekRow(BOOKMARK_BEGINNING, ulRow, NULL);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_CANT_FIND_ENTRY_SD,m_name,hr);
return FALSE;
}
hr = pContainerTable->QueryRows(1, TBL_NOADVANCE, &pDLRows);
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_CANT_LOAD_ENTRY_SD,m_name,hr);
return FALSE;
}
// Get the current entry.
ULONG ulEntryType = 0;
if ( pDLRows && pDLRows->cRows )
{
hr = m_pContainer->OpenEntry(pDLRows->aRow[0].lpProps[ulEntryIdColumn].Value.bin.cb,
(ENTRYID *)pDLRows->aRow[0].lpProps[ulEntryIdColumn].Value.bin.lpb,
NULL,
MAPI_MODIFY,
&ulEntryType,
(LPUNKNOWN*)&pUserEntry);
}
(*pFreeProws)(pDLRows);
pDLRows = NULL;
if (FAILED(hr))
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_RECIP_LOAD_FAILED_SD,m_name,hr);
return FALSE;
}
if ( pUserEntry )
{
UpdateEntry(pUserEntry,ulEntryType, args);
pUserEntry->Release();
pUserEntry = NULL;
}
}
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
return TRUE;
}
BOOL TGlobalDirectory::OpenContainerByRow(long row)
{
HRESULT hr;
ULONG ulObjectType = 0;
MCSASSERT( m_pRootRows );
// TODO: check that row is in valid range.
// Load the container that should contain the DL.
hr = m_pAdrBook->OpenEntry( m_pRootRows->aRow[row].lpProps[0].Value.bin.cb,
(LPENTRYID)m_pRootRows->aRow[row].lpProps[0].Value.bin.lpb,
NULL,
MAPI_MODIFY, // or 0 if nochange mode
&ulObjectType,
(LPUNKNOWN *)&m_pContainer);
(*pFreeProws)(m_pRootRows);
m_pRootRows = NULL;
if (FAILED(hr)) {
err.SysMsgWrite(ErrE,hr,DCT_MSG_OPEN_CONTAINER_FAILED_SD,L"",hr);
return FALSE;
}
// Look for the DL in its container.
// LPMAPITABLE pContainerTable = NULL; // container table
// Get its contents table.
hr = m_pContainer->GetContentsTable(0, &m_pContainerTable);
if (FAILED(hr)) {
err.SysMsgWrite(ErrE,hr,DCT_MSG_GET_TABLE_CONTENTS_FAILED_D,hr);
m_pContainer->Release();
m_pContainer = NULL;
return FALSE;
}
return TRUE;
}
#define NDX_SID 3
#define NDX_SD 4
DWORD
TGlobalDirectory::GetLDAPPort(
WCHAR * server
)
{
DWORD port = LDAP_PORT;
// DWORD rc = 0;
DAPI_ENTRY attList;
DAPI_ENTRY * pValues;
ATT_VALUE atts[3];
WCHAR distName[300];
PDAPI_EVENT result = NULL;
DAPI_ENTRY * pAttributes = NULL;
if ( ! LoadDAPI() )
{
err.MsgWrite(ErrW,DCT_MSG_LDAP_PORT_DETECT_FAILED_S,server);
return port;
}
if ( DAPIOpen(server) )
{
// set up the attribute list
attList.unAttributes = 3;
attList.ulEvalTag = VALUE_ARRAY;
attList.rgEntryValues = atts;
atts[0].DapiType = DAPI_UNICODE;
atts[0].Value.pszW = ATT_OBJ_CLASS;
atts[0].size = UStrLen(atts[0].Value.pszW);
atts[0].pNextValue = NULL;
atts[1].DapiType = DAPI_UNICODE;
atts[1].Value.pszW = ATT_LDAP_PORT;
atts[1].size = UStrLen(atts[1].Value.pszW);
atts[1].pNextValue = NULL;
atts[2].DapiType = DAPI_UNICODE;
atts[2].Value.pszW = LDAP_USE_SITE_VALUES;
atts[2].size = UStrLen(atts[2].Value.pszW);
atts[2].pNextValue = NULL;
// construct the DN for the attribute
swprintf(distName,L"/cn=Configuration/cn=Servers/cn=%s%s",server,LDAP_PortNumber_DN_Part);
result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attList,
&pValues, &pAttributes);
if ( ! result )
{
if ( pValues && pValues->rgEntryValues[2].Value.iValue == 0 )
{
// not using site defaults - rgEntryValues[1] contains the correct value for this server
if ( pValues && pValues->rgEntryValues[1].DapiType == DAPI_INT )
{
port = pValues->rgEntryValues[1].Value.iValue;
}
}
else
{
// This server is using the default values for the site - need to look at the site level to find the correct value
(*pDAPIFreeMemory)(pValues);
swprintf(distName,L"/cn=Configuration%s",LDAP_PortNumber_DN_Part);
attList.unAttributes = 2; // don't want to get 'Use-Site-Defaults' this time (we're looking at the Site)
result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attList,
&pValues, &pAttributes);
if ( ! result )
{
if ( pValues && pValues->rgEntryValues[1].DapiType == DAPI_INT )
{
// Here's the default value for the site
port = pValues->rgEntryValues[1].Value.iValue;
}
}
else
{
(*pDAPIFreeMemory)(result);
}
}
(*pDAPIFreeMemory)(pValues);
}
else
{
(*pDAPIFreeMemory)(result);
}
}
else
{
err.MsgWrite(ErrW,DCT_MSG_LDAP_PORT_DETECT_FAILED_S,server);
}
DAPIClose();
ReleaseDAPI();
return port;
}
void
TGlobalDirectory::GetSiteNameForServer(
WCHAR const * server, // in - name of exchange server to use
CLdapEnum * e, // in - LDAP connection to use for query
WCHAR * siteName // out- distinguished name of exchange site for server
)
{
WCHAR * atts[6] = { L"distinguishedName", L"rdn",NULL };
WCHAR query[200];
DWORD rc;
WCHAR ** values = NULL;
siteName[0] = 0;
swprintf(query,L"(&(objectClass=computer)(rdn=%ls))",server);
rc = e->Open(query,L"",2,100,3,atts);
// there should be only one server with this name
if (! rc )
rc = e->Next(&values);
if (! rc )
{
if ( !UStrICmp(values[1],server) )
{
WCHAR serverPrefix[LEN_Path];
swprintf(serverPrefix,L"cn=%ls,cn=Servers,cn=Configuration,",values[1]);
if ( ! UStrICmp(values[0],serverPrefix,UStrLen(serverPrefix)) )
{
UStrCpy(siteName,values[0] + UStrLen(serverPrefix));
}
else
{
err.MsgWrite(ErrE,DCT_MSG_GENERIC_S,values[0]);
}
}
else
{
err.MsgWrite(ErrE,DCT_MSG_LDAP_CALL_FAILED_SD,server,ERROR_NOT_FOUND);
}
e->FreeData(values);
}
else
{
err.SysMsgWrite(ErrE,e->m_connection.LdapMapErrorToWin32(rc),DCT_MSG_LDAP_CALL_FAILED_SD,server,rc);
}
}
BOOL
TGlobalDirectory::DoLdapTranslation(
WCHAR * server,
WCHAR * creds,
WCHAR * password,
SecurityTranslatorArgs * args,
WCHAR * basept,
WCHAR * query
)
{
CLdapEnum e;
WCHAR * atts[6] = { L"distinguishedName", L"rdn", L"cn", L"Assoc-NT-Account",L"NT-Security-Descriptor",NULL };
WCHAR ** values = NULL;
ULONG port = GetLDAPPort(server);
ULONG pageSize = 100;
WCHAR basepoint[LEN_Path] = L"";
e.m_connection.SetCredentials(creds,password);
DWORD rc = e.InitConnection(server,port);
BOOL anychange = FALSE;
BOOL verbose = args->LogVerbose();
BOOL bUseMapFile = args->UsingMapFile();
if (! rc )
{
if ( ! basept )
{
GetSiteNameForServer(server,&e,basepoint);
}
else
{
// use the user-specified basepoint
safecopy(basepoint,basept);
}
if ( query )
{
rc = e.Open(query,basepoint,2,pageSize,5,atts);
}
else
{
rc = e.Open(L"(objectClass=*)",basepoint,2,pageSize,5,atts);
}
if ( ! rc )
{
do
{
rc = e.Next(&values);
anychange = FALSE;
if (! rc )
{
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
if ( m_stat )
{
m_stat->DisplayPath(values[0]);
m_stat->IncrementExamined(mailbox);
}
// update the Assoc-NT-Account, if any
if ( values[NDX_SID] && *values[NDX_SID] )
{
// convert the SID to a binary value and look it up in the cache
BYTE pSid[500];
if ( e.m_connection.StringToBytes(values[NDX_SID],pSid) )
{
// check if the sid is one we need to change
//TRACE (_T("DisplayName = %s "),pUserProperties[0].Value.lpszW);
PSID newSid = 0;
TAcctNode * node;
if ( IsValidSid(pSid) )
{
if (!bUseMapFile)
node = args->Cache()->Lookup(pSid);
else
node = args->Cache()->LookupWODomain(pSid);
if ( m_stat )
{
m_stat->IncrementOwnerExamined();
if ( verbose )
err.MsgWrite(0,DCT_MSG_EXAMINED_S,values[0]);
}
if ( node == (TAcctNode*)-1 && m_stat )
m_stat->IncrementOwnerNoTarget();
if ( node && (node != (TAcctNode *)-1) && node->IsValidOnTgt() )
{
if (!bUseMapFile)
newSid = args->Cache()->GetTgtSid(node);
else
newSid = args->Cache()->GetTgtSidWODomain(node);
}
else
newSid = NULL;
}
else
{
newSid = NULL;
}
if ( newSid )
{
//TRACE (_T("needs to be translated\n"));
MCSASSERT ( IsValidSid(newSid) );
WCHAR newSidStr[1000];
if ( e.m_connection.BytesToString((BYTE*)newSid,newSidStr,GetLengthSid(newSid)) )
{
if ( m_stat )
{
m_stat->IncrementOwnerChange(node,mailbox,NULL);
}
anychange = TRUE;
if ( ! args->NoChange() )
{
rc = e.m_connection.UpdateSimpleStringValue(values[0],atts[NDX_SID],newSidStr);
if ( rc )
{
err.SysMsgWrite(ErrE,rc,DCT_MSG_UPDATE_ACCOUNT_FAILED_D, rc);
}
}
}
}
}
}
// Update the NT-Security-Descriptor, if any
if ( values[NDX_SD] && *values[NDX_SD] )
{
// convert the SID to a binary value and look it up in the cache
BYTE * pSD = new BYTE[UStrLen(values[NDX_SD])];
if (!pSD)
return FALSE;
if ( e.m_connection.StringToBytes(values[NDX_SD],pSD) )
{
TMapiSD tMailbox((SECURITY_DESCRIPTOR *)pSD);
if ( tMailbox.HasSecurity() )
{
TSD * pSD2 = tMailbox.GetSecurity();
bool changes = tMailbox.ResolveSDInternal(args->Cache(),m_stat,verbose,args->TranslationMode(),mailbox, bUseMapFile);
if ( changes )
{
anychange = TRUE;
SECURITY_DESCRIPTOR * pRelSD = (SECURITY_DESCRIPTOR *)pSD2->MakeRelSD();
DWORD dwSDLength = GetSecurityDescriptorLength(pRelSD);
if ( ! args->NoChange() )
{
WCHAR * pSDString = new WCHAR[1 + dwSDLength * 2];
if (!pSDString)
{
delete [] pSD;
return FALSE;
}
if ( e.m_connection.BytesToString((BYTE*)pRelSD,pSDString,dwSDLength) )
{
rc = e.m_connection.UpdateSimpleStringValue(values[0],atts[NDX_SD],pSDString);
if ( rc )
{
err.SysMsgWrite(ErrE,rc,DCT_MSG_RECIP_SD_WRITE_FAILED_SD,values[0],rc);
if ( rc == ERROR_INVALID_PARAMETER )
{
// this error occurs when the security descriptor is too large
// don't abort in this case
rc = 0;
}
}
}
delete [] pSDString;
}
}
}
}
delete [] pSD;
}
if ( anychange && m_stat )
{
m_stat->IncrementChanged(mailbox);
if ( args->LogFileDetails() )
err.MsgWrite(0,DCT_MSG_CHANGED_S,values[0]);
}
e.FreeData(values);
}
} while ( ! rc );
}
if ( rc && (rc != LDAP_COMPARE_FALSE) && (rc != ERROR_NOT_FOUND) )
{
err.SysMsgWrite(ErrE,e.m_connection.LdapMapErrorToWin32(rc),DCT_MSG_LDAP_CALL_FAILED_SD,server,rc);
}
}
else
{
err.SysMsgWrite(ErrE,rc,DCT_MSG_CANNOT_CONNECT_TO_EXCHANGE_SERVER_SSD,server,creds,rc);
}
return rc;
}
BOOL
TGlobalDirectory::DoDAPITranslation(
WCHAR * serv, // in - Exchange server
SecurityTranslatorArgs * args // in - translation options
)
{
// enumerate organizations, sites, and containers
if ( DAPIOpen( serv ) )
{
HRESULT hr;
LPWSTR pOrganizations = NULL;
LPWSTR pSites = NULL;
LPWSTR pContainers = NULL;
WCHAR * server;
WCHAR container[1];
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
server = new WCHAR[wcslen(serv) + 1];
if (!server)
return FALSE;
UStrCpy(server,serv);
container[0] = 0;
// enumerate organizations
m_stat->DisplayPath(GET_STRING(IDS_ScanningExchangeDirectory));
hr = HrEnumOrganizations(container,server,&pOrganizations);
if ( SUCCEEDED(hr) )
{
for ( ; pOrganizations && *pOrganizations ; pOrganizations+=UStrLen(pOrganizations) + 1 )
{
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
break;
}
WCHAR wOrganizations[300];
safecopy(wOrganizations,pOrganizations);
DAPITranslate(wOrganizations,args);
//enumerate sites
hr = HrEnumSites(server,pOrganizations,&pSites);
if ( SUCCEEDED(hr) )
{
for ( ; pSites && *pSites ; pSites+=UStrLen(pSites) + 1 )
{
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
break;
}
WCHAR wSites[300];
safecopy(wSites,pSites);
DAPITranslate(wSites,args);
//enumerate containers
hr = HrEnumContainers(server,pSites,TRUE,&pContainers);
if ( SUCCEEDED(hr) )
{
for ( ; pContainers && *pContainers ; pContainers+=UStrLen(pContainers) + 1 )
{
if (args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
break;
}
WCHAR wContainers[300];
safecopy(wContainers,pContainers);
DAPITranslate(wContainers,args);
}
}
else
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_CONTAINERS_FAILED_SD,hr);
}
}
}
else
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_SITES_FAILED_SD,hr);
}
}
}
else
{
err.SysMsgWrite(ErrE,hr,DCT_MSG_ENUM_ORGS_FAILED_SD,hr);
}
DAPIClose();
}
m_stat->DisplayPath(L"");
return TRUE;
}
BOOL
TGlobalDirectory::DAPIOpen(
WCHAR * server // in - name of exchange server
)
{
PDAPI_EVENT result;
BOOL bRc;
WCHAR * serv;
if ( ! LoadDAPI() )
{
return FALSE;
}
serv = new WCHAR [wcslen(server) + 1];
if (!serv)
return FALSE;
UStrCpy(serv,&*server);
// initialize parms
m_dParms.dwDAPISignature = DAPI_SIGNATURE;
m_dParms.dwFlags = DAPI_RAW_MODE | DAPI_EVENT_SOME;
m_dParms.pszDSAName = serv; // computer name of directory service agent
m_dParms.pszBasePoint = NULL;
m_dParms.pszContainer = NULL;
m_dParms.pszNTDomain = NULL;
m_dParms.pszCreateTemplate = NULL;
m_dParms.pAttributes = NULL;
result = (*pDAPIStart)(&m_dSession,&m_dParms);
if ( result )
{
// this is an error - need to show a message or something
LogDapiError(ErrE,L"DAPIStart: ",result);
(*pDAPIFreeMemory)(result);
bRc = FALSE;
}
else
bRc = TRUE;
return bRc;
}
BOOL TGlobalDirectory::DAPIClose()
{
(*pDAPIEnd)(&m_dSession);
return TRUE;
}
void StripQuotes(TCHAR * distName)
{
int nChars = UStrLen(distName);
int i, // input index
o; // output index
BOOL prevQuote = FALSE;
for ( i = 0,o = 0 ; i < nChars ; i++ )
{
if ( distName[i] != _T('"') || prevQuote )
{
prevQuote = FALSE;
distName[o] = distName[i];
o++;
}
else
{
// leave the output pointer where it is, so the character will be overwritten
prevQuote = TRUE;
}
}
distName[o] = 0;
}
BOOL TGlobalDirectory::DAPITranslate(WCHAR * dn, SecurityTranslatorArgs * args)
{
PDAPI_EVENT result;
TCHAR * distName; // distinguished name of object to read.
DAPI_ENTRY * pValues = NULL;
DAPI_ENTRY * pAttributes = NULL;
ATT_VALUE attributes[8]; // DapiType, Value, size, pNextValue
WCHAR * att_names[8];
bool verbose = false;
if ( args->Cache()->IsCancelled() )
{
err.MsgWrite(0,DCT_MSG_OPERATION_ABORTED);
return FALSE;
}
att_names[0] = L"Obj-Class";
att_names[1] = L"DSA-Signature";
att_names[2] = L"Directory Name";
att_names[3] = L"Obj-View-Containers";
att_names[4] = L"Obj-Dist-Name";
int sdIndex = 5;
att_names[sdIndex] = L"NT-Security-Descriptor";
att_names[6] = L"Organizational-Unit-Name";
att_names[7] = L"Organization-Name";
DAPI_ENTRY attr;
attr.unAttributes = 8;
attr.ulEvalTag = VALUE_ARRAY;
attr.rgEntryValues = attributes;
for ( int i = 0 ; i < 8 ; i++ )
{
attributes[i].DapiType = DAPI_UNICODE;
attributes[i].Value.pszW = att_names[i];
attributes[i].size = UStrLen(att_names[i]);
attributes[i].pNextValue = NULL;
}
// we may need DAPI_RESTRICT_ACCESS and/or DAPI_MODIFY_REPLACE_PROPERTIES
distName = new TCHAR[wcslen(dn) + 1];
if (!distName)
return FALSE;
UStrCpy(distName,(LPCTSTR)dn);
StripQuotes(distName);
result = (*pDAPIRead)(m_dSession,DAPI_RAW_MODE,distName,&attr,
&pValues, &pAttributes);
if ( m_stat )
{
WCHAR wpath[MAX_PATH+1];
safecopy(wpath,&*distName);
m_stat->DisplayPath(wpath);
m_stat->IncrementExamined(container);
if ( verbose )
err.MsgWrite(0,DCT_MSG_EXAMINED_S,&*dn);
}
if ( result )
{
// this is an error - need to show a message or something
LogDapiError(ErrE,L"DAPIRead: ",result);
(*pDAPIFreeMemory)(result);
}
if ( pValues && pValues->rgEntryValues[sdIndex].DapiType == DAPI_BINARY )
{
SECURITY_DESCRIPTOR * pSD = (SECURITY_DESCRIPTOR *)pValues->rgEntryValues[sdIndex].Value.lpBinary;
TMapiSD exContainer(pSD);
if ( exContainer.HasSecurity() )
{
exContainer.SetName(distName);
bool changes = exContainer.ResolveSDInternal(args->Cache(),m_stat,false,args->TranslationMode(),container, FALSE);
// ULONG usn = 0;
if ( changes )
{
if (m_stat)
{
m_stat->IncrementChanged(container);
if ( args->LogFileDetails() )
err.MsgWrite(0,DCT_MSG_CHANGED_S,&*dn);
}
// record the changes
if ( ! args->NoChange() )
{
TSD * tSD = exContainer.GetSecurity();
pSD = (SECURITY_DESCRIPTOR *)tSD->MakeRelSD();
pValues->rgEntryValues[sdIndex].Value.lpBinary = (UCHAR *)pSD;
// make sure the size is still correct. For NT 3.51 and 4 it
// should always be, since all the SIDs are the same length, but
// we don't want this to break if it gets a different-length SID
pValues->rgEntryValues[sdIndex].size = GetSecurityDescriptorLength(pSD);
// Change the directory name to match the distinguished name, otherwise you get
// object not found error.
pValues->rgEntryValues[2].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
// Same problem for the OU-Name for Sites
if ( pValues->rgEntryValues[6].DapiType != DAPI_NO_VALUE )
{
pValues->rgEntryValues[6].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
}
// Same problem for the O-name for organizations
if ( pValues->rgEntryValues[7].DapiType != DAPI_NO_VALUE )
{
pValues->rgEntryValues[7].Value.pszW = pValues->rgEntryValues[4].Value.pszW;
}
result = (*pDAPIWrite)(m_dSession,DAPI_WRITE_MODIFY,&attr,pValues,NULL,NULL,NULL);
if ( result )
{
LogDapiError(ErrE,L"DAPIWrite: ",result);
(*pDAPIFreeMemory)(result);
}
free(pSD);
}
}
}
}
// cleanup
if ( pValues )
(*pDAPIFreeMemory)(pValues);
if ( pAttributes )
(*pDAPIFreeMemory)(pAttributes);
delete [] distName;
return TRUE;
}
Reference in a new issue Copy permalink