archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/ds/security/gina/snapins/gpedit/rsopwizarddlg.cpp

7892 lines
284 KiB
Raw Permalink Blame History

//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1994 - 2001.
//
// File: RSOPWizardDlg.cpp
//
// Contents: implementation of RSOP wizard dialog
//
// Classes: CRSOPWizardDlg
//
// Functions:
//
// History: 08-08-2001 rhynierm Created
//
//---------------------------------------------------------------------------
#include "main.h"
#include "RSOPWizardDlg.h"
#include "RSOPWizard.h"
#include "RSOPUtil.h"
#include "objsel.h" // for the object picker
#include "sddl.h" // for sid to string functions
//---------------------------------------------------------------------------
// Private global variables
DWORD g_aBrowseForOUHelpIds[] =
{
DSBID_BANNER, IDH_RSOP_BANNER,
DSBID_CONTAINERLIST, IDH_RSOP_CONTAINERLIST,
0, 0
};
DWORD g_aBrowseDCHelpIds[] =
{
IDC_LIST1, IDH_RSOP_BROWSEDC,
0, 0
};
//---------------------------------------------------------------------------
// Private helper methods
WCHAR * NameWithoutDomain(WCHAR * szName); // In RSOPWizard.cpp
TCHAR* NormalizedComputerName(TCHAR * szComputerName ); // In RSOPRoot.cpp
BOOL CopyString( LPTSTR szSource, LPTSTR* pszTarget ); // In RSOPQuery.cpp
BOOL FreeStringList( DWORD dwCount, LPTSTR* aszStrings ); // In RSOPQuery.cpp
BOOL FreeTargetData( LPRSOP_QUERY_TARGET pTarget ); // In RSOPQuery.cpp
BOOL FreeTarget( LPRSOP_QUERY_TARGET pTarget ); // In RSOPQuery.cpp
//---------------------------------------------------------------------------
// TranslateNameXForest
//
// Purpose: a method to do name translations (similar to TranslateName),
// but that also works with names in other forests.
DWORD DsNameErrorMap[] = { ERROR_SUCCESS,
ERROR_NO_SUCH_USER,
ERROR_NO_SUCH_USER,
ERROR_NONE_MAPPED,
ERROR_NONE_MAPPED,
ERROR_SOME_NOT_MAPPED,
ERROR_SOME_NOT_MAPPED
};
#define MapDsNameError( x ) ((x < sizeof( DsNameErrorMap ) / sizeof( DWORD ) ) ? \
DsNameErrorMap[ x ] : ERROR_GEN_FAILURE )
BOOLEAN
TranslateNameXForest (
LPTSTR szDomain, // Domain where the name should be resolved
LPCTSTR lpAccountName, // object name
DS_NAME_FORMAT AccountNameFormat, // name format
DS_NAME_FORMAT DesiredNameFormat, // new name format
LPTSTR *lpTranslatedName // returned name buffer
)
{
BOOL bRetry = FALSE;
DWORD dwErr;
PDOMAIN_CONTROLLER_INFO pDCInfo = NULL;
HANDLE hDS = NULL;
PDS_NAME_RESULT pResult = NULL;
BOOLEAN bRet = FALSE;
LPWSTR szTransName = NULL;
DebugMsg(( DM_VERBOSE, L"TranslateNameXForest: Resolving name <%s> at Domain <%s>", lpAccountName, szDomain ? szDomain : L""));
//
// get a DC and bind to it. Make sure to force rediscover a DC if the bind fails
//
for (;;) {
dwErr = DsGetDcName( NULL,
szDomain ? szDomain : L"",
NULL,
NULL,
DS_DIRECTORY_SERVICE_REQUIRED |
DS_RETURN_DNS_NAME |
(bRetry ? DS_FORCE_REDISCOVERY : 0) |
0,
&pDCInfo );
if (dwErr == NO_ERROR) {
dwErr = DsBind( pDCInfo->DomainControllerName,
NULL,
&hDS );
if (dwErr == NO_ERROR) {
break;
}
else {
DebugMsg(( DM_WARNING, L"TranslateNameXForest: Failed to bind to DC <%s> with error %d",
pDCInfo->DomainControllerName, dwErr ));
NetApiBufferFree(pDCInfo);
pDCInfo = NULL;
}
}
else {
DebugMsg(( DM_WARNING, L"TranslateNameXForest: Failed to get DC for domain <%s> with error %d",
szDomain ? szDomain : L"", dwErr ));
}
//
// Failed to bind to a DC. bail
//
if (bRetry) {
goto Exit;
}
bRetry = TRUE;
}
DebugMsg(( DM_VERBOSE, L"TranslateNameXForest: DC selected is <%s>", pDCInfo->DomainControllerName ));
//
// Now crack names with the DC that is bound
//
dwErr = DsCrackNames( hDS,
DS_NAME_NO_FLAGS,
AccountNameFormat,
DesiredNameFormat,
1,
&lpAccountName,
&pResult);
if (dwErr != DS_NAME_NO_ERROR) {
DebugMsg(( DM_WARNING, L"TranslateNameXForest: Failed to crack names with error %d", dwErr ));
goto Exit;
}
if ( pResult->cItems == 0 ) {
DebugMsg(( DM_WARNING, L"TranslateNameXForest: Failed to return enough result items" ));
dwErr = ERROR_INVALID_DATA;
goto Exit;
}
if ( pResult->rItems[0].status == DS_NAME_NO_ERROR ) {
//
// In case of no error, return the resolved name
//
DWORD dwTransNameLength = 1 + lstrlen(pResult->rItems[0].pName);
szTransName = (LPWSTR)LocalAlloc(LPTR, sizeof(WCHAR) * ( dwTransNameLength ));
if (!szTransName) {
DebugMsg(( DM_WARNING, L"TranslateNameXForest: Failed to allocate memory for domain" ));
dwErr = GetLastError();
goto Exit;
}
HRESULT hr = StringCchCopy(szTransName, dwTransNameLength, pResult->rItems[0].pName);
if(FAILED(hr)) {
dwErr = HRESULT_CODE(hr);
goto Exit;
}
*lpTranslatedName = szTransName;
szTransName = NULL;
}
else {
//
// remap the error code to win32 error
//
DebugMsg(( DM_WARNING, L"TranslateNameXForest: DsCrackNames failed with error %d", pResult->rItems[0].status ));
dwErr = MapDsNameError(pResult->rItems[0].status);
goto Exit;
}
bRet = TRUE;
Exit:
if ( szTransName ) {
LocalFree( szTransName );
}
if ( pDCInfo ) {
NetApiBufferFree(pDCInfo);
}
if (hDS) {
DsUnBind( &hDS );
}
if (pResult) {
DsFreeNameResult(pResult);
}
if ( !bRet )
{
SetLastError( dwErr );
}
return bRet;
}
//-------------------------------------------------------
LPTSTR GetDomainFromSOM (LPTSTR lpSOM)
{
LPTSTR lpFullName, lpResult;
LPOLESTR lpLdapDomain, lpDomainName;
HRESULT hr;
ULONG ulNoChars;
ulNoChars = lstrlen(lpSOM) + 10;
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (!lpFullName)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetDomainFromSOM: Failed to allocate memory with %d."), GetLastError()));
return NULL;
}
hr = StringCchCopy (lpFullName, ulNoChars, TEXT("LDAP://"));
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpFullName, ulNoChars, lpSOM);
}
if (FAILED(hr))
{
LocalFree(lpFullName);
return NULL;
}
lpLdapDomain = GetDomainFromLDAPPath(lpFullName);
LocalFree (lpFullName);
if (!lpLdapDomain)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetDomainFromSOM: Failed to get ldap domain name from path.")));
return NULL;
}
hr = ConvertToDotStyle (lpLdapDomain, &lpDomainName);
delete [] lpLdapDomain;
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetDomainFromSOM: Failed to convert to dot style.")));
return NULL;
}
ulNoChars = lstrlen(lpDomainName) + 1;
lpResult = new TCHAR[ulNoChars];
if (lpResult)
{
hr = StringCchCopy (lpResult, ulNoChars, lpDomainName);
ASSERT(SUCCEEDED(hr));
}
LocalFree (lpDomainName);
return lpResult;
}
//-------------------------------------------------------
WCHAR * ExtractDomain(WCHAR * sz)
{
// parse through the string looking for a forward slash
DWORD cch = 0;
if (!sz)
{
return NULL;
}
while (sz[cch])
{
if (L'\\' == sz[cch] || L'/' == sz[cch])
{
WCHAR * szNew = new WCHAR[cch+1];
if (szNew)
{
wcsncpy(szNew, sz, cch);
szNew[cch] = TEXT('\0');
}
return szNew;
}
cch++;
}
// didn't find a forward slash
return NULL;
}
//*************************************************************
//
// MyLookupAccountName()
//
// Purpose: Gets the SID of the user
//
// Parameters:
// szSystemName: Machine where the account should be resolved
// szAccName: The actual account name
//
// Return: lpUserName if successful
// NULL if an error occurs
//
// Allocates and retries with the appropriate buffer size
LPTSTR MyLookupAccountName(LPTSTR szSystemName, LPTSTR szAccName)
{
PSID pSid = NULL;
DWORD cSid = 0, cbDomain = 0;
SID_NAME_USE peUse;
LPTSTR lpSidString = NULL, szDomain = NULL;
DWORD dwErr = 0;
BOOL bRet = FALSE;
LookupAccountName(szSystemName, szAccName, NULL, &cSid, NULL, &cbDomain, &peUse);
pSid = (PSID)LocalAlloc(LPTR, cSid);
szDomain = (LPTSTR) LocalAlloc(LPTR, cbDomain*(sizeof(TCHAR)));
if (!pSid || !szDomain) {
return NULL;
}
if (!LookupAccountName(szSystemName, szAccName, pSid, &cSid, szDomain, &cbDomain, &peUse)) {
DebugMsg((DM_WARNING, TEXT("MyLookupAccountName: LookupAccountName failed with %d"),
GetLastError()));
dwErr = GetLastError();
goto Exit;
}
if (!ConvertSidToStringSid(pSid, &lpSidString)) {
DebugMsg((DM_WARNING, TEXT("MyLookupAccountName: ConvertSidToStringSid failed with %d"),
GetLastError()));
dwErr = GetLastError();
goto Exit;
}
bRet = TRUE;
Exit:
if (pSid) {
LocalFree(pSid);
}
if (szDomain) {
LocalFree(szDomain);
}
if (!bRet) {
SetLastError(dwErr);
return NULL;
}
else {
return lpSidString;
}
}
//-------------------------------------------------------
void GetControlText(HWND hDlg, DWORD ctrlid, TCHAR * &szControlText, BOOL bUseLocalAlloc)
{
UINT nSize;
if ( szControlText != NULL )
{
if ( bUseLocalAlloc )
{
LocalFree( szControlText );
}
else
{
delete [] szControlText;
}
szControlText = NULL;
}
nSize = (UINT) SendMessage(GetDlgItem(hDlg, ctrlid),
WM_GETTEXTLENGTH, 0, 0);
if (nSize > 0)
{
if ( bUseLocalAlloc )
{
szControlText = (TCHAR*)LocalAlloc( LPTR, (nSize+1)*sizeof(TCHAR) );
}
else
{
szControlText = new TCHAR[nSize + 1];
}
if (szControlText)
{
LPTSTR lpDest, lpSrc;
GetDlgItemText(hDlg, ctrlid, szControlText, nSize + 1);
if (szControlText[0] == TEXT(' '))
{
//
// Remove leading blanks by shuffling the characters forward
//
lpDest = lpSrc = szControlText;
while ((*lpSrc == TEXT(' ')) && *lpSrc)
lpSrc++;
if (*lpSrc)
{
while (*lpSrc)
{
*lpDest = *lpSrc;
lpDest++;
lpSrc++;
}
*lpDest = TEXT('\0');
}
}
//
// Remove trailing blanks
//
lpDest = szControlText + lstrlen(szControlText) - 1;
while ((*lpDest == TEXT(' ')) && (lpDest >= szControlText))
lpDest--;
*(lpDest+1) = TEXT('\0');
}
}
}
//-------------------------------------------------------
HRESULT ImplementBrowseButton(HWND hDlg, DWORD dwFlagsUp, DWORD dwFlagsDown,
DWORD dwflScope, HWND hLB, TCHAR * &szFoundObject)
{
// shell the object picker to get the computer list
HRESULT hr = E_FAIL;
IDsObjectPicker * pDsObjectPicker = NULL;
const ULONG cbNumScopes = 4; //make sure this number matches the number of scopes initialized
DSOP_SCOPE_INIT_INFO ascopes [cbNumScopes];
DSOP_INIT_INFO InitInfo;
IDataObject * pdo = NULL;
STGMEDIUM stgmedium = {
TYMED_HGLOBAL,
NULL
};
UINT cf = 0;
FORMATETC formatetc = {
(CLIPFORMAT)cf,
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL
};
BOOL bAllocatedStgMedium = FALSE;
PDS_SELECTION_LIST pDsSelList = NULL;
PDS_SELECTION pDsSelection = NULL;
ULONG ulSize, ulIndex, ulMax;
LPWSTR lpTemp;
LPTSTR szDomain = NULL;
LPWSTR szUnEscapedPath = NULL;
hr = CoInitialize (NULL);
if (FAILED(hr))
goto Browse_Cleanup;
hr = CoCreateInstance (CLSID_DsObjectPicker,
NULL,
CLSCTX_INPROC_SERVER,
IID_IDsObjectPicker,
(void **) & pDsObjectPicker
);
if (FAILED(hr))
goto Browse_Cleanup;
//Initialize the scopes.
ZeroMemory (ascopes, cbNumScopes * sizeof (DSOP_SCOPE_INIT_INFO));
ascopes[0].cbSize = ascopes[1].cbSize = ascopes[2].cbSize = ascopes[3].cbSize
= sizeof (DSOP_SCOPE_INIT_INFO);
ascopes[0].flType = DSOP_SCOPE_TYPE_GLOBAL_CATALOG;
ascopes[0].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_LDAP
| DSOP_SCOPE_FLAG_STARTING_SCOPE | dwflScope;
ascopes[0].FilterFlags.Uplevel.flBothModes = dwFlagsUp;
ascopes[1].flType = DSOP_SCOPE_TYPE_ENTERPRISE_DOMAIN;
ascopes[1].FilterFlags.Uplevel.flBothModes = dwFlagsUp;
ascopes[1].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_LDAP | dwflScope;
ascopes[2].flType = DSOP_SCOPE_TYPE_EXTERNAL_UPLEVEL_DOMAIN |
DSOP_SCOPE_TYPE_EXTERNAL_DOWNLEVEL_DOMAIN;
ascopes[2].FilterFlags.Uplevel.flBothModes = dwFlagsUp;
ascopes[2].FilterFlags.flDownlevel = dwFlagsDown;
ascopes[2].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_LDAP | dwflScope;
ascopes[3].flType = DSOP_SCOPE_TYPE_USER_ENTERED_UPLEVEL_SCOPE |
DSOP_SCOPE_TYPE_USER_ENTERED_DOWNLEVEL_SCOPE |
DSOP_SCOPE_TYPE_WORKGROUP;
ascopes[3].FilterFlags.Uplevel.flBothModes = dwFlagsUp;
ascopes[3].FilterFlags.flDownlevel = dwFlagsDown;
ascopes[3].flScope = DSOP_SCOPE_FLAG_WANT_PROVIDER_LDAP | dwflScope;
//populate the InitInfo structure that will be used to initialize the
//object picker
ZeroMemory (&InitInfo, sizeof (DSOP_INIT_INFO));
InitInfo.cbSize = sizeof (DSOP_INIT_INFO);
InitInfo.cDsScopeInfos = cbNumScopes;
InitInfo.aDsScopeInfos = ascopes;
InitInfo.flOptions = (hLB ? DSOP_FLAG_MULTISELECT : 0);
hr = pDsObjectPicker->Initialize (&InitInfo);
if (FAILED(hr))
goto Browse_Cleanup;
hr = pDsObjectPicker->InvokeDialog (hDlg, &pdo);
//if the computer selection dialog cannot be invoked or if the user
//hits cancel, bail out.
if (FAILED(hr) || S_FALSE == hr)
goto Browse_Cleanup;
//if we are here, the user chose, OK, so find out what group was chosen
cf = RegisterClipboardFormat (CFSTR_DSOP_DS_SELECTION_LIST);
if (0 == cf)
goto Browse_Cleanup;
//set the clipboard format for the FORMATETC structure
formatetc.cfFormat = (CLIPFORMAT)cf;
hr = pdo->GetData (&formatetc, &stgmedium);
if (FAILED (hr))
goto Browse_Cleanup;
bAllocatedStgMedium = TRUE;
pDsSelList = (PDS_SELECTION_LIST) GlobalLock (stgmedium.hGlobal);
//
// Decide what the max number of items to process is
//
ulMax = pDsSelList->cItems;
if (!hLB && (ulMax > 1))
{
ulMax = 1;
}
//
// Loop through the items
//
for (ulIndex = 0; ulIndex < ulMax; ulIndex++)
{
pDsSelection = &(pDsSelList->aDsSelection[ulIndex]);
//
// Find the beginning of the object name after the domain name
//
lpTemp = pDsSelection->pwzADsPath + 7;
while (*lpTemp && *lpTemp != TEXT('/'))
{
lpTemp++;
}
if (!(*lpTemp))
{
hr = E_FAIL;
goto Browse_Cleanup;
}
lpTemp++;
ulSize = wcslen(lpTemp);
//
// Convert the name from full DN to sam compatible
//
szDomain = GetDomainFromSOM( lpTemp );
//
// ADSI escapes '/' which is not liked by native ldap.
// APIs like DsCrackNames/TranslateName etc.
// Previous function (GetDomainFromSOM) needs it though
// because it is using adsi interfaces internally
//
hr = UnEscapeLdapPath(lpTemp, &szUnEscapedPath);
if (FAILED(hr))
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
DebugMsg((DM_WARNING, TEXT("ImplementBrowseButton: UnEscapeLdapPath for %s failed with 0x%x."),
lpTemp, hr));
goto Browse_Cleanup;
}
if (TranslateNameXForest ( szDomain, szUnEscapedPath, (DS_NAME_FORMAT)NameFullyQualifiedDN,
(DS_NAME_FORMAT)NameSamCompatible, &szFoundObject ))
{
BOOL bDollarRemoved = FALSE;
if (szFoundObject[wcslen(szFoundObject)-1] == L'$')
{
bDollarRemoved = TRUE;
szFoundObject[wcslen(szFoundObject)-1] = 0;
}
if (hLB)
{
INT iIndex;
iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szFoundObject);
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) ((bDollarRemoved) ? 2: 0));
SendMessage (hLB, LB_SETCURSEL, (WPARAM) iIndex, 0);
LocalFree( szFoundObject );
szFoundObject = NULL;
}
}
else
{
hr = HRESULT_FROM_WIN32(GetLastError());
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
DebugMsg((DM_WARNING, TEXT("ImplementBrowseButton: TranslateName for %s to SAM style failed with %d."),
lpTemp, GetLastError()));
goto Browse_Cleanup;
}
}
Browse_Cleanup:
if (szUnEscapedPath)
LocalFree(szUnEscapedPath);
if (pDsSelList)
GlobalUnlock (pDsSelList);
if (bAllocatedStgMedium)
ReleaseStgMedium (&stgmedium);
if (pdo)
pdo->Release();
if (pDsObjectPicker)
pDsObjectPicker->Release();
if (szDomain)
delete [] szDomain;
return hr;
}
//-------------------------------------------------------
HRESULT GetForestFromDC( LPTSTR szDC, LPTSTR* pszForest )
{
DSROLE_PRIMARY_DOMAIN_INFO_BASIC* psDomainInfo( NULL );
DWORD dwResult( ERROR_SUCCESS );
if ( (szDC == NULL) || (*pszForest != NULL) )
{
return E_INVALIDARG;
}
dwResult = ::DsRoleGetPrimaryDomainInformation( szDC, DsRolePrimaryDomainInfoBasic, (PBYTE*) &psDomainInfo );
if ( dwResult != ERROR_SUCCESS )
{
return HRESULT_FROM_WIN32( dwResult );
}
CopyString( psDomainInfo->DomainForestName, pszForest );
::DsRoleFreeMemory( psDomainInfo );
return S_OK;
}
//-------------------------------------------------------
HRESULT GetForestFromObject( LPTSTR szDomainObject, LPTSTR* pszForest )
{
HRESULT hr = E_FAIL;
LPTSTR szDomain = ExtractDomain( szDomainObject );
if ( szDomain != NULL )
{
LPTSTR szDC = GetDCName( szDomain, NULL, NULL, FALSE, 0, DS_RETURN_DNS_NAME);
if ( szDC != NULL )
{
hr = GetForestFromDC( szDC, pszForest );
LocalFree( szDC );
}
delete [] szDomain;
}
return hr;
}
//-------------------------------------------------------
HRESULT GetForestFromContainer( LPTSTR szDSContainer, LPTSTR* pszForest )
{
HRESULT hr = E_FAIL;
LPTSTR szDomain = GetDomainFromSOM( szDSContainer );
if ( szDomain != NULL )
{
LPTSTR szDC = GetDCName( szDomain, NULL, NULL, FALSE, 0, DS_RETURN_DNS_NAME);
if ( szDC != NULL )
{
hr = GetForestFromDC( szDC, pszForest );
LocalFree( szDC );
}
delete [] szDomain;
}
return hr;
}
//---------------------------------------------------------------------------
// CRSOPWizardDlg class
//
CRSOPWizardDlg::CRSOPWizardDlg( LPRSOP_QUERY pQuery, CRSOPExtendedProcessing* pExtendedProcessing )
{
m_bPostXPBuild = FALSE; // Assume this is not post XP until verified as otherwise
OSVERSIONINFOEX osvi;
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
if ( GetVersionEx ((OSVERSIONINFO*) &osvi) )
{
// Windows XP was version 5.1, while .Net Server is version 5.2. So, we enable the
// additional features for any version past XP, i.e. >= 5.2
m_bPostXPBuild = (osvi.dwMajorVersion >= 5) && (osvi.dwMinorVersion >= 2) && (VER_NT_WORKSTATION != osvi.wProductType);
}
m_dwSkippedFrom = 0;
m_pRSOPQuery = pQuery;
m_pRSOPQueryResults = NULL;
m_hrQuery = E_FAIL;
m_bNoChooseQuery = FALSE;
// Initialize local variables
m_szDefaultUserSOM = NULL;
m_szDefaultComputerSOM = NULL;
m_pComputerObject = NULL;
m_pUserObject = NULL;
m_bDollarRemoved = FALSE;
m_bNoCurrentUser = FALSE;
m_dwDefaultUserSecurityGroupCount = 0;
m_aszDefaultUserSecurityGroups = NULL;
m_adwDefaultUserSecurityGroupsAttr = NULL;
m_dwDefaultUserWQLFilterCount = 0;
m_aszDefaultUserWQLFilters = NULL;
m_aszDefaultUserWQLFilterNames = NULL;
m_dwDefaultComputerSecurityGroupCount = 0;
m_aszDefaultComputerSecurityGroups = NULL;
m_adwDefaultComputerSecurityGroupsAttr = NULL;
m_dwDefaultComputerWQLFilterCount = 0;
m_aszDefaultComputerWQLFilters = NULL;
m_aszDefaultComputerWQLFilterNames = NULL;
m_bFinalNextClicked = FALSE;
m_pExtendedProcessing = pExtendedProcessing;
m_lPlanningFinishedPage = 0;
m_lLoggingFinishedPage = 0;
}
//-------------------------------------------------------
CRSOPWizardDlg::~CRSOPWizardDlg()
{
delete [] m_szDefaultUserSOM;
delete [] m_szDefaultComputerSOM;
if ( m_pComputerObject != NULL )
{
m_pComputerObject->Release();
m_pComputerObject = NULL;
}
if ( m_pUserObject != NULL )
{
m_pUserObject->Release();
m_pUserObject = NULL;
}
if ( m_dwDefaultUserSecurityGroupCount != 0 )
{
LocalFree( m_aszDefaultUserSecurityGroups );
LocalFree( m_adwDefaultUserSecurityGroupsAttr );
}
if ( m_dwDefaultUserWQLFilterCount != 0 )
{
LocalFree( m_aszDefaultUserWQLFilters );
LocalFree( m_aszDefaultUserWQLFilterNames );
}
if ( m_dwDefaultComputerSecurityGroupCount != 0 )
{
LocalFree( m_aszDefaultComputerSecurityGroups );
LocalFree( m_adwDefaultComputerSecurityGroupsAttr );
}
if ( m_dwDefaultComputerWQLFilterCount != 0 )
{
LocalFree( m_aszDefaultComputerWQLFilters );
LocalFree( m_aszDefaultComputerWQLFilterNames );
}
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::FreeUserData ()
// RSOP_PLANNING_MODE : Only called from RSOPTargetDlgProc
{
if ( m_pRSOPQuery->QueryType == RSOP_PLANNING_MODE )
{
FreeTargetData( m_pRSOPQuery->pUser );
m_pRSOPQuery->pUser->bAssumeWQLFiltersTrue = TRUE;
}
else
{
LocalFree( m_pRSOPQuery->szUserName );
m_pRSOPQuery->szUserName = NULL;
LocalFree( m_pRSOPQuery->szUserSid );
m_pRSOPQuery->szUserSid = NULL;
}
if ( m_szDefaultUserSOM != NULL )
{
delete [] m_szDefaultUserSOM;
m_szDefaultUserSOM = NULL;
}
if ( m_dwDefaultUserSecurityGroupCount != 0 )
{
FreeStringList( m_dwDefaultUserSecurityGroupCount, m_aszDefaultUserSecurityGroups );
m_aszDefaultUserSecurityGroups = NULL;
LocalFree( m_adwDefaultUserSecurityGroupsAttr );
m_adwDefaultUserSecurityGroupsAttr = NULL;
m_dwDefaultUserSecurityGroupCount = 0;
}
if ( m_dwDefaultUserWQLFilterCount != 0 )
{
FreeStringList( m_dwDefaultUserWQLFilterCount, m_aszDefaultUserWQLFilterNames );
m_aszDefaultUserWQLFilterNames = NULL;
FreeStringList( m_dwDefaultUserWQLFilterCount, m_aszDefaultUserWQLFilters );
m_aszDefaultUserWQLFilters = NULL;
m_dwDefaultUserWQLFilterCount = 0;
}
if ( m_pUserObject != NULL )
{
m_pUserObject->Release();
m_pUserObject = NULL;
}
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::FreeComputerData ()
// RSOP_PLANNING_MODE : Only called from RSOPTargetDlgProc
{
if ( m_pRSOPQuery->QueryType == RSOP_PLANNING_MODE )
{
FreeTargetData( m_pRSOPQuery->pComputer );
m_pRSOPQuery->pComputer->bAssumeWQLFiltersTrue = TRUE;
}
else
{
LocalFree( m_pRSOPQuery->szComputerName );
m_pRSOPQuery->szComputerName = NULL;
}
if ( m_szDefaultComputerSOM != NULL )
{
delete [] m_szDefaultComputerSOM;
m_szDefaultComputerSOM = NULL;
}
if ( m_dwDefaultComputerSecurityGroupCount != 0 )
{
FreeStringList( m_dwDefaultComputerSecurityGroupCount, m_aszDefaultComputerSecurityGroups );
m_aszDefaultComputerSecurityGroups = NULL;
LocalFree( m_adwDefaultComputerSecurityGroupsAttr );
m_adwDefaultComputerSecurityGroupsAttr = NULL;
m_dwDefaultComputerSecurityGroupCount = 0;
}
if ( m_dwDefaultComputerWQLFilterCount != 0 )
{
FreeStringList( m_dwDefaultComputerWQLFilterCount, m_aszDefaultComputerWQLFilterNames );
m_aszDefaultComputerWQLFilterNames = NULL;
FreeStringList( m_dwDefaultComputerWQLFilterCount, m_aszDefaultComputerWQLFilters );
m_aszDefaultComputerWQLFilters = NULL;
m_dwDefaultComputerWQLFilterCount = 0;
}
if ( m_pComputerObject != NULL )
{
m_pComputerObject->Release();
m_pComputerObject = NULL;
}
}
//-------------------------------------------------------
// Wizard interface
HRESULT CRSOPWizardDlg::ShowWizard( HWND hParent )
{
HRESULT hr = E_FAIL;
PROPSHEETPAGE psp;
HPROPSHEETPAGE hPage;
TCHAR szTitle[150];
TCHAR szSubTitle[300];
HPROPSHEETPAGE hShowNowPages[20];
DWORD dwCount=0, dwDiagStartPage = 0, dwPlanStartPage = 0, dwDiagFinishPage = 0, dwPlanFinishPage = 0;
hr = SetupFonts();
if ( FAILED(hr) )
{
return hr;
}
// ------------------------------
// Create all the wizard property pages
// (1) --- Welcome ---
// LoadString (g_hInstance, IDS_TITLE_WELCOME, szTitle, ARRAYSIZE(szTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
// psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.dwFlags = PSP_HIDEHEADER;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_WELCOME);
psp.pfnDlgProc = RSOPWelcomeDlgProc;
psp.lParam = (LPARAM) this;
//psp.pszHeaderTitle = szTitle;
psp.pszHeaderTitle = NULL;
psp.pszHeaderSubTitle = NULL;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (2) --- Choose Mode ---
LoadString (g_hInstance, IDS_TITLE_CHOOSEMODE, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_CHOOSEMODE, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_CHOOSEMODE);
psp.pfnDlgProc = RSOPChooseModeDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (3) --- GetComp ---
LoadString (g_hInstance, IDS_TITLE_GETCOMP, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_GETCOMP, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_GETCOMP);
psp.pfnDlgProc = RSOPGetCompDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwDiagStartPage = dwCount;
dwCount++;
// (4) --- GetUser ---
LoadString (g_hInstance, IDS_TITLE_GETUSER, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_GETUSER, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_GETUSER);
psp.pfnDlgProc = RSOPGetUserDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (5) --- GetTarget ---
LoadString (g_hInstance, IDS_TITLE_GETTARGET, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_GETTARGET, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_GETTARGET);
psp.pfnDlgProc = RSOPGetTargetDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwPlanStartPage = dwCount;
dwCount++;
// (6) --- GetDC ---
LoadString (g_hInstance, IDS_TITLE_GETDC, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_GETDC, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_GETDC);
psp.pfnDlgProc = RSOPGetDCDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (7) --- AltDirs ---
LoadString (g_hInstance, IDS_TITLE_ALTDIRS, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_ALTDIRS, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_ALTDIRS);
psp.pfnDlgProc = RSOPAltDirsDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (8) --- AltUserSec ---
LoadString (g_hInstance, IDS_TITLE_USERSECGRPS, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_USERSECGRPS, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_ALTUSERSEC);
psp.pfnDlgProc = RSOPAltUserSecDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (9) --- AltCompSec ---
LoadString (g_hInstance, IDS_TITLE_COMPSECGRPS, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_COMPSECGRPS, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_ALTCOMPSEC);
psp.pfnDlgProc = RSOPAltCompSecDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (10) --- WQLUser ---
LoadString (g_hInstance, IDS_TITLE_WQLUSER, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_WQL, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_WQLUSER);
psp.pfnDlgProc = RSOPWQLUserDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (11) --- WQLComp ---
LoadString (g_hInstance, IDS_TITLE_WQLCOMP, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_WQL, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_WQLCOMP);
psp.pfnDlgProc = RSOPWQLCompDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
// (12) --- Finished ---
LoadString (g_hInstance, IDS_TITLE_FINISHED, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_FINISHED, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
if ( m_pExtendedProcessing != NULL )
{
m_lLoggingFinishedPage = IDD_RSOP_FINISHED_INT;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_FINISHED_INT);
}
else
{
m_lLoggingFinishedPage = IDD_RSOP_FINISHED;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_FINISHED);
}
psp.pfnDlgProc = RSOPFinishedDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwDiagFinishPage = dwCount;
dwCount++;
// (13) --- Finished3 ---
LoadString (g_hInstance, IDS_TITLE_FINISHED, szTitle, ARRAYSIZE(szTitle));
LoadString (g_hInstance, IDS_SUBTITLE_FINISHED, szSubTitle, ARRAYSIZE(szSubTitle));
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.hInstance = g_hInstance;
if ( m_pExtendedProcessing != NULL )
{
m_lPlanningFinishedPage = IDD_RSOP_FINISHED3_INT;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_FINISHED3_INT);
}
else
{
m_lPlanningFinishedPage = IDD_RSOP_FINISHED3;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_FINISHED3);
}
psp.pfnDlgProc = RSOPFinishedDlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = szTitle;
psp.pszHeaderSubTitle = szSubTitle;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwPlanFinishPage = dwCount;
dwCount++;
// (14) --- Finished2 ---
::memset( &psp, 0, sizeof(PROPSHEETPAGE) );
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_HIDEHEADER;
psp.hInstance = g_hInstance;
psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_FINISHED2);
psp.pfnDlgProc = RSOPFinished2DlgProc;
psp.lParam = (LPARAM) this;
psp.pszHeaderTitle = NULL;
psp.pszHeaderSubTitle = NULL;
hPage = CreatePropertySheetPage(&psp);
if (!hPage)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: Failed to create property sheet page with %d."),
GetLastError()));
return E_FAIL;
}
hShowNowPages[dwCount] = hPage;
dwCount++;
if ( (m_pRSOPQuery->dwFlags & RSOP_FIX_QUERYTYPE) == RSOP_FIX_QUERYTYPE )
{
m_bNoChooseQuery = FALSE;
}
else
{
m_bNoChooseQuery = ((m_pRSOPQuery->dwFlags & RSOP_FIX_COMPUTER) == RSOP_FIX_COMPUTER)
|| ((m_pRSOPQuery->dwFlags & RSOP_FIX_DC) == RSOP_FIX_DC)
|| ((m_pRSOPQuery->dwFlags & RSOP_FIX_SITENAME) == RSOP_FIX_SITENAME)
|| ((m_pRSOPQuery->dwFlags & RSOP_FIX_USER) == RSOP_FIX_USER);
}
// ------------------------------
// Now create the Property Sheet
INT_PTR iRet;
PROPSHEETHEADER psph;
::memset( &psph, 0, sizeof(PROPSHEETHEADER) );
psph.dwSize = sizeof(PROPSHEETHEADER);
psph.dwFlags = PSH_WIZARD97 | PSH_HEADER | PSH_WATERMARK;
psph.hwndParent = hParent;
psph.hInstance = g_hInstance;
psph.nPages = dwCount;
psph.pszbmHeader = MAKEINTRESOURCE(IDB_HEADER);
psph.pszbmWatermark = MAKEINTRESOURCE(IDB_WIZARD);
// if (dwFlags & RSOPMSC_OVERRIDE)
if ( (m_pRSOPQuery->dwFlags & RSOP_NO_WELCOME) == RSOP_NO_WELCOME )
{
// RM: This condition translates to a case where an MSC was loaded but where parameters where passed, overriding
// the values in the MSC file.
psph.nStartPage = ( m_pRSOPQuery->QueryType == RSOP_LOGGING_MODE) ? dwDiagStartPage : dwPlanStartPage;
DebugMsg((DM_VERBOSE, TEXT("CRSOPWizardDlg::CreatePropertyPages: Showing prop sheet in override mode.")));
}
psph.phpage = hShowNowPages;
DebugMsg((DM_VERBOSE, TEXT("CRSOPWizardDlg::CreatePropertyPages: Showing prop sheet.")));
iRet = PropertySheet(&psph);
if (iRet == -1) {
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::CreatePropertyPages: PropertySheet failed with error %d."),
GetLastError()));
}
// user cancelled in the wizard
if (iRet != IDOK)
{
return S_FALSE;
}
return m_hrQuery;
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::RunQuery( HWND hParent )
{
if ( DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_RSOP_STATUSMSC),
hParent, InitRsopDlgProc, (LPARAM) this ) == -1)
{
HRESULT hr = HRESULT_FROM_WIN32( GetLastError() );
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Falied to create dialog box. 0x%x"), hr));
return hr;
}
return m_hrQuery;
}
//-------------------------------------------------------
// RSOP generation dialog method
INT_PTR CALLBACK CRSOPWizardDlg::InitRsopDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
HRESULT hr = S_OK;
TCHAR szMessage[200];
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) lParam;
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
if (pWizard)
{
CRSOPWizard::InitializeResultsList (GetDlgItem (hDlg, IDC_LIST1));
CRSOPWizard::FillResultsList (GetDlgItem (hDlg, IDC_LIST1), pWizard->m_pRSOPQuery, NULL);
}
PostMessage(hDlg, WM_INITRSOP, 0, 0);
return TRUE;
}
case WM_INITRSOP:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
// RM: InitializeRSOP used to be called here, but now we go directly to GenerateRSOPEx
pWizard->m_hrQuery = CRSOPWizard::GenerateRSOPDataEx(hDlg, pWizard->m_pRSOPQuery, &(pWizard->m_pRSOPQueryResults) );
if ( pWizard->m_hrQuery != S_OK )
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitRsopDlgProc: GenerateRSOPEx failed with 0x%x."), hr));
EndDialog(hDlg, 0);
return TRUE;
}
if ( pWizard->m_pExtendedProcessing != NULL )
{
pWizard->m_pExtendedProcessing->DoProcessing( pWizard->m_pRSOPQuery,
pWizard->m_pRSOPQueryResults,
pWizard->m_pExtendedProcessing->GetExtendedErrorInfo() );
}
EndDialog(hDlg, 1);
return TRUE;
}
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPWelcomeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
TCHAR szDefaultGPO[128];
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
SendMessage(GetDlgItem(hDlg, IDC_RSOP_BIG_BOLD1),
WM_SETFONT, (WPARAM)pWizard->m_BigBoldFont, (LPARAM)TRUE);
/*
if (!pWizard->m_hChooseBitmap)
{
pWizard->m_hChooseBitmap = (HBITMAP) LoadImage (g_hInstance,
MAKEINTRESOURCE(IDB_WIZARD),
IMAGE_BITMAP, 0, 0,
LR_DEFAULTCOLOR);
}
if (pWizard->m_hChooseBitmap)
{
SendDlgItemMessage (hDlg, IDC_BITMAP, STM_SETIMAGE,
IMAGE_BITMAP, (LPARAM) pWizard->m_hChooseBitmap);
}
*/
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_NEXT);
break;
case PSN_WIZNEXT:
if ( (pQuery->dwFlags & RSOP_FIX_QUERYTYPE) == RSOP_FIX_QUERYTYPE )
{
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETTARGET);
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETCOMP);
}
return TRUE;
}
// otherwise we fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
break;
}
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPChooseModeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg*pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( IsStandaloneComputer() || !pWizard->m_bPostXPBuild )
{
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
CheckRadioButton( hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2 );
}
else if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
CheckRadioButton( hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1 );
}
else
{
CheckRadioButton( hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2 );
}
break;
}
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_WIZNEXT:
{
// First make sure that we do not come back to this page
pQuery->dwFlags |= RSOP_NO_WELCOME;
// Now get the right mode
RSOP_QUERY_TYPE QueryType = RSOP_LOGGING_MODE;
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
QueryType = RSOP_PLANNING_MODE;
}
if ( pQuery->QueryType != QueryType )
{
// First free any mode related information in the object
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
pWizard->FreeUserData();
pWizard->FreeComputerData();
}
ChangeRSOPQueryType( pQuery, QueryType );
}
if ( QueryType == RSOP_PLANNING_MODE )
{
// Skip to the planning mode pages
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETTARGET);
return TRUE;
}
}
break;
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
break;
}
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPGetCompDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_LOGGING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_EDIT1:
if (HIWORD(wParam) == EN_CHANGE)
{
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON1:
{
TCHAR * sz;
if (ImplementBrowseButton(hDlg, DSOP_FILTER_COMPUTERS,
DSOP_DOWNLEVEL_FILTER_COMPUTERS,
DSOP_SCOPE_FLAG_DEFAULT_FILTER_COMPUTERS,
NULL, sz) == S_OK)
{
SetDlgItemText (hDlg, IDC_EDIT1, sz);
LocalFree( sz );
}
}
break;
case IDC_RADIO1:
SetDlgItemText (hDlg, IDC_EDIT1, TEXT(""));
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO2:
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), TRUE);
SetFocus (GetDlgItem(hDlg, IDC_EDIT1));
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
}
}
break;
case WM_REFRESHDISPLAY:
{
UINT n;
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
DWORD dwWizBack = PSWIZB_BACK;
if ( pWizard->m_bNoChooseQuery )
{
dwWizBack = 0;
}
if (IsDlgButtonChecked (hDlg, IDC_RADIO2) == BST_CHECKED)
{
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_GETTEXTLENGTH, 0, 0);
if (n > 0 )
{
PropSheet_SetWizButtons(GetParent(hDlg), dwWizBack | PSWIZB_NEXT);
}
else
{
PropSheet_SetWizButtons(GetParent(hDlg), dwWizBack);
}
}
else
{
PropSheet_SetWizButtons(GetParent(hDlg), dwWizBack | PSWIZB_NEXT);
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_WIZBACK:
if ( (pQuery->dwFlags & RSOP_FIX_QUERYTYPE) == RSOP_FIX_QUERYTYPE )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WELCOME);
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_CHOOSEMODE);
}
return TRUE;
case PSN_WIZNEXT:
{
LPTSTR szNewComputerName = NULL;
if (IsDlgButtonChecked (hDlg, IDC_RADIO2) == BST_CHECKED)
{
GetControlText(hDlg, IDC_EDIT1, szNewComputerName, TRUE );
if ( szNewComputerName != NULL )
{
TCHAR* szNormalizedComputerName;
// We need to handle the case where the user enters a name
// prefixed by '\\'
szNormalizedComputerName = NormalizedComputerName( szNewComputerName );
// If we detect the '\\' prefix, we must remove it since this syntax
// is not recognized by the RSoP provider
if ( szNormalizedComputerName != szNewComputerName )
{
LPTSTR szReplaceComputerName;
HRESULT hr;
ULONG ulNoChars;
ulNoChars = lstrlen(szNormalizedComputerName)+1;
szReplaceComputerName = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( szReplaceComputerName != NULL )
{
hr = StringCchCopy( szReplaceComputerName, ulNoChars, szNormalizedComputerName );
ASSERT(SUCCEEDED(hr));
}
LocalFree( szNewComputerName );
szNewComputerName = szReplaceComputerName;
}
}
}
else
{
ULONG ulNoChars = 2;
HRESULT hr;
szNewComputerName = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( szNewComputerName != NULL )
{
hr = StringCchCopy( szNewComputerName, ulNoChars, L"." );
ASSERT(SUCCEEDED(hr));
}
}
BOOL bComputerNameChanged = FALSE;
if ( pQuery->szComputerName != NULL )
{
if ( szNewComputerName && ( lstrcmpi( pQuery->szComputerName, szNewComputerName ) != 0 ) )
{
LocalFree( pQuery->szComputerName );
pQuery->szComputerName = szNewComputerName;
bComputerNameChanged = TRUE;
}
else
{
LocalFree( szNewComputerName );
}
}
else
{
pQuery->szComputerName = szNewComputerName;
bComputerNameChanged = TRUE;
}
if ( pWizard->TestAndValidateComputer (hDlg) )
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
if ( ((pQuery->dwFlags & RSOP_FIX_USER) != RSOP_FIX_USER)
&& bComputerNameChanged )
{
if ( pQuery->szUserName != NULL )
{
LocalFree( pQuery->szUserName );
pQuery->szUserName = NULL;
}
if ( pQuery->szUserSid != NULL )
{
LocalFree( pQuery->szUserSid );
pQuery->szUserSid = NULL;
}
}
}
else
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
}
if (IsDlgButtonChecked (hDlg, IDC_CHECK1) == BST_CHECKED)
{
pQuery->dwFlags |= RSOP_NO_COMPUTER_POLICY;
}
else
{
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_COMPUTER_POLICY ^ 0xffffffff);
}
}
return TRUE;
case PSN_SETACTIVE:
{
if ( (pQuery->dwFlags & RSOP_FIX_COMPUTER) == RSOP_FIX_COMPUTER )
{
CheckRadioButton( hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2 );
EnableWindow( GetDlgItem( hDlg, IDC_RADIO1 ), FALSE );
SetDlgItemText( hDlg, IDC_EDIT1, pQuery->szComputerName );
CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_CHECK1), FALSE);
}
else
{
if ( (pQuery->szComputerName != NULL) && (lstrcmpi( pQuery->szComputerName, L"." ) != 0) )
{
CheckRadioButton( hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2 );
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), TRUE);
SetDlgItemText( hDlg, IDC_EDIT1, pQuery->szComputerName );
SetFocus (GetDlgItem(hDlg, IDC_EDIT1));
}
else
{
CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), FALSE);
SetDlgItemText( hDlg, IDC_EDIT1, _T("") );
SetFocus (GetDlgItem(hDlg, IDC_RADIO1));
}
if ( (pQuery->dwFlags & RSOP_NO_USER_POLICY) == RSOP_NO_USER_POLICY )
{
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_COMPUTER_POLICY ^ 0xffffffff);
CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_CHECK1), FALSE);
}
else if ( (pQuery->dwFlags & RSOP_NO_COMPUTER_POLICY) == RSOP_NO_COMPUTER_POLICY )
{
CheckDlgButton (hDlg, IDC_CHECK1, BST_CHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_CHECK1), TRUE);
}
else
{
CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
EnableWindow(GetDlgItem(hDlg, IDC_CHECK1), TRUE);
}
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
break;
}
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPGetUserDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_LOGGING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
LVCOLUMN lvcol;
RECT rect;
HWND hLV = GetDlgItem(hDlg, IDC_LIST1);
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
GetClientRect(hLV, &rect);
ZeroMemory(&lvcol, sizeof(lvcol));
lvcol.mask = LVCF_FMT | LVCF_WIDTH;
lvcol.fmt = LVCFMT_LEFT;
lvcol.cx = rect.right - GetSystemMetrics(SM_CYHSCROLL);
ListView_InsertColumn(hLV, 0, &lvcol);
SendMessage(hLV, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_WIZNEXT:
case PSN_WIZBACK:
{
LPTSTR lpData;
HWND hList = GetDlgItem(hDlg, IDC_LIST1);
INT iSel;
if ( (pQuery->dwFlags & RSOP_FIX_USER) != RSOP_FIX_USER )
{
if ( pQuery->szUserName != NULL )
{
LocalFree( pQuery->szUserName );
pQuery->szUserName = NULL;
}
if ( pQuery->szUserSid != NULL )
{
LocalFree( pQuery->szUserSid );
pQuery->szUserSid = NULL;
}
if (IsDlgButtonChecked (hDlg, IDC_RADIO4) == BST_CHECKED)
{
pQuery->dwFlags |= RSOP_NO_USER_POLICY;
}
else
{
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_USER_POLICY ^ 0xffffffff);
if (IsDlgButtonChecked (hDlg, IDC_RADIO1))
{
LPTSTR lpTemp;
if ( IsStandaloneComputer() )
{
pQuery->szUserName = MyGetUserName (NameUnknown);
}
else
{
pQuery->szUserName = MyGetUserName (NameSamCompatible);
}
HRESULT hr;
ULONG ulNoChars = 2;
pQuery->szUserSid = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( pQuery->szUserSid != NULL )
{
hr = StringCchCopy( pQuery->szUserSid, ulNoChars, TEXT(".") );
ASSERT(SUCCEEDED(hr));
}
}
else
{
iSel = (INT) SendMessage(hList, LVM_GETNEXTITEM, (WPARAM) -1, MAKELPARAM(LVNI_SELECTED, 0));
if (iSel != -1)
{
pQuery->szUserName = (TCHAR*)LocalAlloc( LPTR, 200 * sizeof(TCHAR) );
if ( pQuery->szUserName != NULL )
{
LVITEM item;
ZeroMemory (&item, sizeof(item));
item.mask = LVIF_TEXT | LVIF_PARAM;
item.iItem = iSel;
item.pszText = pQuery->szUserName;
item.cchTextMax = 200;
if (SendMessage(hList, LVM_GETITEM, 0, (LPARAM) &item))
{
lpData = (LPTSTR) item.lParam;
if (lpData)
{
ULONG ulNoChars;
HRESULT hr;
ulNoChars = lstrlen(lpData) + 1;
pQuery->szUserSid = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( pQuery->szUserSid != NULL )
{
hr = StringCchCopy( pQuery->szUserSid, ulNoChars, lpData );
ASSERT(SUCCEEDED(hr));
}
}
}
}
}
} // if (IsDlgButtonChecked (hDlg, IDC_RADIO1))
}
}
if ( ((NMHDR FAR*)lParam)->code == PSN_WIZNEXT )
{
// Skip to the last page in the wizard
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lLoggingFinishedPage);
return TRUE;
}
}
break;
case PSN_SETACTIVE:
{
HRESULT hr;
BOOL bFixedUserFound;
BOOL bCurrentUserFound;
HWND hList = GetDlgItem(hDlg, IDC_LIST1);
SendMessage(hList, LVM_DELETEALLITEMS, 0 ,0);
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
hr = pWizard->FillUserList (hList, &bCurrentUserFound, &bFixedUserFound);
if ( FAILED(hr) )
{
ReportError (hDlg, hr, IDS_ENUMUSERSFAILED);
// RsopEnumerateUsers failed. It should be safe to disable user policy setting in all cases
pQuery->dwFlags |= RSOP_NO_USER_POLICY;
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
}
else if ( (pQuery->dwFlags & RSOP_FIX_USER) == RSOP_FIX_USER )
{
if ( bFixedUserFound )
{
// Disable current user radio button
CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
}
}
else
{
// If there is no computer policy, then we should at least have user policy, so disable
if ( (pQuery->dwFlags & RSOP_NO_COMPUTER_POLICY) == RSOP_NO_COMPUTER_POLICY )
{
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_USER_POLICY ^ 0xffffffff);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);
}
else if ( ((pQuery->dwFlags & RSOP_NO_USER_POLICY) == RSOP_NO_USER_POLICY)
|| (ListView_GetItemCount (hList) == 0) )
{
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
}
else
{
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
}
if ( (!lstrcmpi( pQuery->szComputerName, TEXT("."))) && bCurrentUserFound )
{
pWizard->m_bNoCurrentUser = FALSE;
}
else
{
pWizard->m_bNoCurrentUser = TRUE;
}
if ( (pQuery->szUserSid != NULL)
&& !lstrcmpi( pQuery->szUserSid, TEXT("."))
&& !pWizard->m_bNoCurrentUser )
{
CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
}
else if ( (pQuery->szUserSid == NULL) && !pWizard->m_bNoCurrentUser )
{
CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
}
else if ( ListView_GetItemCount (hList) != 0 )
{
CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);
if ( pQuery->szUserName != NULL )
{
LVFINDINFO FindInfo;
LVITEM item;
INT iRet;
ZeroMemory (&FindInfo, sizeof(FindInfo));
FindInfo.flags = LVFI_STRING;
FindInfo.psz = pQuery->szUserName;
iRet = (INT) SendMessage (hList, LVM_FINDITEM,
(WPARAM) -1, (LPARAM) &FindInfo);
if (iRet != -1)
{
ZeroMemory (&item, sizeof(item));
item.mask = LVIF_STATE;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hList, LVM_SETITEMSTATE, (WPARAM) -1, (LPARAM) &item);
ZeroMemory (&item, sizeof(item));
item.mask = LVIF_STATE;
item.iItem = iRet;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hList, LVM_SETITEMSTATE, (WPARAM) iRet, (LPARAM) &item);
}
}
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
}
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
case LVN_DELETEITEM:
{
NMLISTVIEW * pNMListView = (NMLISTVIEW *) lParam;
if (pNMListView && pNMListView->lParam)
{
delete [] ((LPTSTR)pNMListView->lParam);
}
}
break;
}
}
break;
case WM_COMMAND:
{
switch (LOWORD(wParam))
{
case IDC_RADIO1:
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO2:
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO3:
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO4:
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
}
}
break;
case WM_REFRESHDISPLAY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( (pQuery->dwFlags & RSOP_FIX_USER) == RSOP_FIX_USER )
{
break;
}
int iListCount = ListView_GetItemCount(GetDlgItem(hDlg, IDC_LIST1));
if (IsDlgButtonChecked (hDlg, IDC_RADIO4) == BST_CHECKED)
{
// Disable list of users while "Do not display user policy" radio is selected
EnableWindow(GetDlgItem(hDlg, IDC_LIST1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_RADIO1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_RADIO2), FALSE);
if ( pWizard->m_bNoCurrentUser && (iListCount == 0)
&& ( (pQuery->dwFlags & RSOP_NO_COMPUTER_POLICY) == RSOP_NO_COMPUTER_POLICY ) )
{
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
}
else
{
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
}
}
else
{
// Enable/disable inner radio buttons
EnableWindow(GetDlgItem(hDlg, IDC_RADIO1), !pWizard->m_bNoCurrentUser);
EnableWindow(GetDlgItem(hDlg, IDC_RADIO2), iListCount != 0);
if ( !pWizard->m_bNoCurrentUser || (iListCount != 0) )
{
if ( (pQuery->dwFlags & RSOP_NO_COMPUTER_POLICY) == RSOP_NO_COMPUTER_POLICY )
{
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_USER_POLICY ^ 0xffffffff);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), TRUE);
}
if (IsDlgButtonChecked (hDlg, IDC_RADIO2) == BST_CHECKED)
{
EnableWindow(GetDlgItem(hDlg, IDC_LIST1), TRUE);
if ( iListCount != 0 )
{
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
SetFocus (GetDlgItem(hDlg, IDC_LIST1));
}
else
{
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
}
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_LIST1), FALSE);
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
}
}
else
{
if ( (pQuery->dwFlags & RSOP_NO_COMPUTER_POLICY) == RSOP_NO_COMPUTER_POLICY )
{
// If the user said no computer data but he has access to no users,
// enable on back button and disable the checkbox
pQuery->dwFlags = pQuery->dwFlags & (RSOP_NO_USER_POLICY ^ 0xffffffff);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
}
else
{
// This is an error condition where ::FillUserList failed
EnableWindow(GetDlgItem(hDlg, IDC_LIST1), FALSE);
CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
}
}
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPGetTargetDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
LPTSTR lpText, lpPath;
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( pWizard != NULL )
{
lpText = MyGetUserName(NameSamCompatible);
if (lpText)
{
SetDlgItemText (hDlg, IDC_EDIT6, lpText);
LocalFree (lpText);
}
lpText = MyGetUserName(NameFullyQualifiedDN);
if (lpText)
{
lpPath = pWizard->GetDefaultSOM(lpText);
if (lpPath)
{
SetDlgItemText (hDlg, IDC_EDIT5, lpPath);
delete [] lpPath;
}
LocalFree (lpText);
}
}
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_RADIO1:
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), TRUE);
if ( pQuery->pUser->szSOM != NULL )
{
SetDlgItemText( hDlg, IDC_EDIT1, pQuery->pUser->szSOM );
}
SetDlgItemText (hDlg, IDC_EDIT2, TEXT(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO2:
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), TRUE);
if ( pQuery->pUser->szName != NULL )
{
SetDlgItemText( hDlg, IDC_EDIT2, pQuery->pUser->szName );
}
SetDlgItemText (hDlg, IDC_EDIT1, TEXT(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO3:
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), TRUE);
if ( pQuery->pComputer->szSOM != NULL )
{
SetDlgItemText( hDlg, IDC_EDIT3, pQuery->pComputer->szSOM );
}
SetDlgItemText (hDlg, IDC_EDIT4, TEXT(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_RADIO4:
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), TRUE);
if ( pQuery->pComputer->szName != NULL )
{
// RM: The computer name account in the DS actually has a '$' at the end. We strip it here for display
// purposes, but will add it again ...
if ( (wcslen(pQuery->pComputer->szName) >= 1)
&& (pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)-1] == L'$') )
{
pWizard->m_bDollarRemoved = TRUE;
pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)-1] = L'\0';
}
SetDlgItemText(hDlg, IDC_EDIT4, pQuery->pComputer->szName );
if ( pWizard->m_bDollarRemoved )
{
pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)] = L'$';
pWizard->m_bDollarRemoved = FALSE;
}
}
SetDlgItemText (hDlg, IDC_EDIT3, TEXT(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case IDC_EDIT1:
case IDC_EDIT2:
case IDC_EDIT3:
case IDC_EDIT4:
if (HIWORD(wParam) == EN_CHANGE)
{
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BROWSE1:
{
DSBROWSEINFO dsbi = {0};
TCHAR *szResult;
TCHAR szTitle[256];
TCHAR szCaption[256];
dsbi.hwndOwner = hDlg;
dsbi.pszCaption = szTitle;
dsbi.pszTitle = szCaption;
dsbi.cbStruct = sizeof(dsbi);
dsbi.dwFlags = DSBI_ENTIREDIRECTORY;
dsbi.pfnCallback = DsBrowseCallback;
szResult = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*4000);
if (szResult) {
dsbi.pszPath = szResult;
dsbi.cchPath = 4000;
LoadString(g_hInstance,
IDS_BROWSE_USER_OU_TITLE,
szTitle,
ARRAYSIZE(szTitle));
LoadString(g_hInstance,
IDS_BROWSE_USER_OU_CAPTION,
szCaption,
ARRAYSIZE(szCaption));
if (IDOK == DsBrowseForContainer(&dsbi))
{
LPWSTR szDN;
HRESULT hr;
// skipping 7 chars for LDAP:// in the szResult
hr = UnEscapeLdapPath(szResult+7, &szDN);
if (FAILED(hr))
{
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
}
else {
SetDlgItemText(hDlg, IDC_EDIT1, szDN);
LocalFree(szDN);
}
}
LocalFree(szResult);
}
}
break;
case IDC_BROWSE2:
{
TCHAR * sz;
if (ImplementBrowseButton(hDlg, DSOP_FILTER_USERS,
DSOP_DOWNLEVEL_FILTER_USERS,
DSOP_SCOPE_FLAG_DEFAULT_FILTER_USERS,
NULL, sz) == S_OK)
{
SetDlgItemText (hDlg, IDC_EDIT2, sz);
LocalFree( sz );
}
}
break;
case IDC_BROWSE3:
{
DSBROWSEINFO dsbi = {0};
TCHAR *szResult;
TCHAR szTitle[256];
TCHAR szCaption[256];
dsbi.hwndOwner = hDlg;
dsbi.pszCaption = szTitle;
dsbi.pszTitle = szCaption;
dsbi.cbStruct = sizeof(dsbi);
dsbi.dwFlags = DSBI_ENTIREDIRECTORY;
dsbi.pfnCallback = DsBrowseCallback;
szResult = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*4000);
if (szResult) {
dsbi.pszPath = szResult;
dsbi.cchPath = 4000;
LoadString(g_hInstance,
IDS_BROWSE_COMPUTER_OU_TITLE,
szTitle,
ARRAYSIZE(szTitle));
LoadString(g_hInstance,
IDS_BROWSE_COMPUTER_OU_CAPTION,
szCaption,
ARRAYSIZE(szCaption));
if (IDOK == DsBrowseForContainer(&dsbi))
{
LPWSTR szDN;
HRESULT hr;
// skipping 7 chars for LDAP:// in the szResult
hr = UnEscapeLdapPath(szResult+7, &szDN);
if (FAILED(hr))
{
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
}
else {
SetDlgItemText(hDlg, IDC_EDIT3, szDN);
LocalFree(szDN);
}
}
LocalFree(szResult);
}
}
break;
case IDC_BROWSE4:
{
TCHAR * sz;
if (ImplementBrowseButton(hDlg, DSOP_FILTER_COMPUTERS,
DSOP_DOWNLEVEL_FILTER_COMPUTERS,
DSOP_SCOPE_FLAG_DEFAULT_FILTER_COMPUTERS,
NULL, sz) == S_OK)
{
SetDlgItemText (hDlg, IDC_EDIT4, sz);
LocalFree( sz );
}
}
break;
}
}
break;
case WM_REFRESHDISPLAY:
{
UINT n;
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_GETTEXTLENGTH, 0, 0);
if (n == 0)
{
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT2), WM_GETTEXTLENGTH, 0, 0);
}
if (n == 0)
{
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT3), WM_GETTEXTLENGTH, 0, 0);
}
if (n == 0)
{
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT4), WM_GETTEXTLENGTH, 0, 0);
}
DWORD dwWizBack = PSWIZB_BACK;
if ( pWizard->m_bNoChooseQuery )
{
dwWizBack = 0;
}
if (n > 0 )
{
PropSheet_SetWizButtons(GetParent(hDlg), dwWizBack | PSWIZB_NEXT);
}
else
{
PropSheet_SetWizButtons(GetParent(hDlg), dwWizBack);
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
{
// RM: Fill dialog with current user values
if ( pQuery->pUser->szName != NULL )
{
CheckDlgButton (hDlg, IDC_RADIO2, BST_CHECKED);
SetDlgItemText(hDlg, IDC_EDIT2, pQuery->pUser->szName);
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), TRUE);
CheckDlgButton (hDlg, IDC_RADIO1, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT1, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), FALSE);
}
else if ( pQuery->pUser->szSOM != NULL )
{
CheckDlgButton (hDlg, IDC_RADIO1, BST_CHECKED);
SetDlgItemText(hDlg, IDC_EDIT1, pQuery->pUser->szSOM);
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), TRUE);
CheckDlgButton (hDlg, IDC_RADIO2, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT2, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
}
else
{
CheckDlgButton (hDlg, IDC_RADIO1, BST_CHECKED);
SetDlgItemText(hDlg, IDC_EDIT1, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), TRUE);
CheckDlgButton (hDlg, IDC_RADIO2, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT2, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
}
// Disable certain items if the user must remain fixed
if ( (pQuery->dwFlags & RSOP_FIX_USER) == RSOP_FIX_USER )
{
EnableWindow (GetDlgItem (hDlg, IDC_RADIO1), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_RADIO2), FALSE);
if ( pQuery->pUser->szName != NULL )
{
EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
}
else if ( pQuery->pUser->szSOM != NULL )
{
EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), FALSE);
}
}
// RM: Fill dialog with current computer values
if ( pQuery->pComputer->szName != NULL )
{
CheckDlgButton (hDlg, IDC_RADIO4, BST_CHECKED);
// RM: The computer name account in the DS actually has a '$' at the end. We strip it here for display
// purposes, but will add it again ...
if ( (wcslen(pQuery->pComputer->szName) >= 1)
&& (pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)-1] == L'$') )
{
pWizard->m_bDollarRemoved = TRUE;
pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)-1] = L'\0';
}
SetDlgItemText(hDlg, IDC_EDIT4, pQuery->pComputer->szName );
if ( pWizard->m_bDollarRemoved )
{
pQuery->pComputer->szName[wcslen(pQuery->pComputer->szName)] = L'$';
pWizard->m_bDollarRemoved = FALSE;
}
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), TRUE);
CheckDlgButton (hDlg, IDC_RADIO3, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT3, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), FALSE);
}
else if ( pQuery->pComputer->szSOM != NULL )
{
CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
SetDlgItemText(hDlg, IDC_EDIT3, pQuery->pComputer->szSOM);
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), TRUE);
CheckDlgButton (hDlg, IDC_RADIO4, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT4, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
}
else
{
CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
SetDlgItemText(hDlg, IDC_EDIT3, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), TRUE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), TRUE);
CheckDlgButton (hDlg, IDC_RADIO4, BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT4, _T(""));
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
}
// Disable certain items if the computer must remain fixed
if ( (pQuery->dwFlags & RSOP_FIX_COMPUTER) == RSOP_FIX_COMPUTER )
{
EnableWindow (GetDlgItem (hDlg, IDC_RADIO3), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_RADIO4), FALSE);
if ( pQuery->pComputer->szName != NULL )
{
EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
}
else if ( pQuery->pComputer->szSOM != NULL )
{
EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), FALSE);
EnableWindow (GetDlgItem (hDlg, IDC_BROWSE3), FALSE);
}
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case PSN_WIZBACK:
if ( (pQuery->dwFlags & RSOP_FIX_QUERYTYPE) == RSOP_FIX_QUERYTYPE )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WELCOME);
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_CHOOSEMODE);
}
return TRUE;
case PSN_WIZNEXT:
{
HRESULT hr;
IDirectoryObject * pUserObject = NULL;
IDirectoryObject * pComputerObject = NULL;
LPTSTR lpUserName = NULL, lpUserSOM = NULL;
LPTSTR lpComputerName = NULL, lpComputerSOM = NULL;
LPTSTR lpFullName;
BOOL bUserChanged = TRUE;
BOOL bComputerChanged = TRUE;
SetWaitCursor();
// Get the user and dn name
if (IsDlgButtonChecked(hDlg, IDC_RADIO1) == BST_CHECKED)
{
GetControlText(hDlg, IDC_EDIT1, lpUserSOM, FALSE);
if (lpUserSOM)
{
pWizard->EscapeString (&lpUserSOM);
hr = pWizard->TestSOM (lpUserSOM, hDlg);
if (FAILED(hr))
{
if (hr != E_INVALIDARG)
{
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
}
delete [] lpUserSOM;
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
}
}
else
{
GetControlText(hDlg, IDC_EDIT2, lpUserName, FALSE);
if ( lpUserName )
{
lpUserSOM = ConvertName(lpUserName);
if (lpUserName && !lpUserSOM)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::RSOPGetTargetDlgProc: Failed to convert username %s to DN name with %d."), lpUserName, GetLastError()));
if (GetLastError() == ERROR_FILE_NOT_FOUND)
{
ReportError (hDlg, 0, IDS_NOUSER2);
}
else
{
ReportError (hDlg, GetLastError(), IDS_NOUSER);
}
delete [] lpUserName;
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
pWizard->EscapeString (&lpUserSOM);
}
}
if (lpUserSOM)
{
ULONG ulNoChars;
ulNoChars = lstrlen(lpUserSOM) + 10;
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpFullName)
{
hr = StringCchCopy (lpFullName, ulNoChars, TEXT("LDAP://"));
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpFullName, ulNoChars, lpUserSOM);
}
if (SUCCEEDED(hr))
{
hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pUserObject);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::RSOPGetTargetDlgProc: Failed to bind to user object %s with %d."), lpFullName, hr));
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
if (lpUserName)
{
delete [] lpUserName;
}
LocalFree (lpFullName);
delete [] lpUserSOM;
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
}
LocalFree (lpFullName);
}
}
// Get the computer and dn name
if (IsDlgButtonChecked(hDlg, IDC_RADIO3) == BST_CHECKED)
{
GetControlText(hDlg, IDC_EDIT3, lpComputerSOM, FALSE);
if (lpComputerSOM)
{
pWizard->EscapeString (&lpComputerSOM);
hr = pWizard->TestSOM (lpComputerSOM, hDlg);
if (FAILED(hr))
{
if (hr != E_INVALIDARG)
{
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
}
delete [] lpComputerSOM;
if (lpUserName)
{
delete [] lpUserName;
}
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (pUserObject)
{
pUserObject->Release();
pUserObject = NULL;
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
}
}
else
{
GetControlText(hDlg, IDC_EDIT4, lpComputerName, FALSE );
if (lpComputerName)
{
ULONG ulNoChars;
ulNoChars = lstrlen(lpComputerName) + 2;
LPTSTR lpTempName = new TCHAR [ulNoChars];
if (lpTempName)
{
hr = StringCchCopy (lpTempName, ulNoChars, lpComputerName);
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpTempName, ulNoChars, TEXT("$"));
}
if (SUCCEEDED(hr))
{
lpComputerSOM = ConvertName(lpTempName);
delete [] lpComputerName;
lpComputerName = lpTempName;
}
}
}
if (lpComputerName && !lpComputerSOM)
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::RSOPGetTargetDlgProc: Failed to convert computername %s to DN name with %d."), lpComputerName, GetLastError()));
if (GetLastError() == ERROR_FILE_NOT_FOUND)
{
ReportError (hDlg, 0, IDS_NOCOMPUTER2);
}
else
{
ReportError (hDlg, GetLastError(), IDS_NOCOMPUTER);
}
delete [] lpComputerName;
if (lpUserName)
{
delete [] lpUserName;
}
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (pUserObject)
{
pUserObject->Release();
pUserObject = NULL;
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
pWizard->EscapeString (&lpComputerSOM);
}
if (lpComputerSOM)
{
ULONG ulNoChars;
ulNoChars = lstrlen(lpComputerSOM) + 10;
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpFullName)
{
hr = StringCchCopy (lpFullName, ulNoChars, TEXT("LDAP://"));
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpFullName, ulNoChars, lpComputerSOM);
}
if (SUCCEEDED(hr))
{
hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pComputerObject);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPWizardDlg::RSOPGetTargetDlgProc: Failed to bind to computer object %s with %d."), lpFullName, hr));
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
if (lpComputerName)
{
delete [] lpComputerName;
}
LocalFree (lpFullName);
delete [] lpComputerSOM;
if (lpUserName)
{
delete [] lpUserName;
}
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (pUserObject)
{
pUserObject->Release();
pUserObject = NULL;
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
LocalFree (lpFullName);
}
}
}
// Now check that both user and computer are in the same forest
if ( (lpUserSOM != NULL) && (lpComputerSOM != NULL) )
{
LPTSTR szComputerForest( NULL );
LPTSTR szUserForest( NULL );
BOOL bDifferentForests( FALSE );
hr = GetForestFromContainer( lpUserSOM, &szUserForest );
if ( SUCCEEDED(hr) )
{
hr = GetForestFromContainer( lpComputerSOM, &szComputerForest );
if ( SUCCEEDED(hr) )
{
if ( CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE, szComputerForest, -1,
szUserForest, -1 ) != CSTR_EQUAL )
{
bDifferentForests = TRUE;
hr = E_INVALIDARG;
}
LocalFree( szComputerForest );
}
LocalFree( szUserForest );
}
if ( FAILED(hr) )
{
if ( bDifferentForests )
{
ReportError (hDlg, hr, IDS_NOCROSSFORESTALLOWED);
}
else
{
ReportError (hDlg, hr, IDS_CROSSFORESTFAILED);
}
if (lpComputerName)
{
delete [] lpComputerName;
}
delete [] lpComputerSOM;
if (lpUserName)
{
delete [] lpUserName;
}
delete [] lpUserSOM;
if (pUserObject)
{
pUserObject->Release();
pUserObject = NULL;
}
if (pComputerObject)
{
pComputerObject->Release();
pComputerObject = NULL;
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
}
// Store the user information
if ( (pQuery->pUser->szName != NULL) && (lpUserName != NULL) && (!lstrcmpi(pQuery->pUser->szName, lpUserName)))
{
bUserChanged = FALSE;
// Just reinitialize and reuse what we might need
if ( pWizard->m_szDefaultUserSOM == NULL )
{
pWizard->m_szDefaultUserSOM = pWizard->GetDefaultSOM (lpUserSOM);
}
if ( pWizard->m_pUserObject == NULL )
{
pWizard->m_pUserObject = pUserObject;
pUserObject = NULL;
}
// Now delete the unneeded stuff
delete [] lpUserName;
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (pUserObject)
{
pUserObject->Release();
pUserObject = NULL;
}
}
else if ( (pQuery->pUser->szName == NULL) && (lpUserName == NULL)
&& (pQuery->pUser->szSOM != NULL) && (lpUserSOM != NULL)
&& (!lstrcmpi( pQuery->pUser->szSOM, lpUserSOM)))
{
bUserChanged = FALSE;
// Just reinitialize and reuse what we might need
if ( pWizard->m_szDefaultUserSOM == NULL )
{
pWizard->m_szDefaultUserSOM = pWizard->GetDefaultSOM (lpUserSOM);
}
if ( pWizard->m_pUserObject == NULL )
{
pWizard->m_pUserObject = pUserObject;
pUserObject = NULL;
}
// Now delete the unneeded stuff
delete [] lpUserSOM;
if (pUserObject)
{
pUserObject->Release();
}
}
else if ( (pQuery->pUser->szName == NULL) && (lpUserName == NULL)
&& (pQuery->pUser->szSOM == NULL) && (lpUserSOM == NULL) )
{
bUserChanged = FALSE;
// No stuff to delete!
}
else
{
pWizard->FreeUserData();
if ( lpUserName != NULL )
{
ULONG ulNoChars;
ulNoChars = lstrlen(lpUserName)+1;
pQuery->pUser->szName = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( pQuery->pUser->szName != NULL )
{
hr = StringCchCopy( pQuery->pUser->szName, ulNoChars, lpUserName );
ASSERT(SUCCEEDED(hr));
}
delete [] lpUserName;
pWizard->m_szDefaultUserSOM = pWizard->GetDefaultSOM (lpUserSOM);
delete [] lpUserSOM;
}
else if ( lpUserSOM != NULL )
{
pQuery->pUser->szSOM = NULL;
(void)UnEscapeLdapPath(lpUserSOM, &(pQuery->pUser->szSOM));
delete [] lpUserSOM;
}
pWizard->m_pUserObject = pUserObject;
}
// Store the computer information
if ( (pQuery->pComputer->szName != NULL) && (lpComputerName != NULL) && !lstrcmpi(pQuery->pComputer->szName, lpComputerName) )
{
bComputerChanged = FALSE;
// Just reinitialize and reuse what we might need
if ( pWizard->m_szDefaultComputerSOM == NULL )
{
pWizard->m_szDefaultComputerSOM = pWizard->GetDefaultSOM (lpComputerSOM);
}
if ( pWizard->m_pComputerObject== NULL )
{
pWizard->m_pComputerObject = pComputerObject;
pComputerObject = NULL;
}
// Now delete the unneeded stuff
delete [] lpComputerName;
if (lpComputerSOM)
{
delete [] lpComputerSOM;
}
if (pComputerObject)
{
pComputerObject->Release();
pComputerObject = NULL;
}
}
else if ( (pQuery->pComputer->szName == NULL) && (lpComputerName == NULL)
&& (pQuery->pComputer->szSOM != NULL) && (lpComputerSOM != NULL)
&& !lstrcmpi(pQuery->pComputer->szSOM, lpComputerSOM) )
{
bComputerChanged = FALSE;
// Just reinitialize and reuse what we might need
if ( pWizard->m_szDefaultComputerSOM == NULL )
{
pWizard->m_szDefaultComputerSOM = pWizard->GetDefaultSOM (lpComputerSOM);
}
if ( pWizard->m_pComputerObject== NULL )
{
pWizard->m_pComputerObject = pComputerObject;
pComputerObject = NULL;
}
// Now delete the unneeded stuff
delete [] lpComputerSOM;
if (pComputerObject)
{
pComputerObject->Release();
pComputerObject = NULL;
}
}
else if ( (pQuery->pComputer->szName == NULL) && (lpComputerName == NULL)
&& (pQuery->pComputer->szSOM == NULL) && (lpComputerSOM == NULL) )
{
bComputerChanged = FALSE;
// No stuff to delete!
}
else
{
pWizard->FreeComputerData ();
if ( lpComputerName != NULL )
{
ULONG ulNoChars;
ulNoChars = lstrlen(lpComputerName)+1;
pQuery->pComputer->szName = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( pQuery->pComputer->szName != NULL )
{
hr = StringCchCopy( pQuery->pComputer->szName, ulNoChars, lpComputerName );
ASSERT(SUCCEEDED(hr));
}
delete [] lpComputerName;
pWizard->m_szDefaultComputerSOM = pWizard->GetDefaultSOM (lpComputerSOM);
delete [] lpComputerSOM;
}
else if ( lpComputerSOM != NULL )
{
pQuery->pComputer->szSOM = NULL;
(void)UnEscapeLdapPath(lpComputerSOM, &(pQuery->pComputer->szSOM));
delete [] lpComputerSOM;
}
pWizard->m_pComputerObject = pComputerObject;
}
if ( (pQuery->dwFlags & RSOP_FIX_SITENAME) == RSOP_FIX_SITENAME )
{
LPTSTR szSiteFriendly = NULL;
if ( GetSiteFriendlyName( pQuery->szSite, &szSiteFriendly ) )
{
ULONG ulNoChars;
ulNoChars = lstrlen(szSiteFriendly)+1;
LocalFree( pQuery->szSite );
pQuery->szSite = (TCHAR*)LocalAlloc( LPTR, ulNoChars * sizeof(TCHAR) );
if ( pQuery->szSite != NULL )
{
hr = StringCchCopy( pQuery->szSite, ulNoChars, szSiteFriendly );
ASSERT(SUCCEEDED(hr));
}
delete [] szSiteFriendly;
}
}
// RM-TODO: Do not delete site name if it is already set and ? didn't change. First find out what ? is!
else if ( (bComputerChanged || bUserChanged) && (pQuery->szSite != NULL) )
{
LocalFree( pQuery->szSite );
pQuery->szSite = NULL;
}
if ( bUserChanged || bComputerChanged || (pQuery->szDomainController == NULL) )
{
// Set pQuery->szDomainController to the primary DC
LPTSTR szDomain = NULL;
// Determine the focused domain so we can focus on the correct DC.
if ( pQuery->pComputer->szName != NULL )
{
// Try and get the computer's domain
szDomain = ExtractDomain( pQuery->pComputer->szName );
}
if ( (szDomain == NULL) && (pQuery->pComputer->szSOM != NULL) )
{
// Try and get the computer's domain from the SOM
szDomain = GetDomainFromSOM( pQuery->pComputer->szSOM );
}
if ( (szDomain == NULL) && (pQuery->pUser->szName != NULL) )
{
// Try and get the user's domain
szDomain = ExtractDomain( pQuery->pUser->szName );
}
if ( (szDomain == NULL) && (pQuery->pUser->szSOM != NULL) )
{
// Try and get the user's domain from the SOM
szDomain = GetDomainFromSOM( pQuery->pUser->szSOM );
}
if ( szDomain == NULL )
{
// Use the local domain
LPTSTR szName;
szName = MyGetUserName(NameSamCompatible);
if ( szName != NULL )
{
szDomain = ExtractDomain(szName);
LocalFree( szName );
}
}
// RM: This is a hack! The command line parameter passed as the preferred DC is being used lower down
// in this method as a parameter to GetDCName - this is the only known place where it is used.
LPTSTR szInheritServer = NULL;
if ( (pQuery->dwFlags & RSOP_FIX_DC) == RSOP_FIX_DC )
{
szInheritServer = pQuery->szDomainController;
pQuery->szDomainController = NULL;
}
if ( pQuery->szDomainController != NULL )
{
LocalFree( pQuery->szDomainController );
pQuery->szDomainController = NULL;
}
LPTSTR lpDCName;
lpDCName = GetDCName (szDomain, szInheritServer, NULL, FALSE, 0, DS_RETURN_DNS_NAME);
if ( lpDCName != NULL )
{
pQuery->szDomainController = lpDCName;
lpDCName = NULL;
}
if ( szDomain != NULL )
{
delete [] szDomain;
}
}
// Reset the loopback mode if the computer or user is now empty
if ( (pQuery->LoopbackMode != RSOP_LOOPBACK_NONE) && (bComputerChanged || bUserChanged) )
{
if ( ((pQuery->pComputer->szName == NULL) && (pQuery->pComputer->szSOM == NULL))
|| ((pQuery->pUser->szName == NULL) && (pQuery->pUser->szSOM == NULL)) )
pQuery->LoopbackMode = RSOP_LOOPBACK_NONE;
}
ClearWaitCursor();
}
if (SendMessage(GetDlgItem(hDlg, IDC_BUTTON1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_GETTARGET;
// skip to the final pages
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
break;
case PSN_WIZFINISH:
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPGetDCDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
BOOL bEnable;
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_CHECK2:
if (SendMessage (GetDlgItem(hDlg, IDC_CHECK2), BM_GETCHECK, 0, 0))
{
pQuery->LoopbackMode = RSOP_LOOPBACK_REPLACE;
SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_CHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_UNCHECKED, 0);
bEnable = TRUE;
if ( (NULL == pQuery->pUser->szName) && (NULL == pQuery->pUser->szSOM) )
{
bEnable = FALSE;
}
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), bEnable);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), bEnable);
}
else
{
pQuery->LoopbackMode = RSOP_LOOPBACK_NONE;
SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_UNCHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_UNCHECKED, 0);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
}
break;
case IDC_RADIO2:
pQuery->LoopbackMode = RSOP_LOOPBACK_REPLACE;
break;
case IDC_RADIO3:
pQuery->LoopbackMode = RSOP_LOOPBACK_MERGE;
break;
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
{
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
SetWaitCursor();
if ( pQuery->bSlowNetworkConnection )
{
CheckDlgButton(hDlg, IDC_CHECK1, BST_CHECKED);
}
else
{
CheckDlgButton(hDlg, IDC_CHECK1, BST_UNCHECKED);
}
pWizard->InitializeSitesInfo (hDlg);
if ( (RSOP_LOOPBACK_NONE == pQuery->LoopbackMode)
|| ( (RSOP_LOOPBACK_MERGE == pQuery->LoopbackMode)
&& ( ((NULL == pQuery->pUser->szName) && (NULL == pQuery->pUser->szSOM))
|| ((NULL == pQuery->pComputer->szName) && (NULL == pQuery->pComputer->szSOM)) ) )
|| ( (RSOP_LOOPBACK_REPLACE == pQuery->LoopbackMode)
&& (NULL == pQuery->pComputer->szName) && (NULL == pQuery->pComputer->szSOM) ) )
{
pQuery->LoopbackMode = RSOP_LOOPBACK_NONE;
SendMessage (GetDlgItem(hDlg, IDC_CHECK2), BM_SETCHECK, BST_UNCHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_UNCHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_UNCHECKED, 0);
if ( (NULL == pQuery->pComputer->szName) && (NULL == pQuery->pComputer->szSOM) )
{
EnableWindow (GetDlgItem(hDlg, IDC_CHECK2), FALSE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_CHECK2), TRUE);
}
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);
}
else
{
CheckDlgButton( hDlg, IDC_CHECK2, BST_CHECKED );
if ( RSOP_LOOPBACK_REPLACE == pQuery->LoopbackMode )
{
SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_CHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_UNCHECKED, 0);
}
else
{
SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_UNCHECKED, 0);
SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_CHECKED, 0);
}
bEnable = TRUE;
if ( (NULL == pQuery->pUser->szName) && (NULL == pQuery->pUser->szSOM) )
{
bEnable = FALSE;
}
EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), bEnable);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), bEnable);
}
ClearWaitCursor();
}
break;
case PSN_WIZBACK:
case PSN_WIZNEXT:
{
SetWaitCursor();
GetControlText(hDlg, IDC_COMBO1, pQuery->szSite, TRUE);
if ( pQuery->szSite != NULL )
{
TCHAR szName[30];
LoadString (g_hInstance, IDS_NONE, szName, ARRAYSIZE(szName));
if ( !lstrcmpi( pQuery->szSite, szName ) )
{
LocalFree( pQuery->szSite );
pQuery->szSite = NULL;
}
}
if (SendMessage(GetDlgItem(hDlg, IDC_CHECK1), BM_GETCHECK, 0, 0))
{
pQuery->bSlowNetworkConnection= TRUE;
}
else
{
pQuery->bSlowNetworkConnection = FALSE;
}
ClearWaitCursor();
if ( ((NMHDR FAR*)lParam)->code == PSN_WIZNEXT )
{
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_GETDC;
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
if ( (NULL == pQuery->pUser->szName) && (NULL == pQuery->pComputer->szName) )
{
pWizard->m_dwSkippedFrom = IDD_RSOP_GETDC;
if ( (pQuery->pUser->szSOM != NULL) || (RSOP_LOOPBACK_NONE!= pQuery->LoopbackMode) )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTUSERSEC);
}
else if ( pQuery->pComputer->szSOM != NULL )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTCOMPSEC);
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
}
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
break;
}
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPAltDirsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
}
break;
case WM_COMMAND:
{
DSBROWSEINFO dsbi = {0};
TCHAR szTitle[256];
TCHAR szCaption[256];
TCHAR* szResult;
dsbi.hwndOwner = hDlg;
dsbi.pszCaption = szTitle;
dsbi.pszTitle = szCaption;
dsbi.cbStruct = sizeof(dsbi);
dsbi.pszPath = NULL;
dsbi.cchPath = 0;
dsbi.dwFlags = DSBI_ENTIREDIRECTORY;
dsbi.pfnCallback = DsBrowseCallback;
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_BUTTON1:
// browse for user's OU
szResult = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*4000);
if ( szResult )
{
dsbi.pszPath = szResult;
dsbi.cchPath = 4000;
LoadString(g_hInstance,
IDS_BROWSE_USER_OU_TITLE,
szTitle,
ARRAYSIZE(szTitle));
LoadString(g_hInstance,
IDS_BROWSE_USER_OU_CAPTION,
szCaption,
ARRAYSIZE(szCaption));
if (IDOK == DsBrowseForContainer(&dsbi))
{
LPWSTR szDN;
HRESULT hr;
// skipping 7 chars for LDAP:// in the szResult
hr = UnEscapeLdapPath(szResult+7, &szDN);
if (FAILED(hr))
{
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
}
else {
SetDlgItemText(hDlg, IDC_EDIT1, szDN);
LocalFree(szDN);
}
}
LocalFree(szResult);
}
break;
case IDC_BUTTON2:
// browse for computer's OU
szResult = (LPTSTR)LocalAlloc(LPTR, sizeof(TCHAR)*4000);
if ( szResult )
{
dsbi.pszPath = szResult;
dsbi.cchPath = 4000;
LoadString(g_hInstance,
IDS_BROWSE_COMPUTER_OU_TITLE,
szTitle,
ARRAYSIZE(szTitle));
LoadString(g_hInstance,
IDS_BROWSE_COMPUTER_OU_CAPTION,
szCaption,
ARRAYSIZE(szCaption));
if (IDOK == DsBrowseForContainer(&dsbi))
{
LPWSTR szDN;
HRESULT hr;
// skipping 7 chars for LDAP:// in the szResult
hr = UnEscapeLdapPath(szResult+7, &szDN);
if (FAILED(hr))
{
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
}
else {
SetDlgItemText(hDlg, IDC_EDIT2, szDN);
LocalFree(szDN);
}
}
LocalFree(szResult);
}
break;
case IDC_BUTTON3:
if (IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT1)))
{
if ( pWizard->m_szDefaultUserSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT1, pWizard->m_szDefaultUserSOM);
}
}
if (IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT2)))
{
if ( pWizard->m_szDefaultComputerSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT2, pWizard->m_szDefaultComputerSOM);
}
}
break;
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
SetDlgItemText (hDlg, IDC_EDIT1, TEXT(""));
if ( pQuery->pUser->szSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT1, pQuery->pUser->szSOM );
if ( pQuery->pUser->szName == NULL )
{
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
}
}
else if ( pWizard->m_szDefaultUserSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT1, pWizard->m_szDefaultUserSOM);
}
else if ( pQuery->pUser->szName == NULL )
{
EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
}
EnableWindow(GetDlgItem(hDlg, IDC_EDIT2), TRUE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
SetDlgItemText (hDlg, IDC_EDIT2, TEXT(""));
if ( pQuery->pComputer->szSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT2, pQuery->pComputer->szSOM);
if ( pQuery->pComputer->szName == NULL )
{
EnableWindow(GetDlgItem(hDlg, IDC_EDIT2), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
}
else if ( pWizard->m_szDefaultComputerSOM != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT2, pWizard->m_szDefaultComputerSOM);
}
else if ( pQuery->pComputer->szName == NULL )
{
EnableWindow(GetDlgItem(hDlg, IDC_EDIT2), FALSE);
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
if (IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT1))
|| IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT2)))
{
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
}
else
{
EnableWindow(GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
}
break;
case PSN_WIZBACK:
case PSN_WIZNEXT:
{
LPTSTR lpUserSOM = NULL, lpComputerSOM = NULL;
HRESULT hr;
GetControlText(hDlg, IDC_EDIT1, lpUserSOM, FALSE);
GetControlText(hDlg, IDC_EDIT2, lpComputerSOM, FALSE);
if (lpUserSOM)
{
pWizard->EscapeString(&lpUserSOM);
if (lpUserSOM)
{
hr = pWizard->TestSOM (lpUserSOM, hDlg);
}
else {
hr = E_FAIL;
}
if (FAILED(hr))
{
if (hr != E_INVALIDARG)
{
ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
}
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (lpComputerSOM)
{
delete [] lpComputerSOM;
}
if ( ((NMHDR FAR*)lParam)->code == PSN_WIZNEXT )
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
else
{
return FALSE;
}
}
}
if (lpComputerSOM)
{
pWizard->EscapeString(&lpComputerSOM);
if (lpComputerSOM)
{
hr = pWizard->TestSOM (lpComputerSOM, hDlg);
}
else {
hr = E_FAIL;
}
if (FAILED(hr))
{
if (hr != E_INVALIDARG)
{
ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
}
if (lpUserSOM)
{
delete [] lpUserSOM;
}
if (lpComputerSOM)
{
delete [] lpComputerSOM;
}
if ( ((NMHDR FAR*)lParam)->code == PSN_WIZNEXT )
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
else
{
return FALSE;
}
}
}
if (lpUserSOM)
{
hr = UnEscapeLdapPath(lpUserSOM, &pQuery->pUser->szSOM);
delete [] lpUserSOM;
lpUserSOM = NULL;
}
else {
pQuery->pUser->szSOM = NULL;
}
if (lpComputerSOM)
{
hr = UnEscapeLdapPath(lpComputerSOM, &pQuery->pComputer->szSOM);
delete [] lpComputerSOM;
lpComputerSOM = NULL;
}
else {
pQuery->pComputer->szSOM = NULL;
}
if ( (pWizard->m_szDefaultUserSOM != NULL) && (pQuery->pUser->szSOM != NULL) )
{
if (!lstrcmpi(pWizard->m_szDefaultUserSOM, pQuery->pUser->szSOM))
{
LocalFree( pQuery->pUser->szSOM );
pQuery->pUser->szSOM = NULL;
}
}
if ( (pWizard->m_szDefaultComputerSOM != NULL) && (pQuery->pComputer->szSOM != NULL) )
{
if (!lstrcmpi(pWizard->m_szDefaultComputerSOM, pQuery->pComputer->szSOM))
{
LocalFree( pQuery->pComputer->szSOM );
pQuery->pComputer->szSOM = NULL;
}
}
if ( ((NMHDR FAR*)lParam)->code == PSN_WIZNEXT )
{
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTDIRS;
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
if ( (NULL == pQuery->pUser->szName) && (NULL == pQuery->pUser->szSOM) )
{
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTDIRS;
if ( (pQuery->pComputer->szName != NULL) || (pQuery->pComputer->szSOM != NULL) )
{
if ( RSOP_LOOPBACK_NONE == pQuery->LoopbackMode)
{
// skip to the alternate computer security page
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTCOMPSEC);
}
else
{
// Skip to the alternate user security page if simulating loopback mode
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTUSERSEC);
}
}
else
{
// skip to the finish page
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
}
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPAltUserSecDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_BUTTON1:
{
TCHAR * sz;
if ( ImplementBrowseButton(hDlg,
(DSOP_FILTER_UNIVERSAL_GROUPS_SE | DSOP_FILTER_GLOBAL_GROUPS_SE | DSOP_FILTER_DOMAIN_LOCAL_GROUPS_SE),
(DSOP_DOWNLEVEL_FILTER_GLOBAL_GROUPS),
(DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS),
GetDlgItem(hDlg, IDC_LIST1), sz) == S_OK )
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON2:
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
if ((SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETITEMDATA, (WPARAM) iIndex, 0) & 1) == 0)
{
SendDlgItemMessage (hDlg, IDC_LIST1, LB_DELETESTRING, (WPARAM) iIndex, 0);
SendDlgItemMessage (hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM) iIndex, 0);
}
}
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON3:
{
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pUser->dwSecurityGroupCount, pQuery->pUser->aszSecurityGroups );
pQuery->pUser->dwSecurityGroupCount = 0;
pQuery->pUser->aszSecurityGroups = NULL;
LocalFree( pQuery->pUser->adwSecurityGroupsAttr );
pQuery->pUser->adwSecurityGroupsAttr = NULL;
}
if ( pWizard->m_dwDefaultUserSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultUserSecurityGroupCount,
pWizard->m_aszDefaultUserSecurityGroups,
pWizard->m_adwDefaultUserSecurityGroupsAttr );
}
else
{
pWizard->BuildMembershipList( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_pUserObject,
&(pWizard->m_dwDefaultUserSecurityGroupCount),
&(pWizard->m_aszDefaultUserSecurityGroups),
&(pWizard->m_adwDefaultUserSecurityGroupsAttr) );
}
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_LIST1:
if (HIWORD(wParam) == LBN_SELCHANGE)
{
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
}
}
break;
case WM_REFRESHDISPLAY:
if (SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0) > 0)
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
if ((SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETITEMDATA, (WPARAM) iIndex, 0) & 1) == 0)
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
}
} else {
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pQuery->pUser->dwSecurityGroupCount,
pQuery->pUser->aszSecurityGroups,
pQuery->pUser->adwSecurityGroupsAttr );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
}
else if ( pWizard->m_dwDefaultUserSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultUserSecurityGroupCount,
pWizard->m_aszDefaultUserSecurityGroups,
pWizard->m_adwDefaultUserSecurityGroupsAttr );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
}
else
{
pWizard->BuildMembershipList( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_pUserObject,
&(pWizard->m_dwDefaultUserSecurityGroupCount),
&(pWizard->m_aszDefaultUserSecurityGroups),
&(pWizard->m_adwDefaultUserSecurityGroupsAttr) );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case PSN_WIZNEXT:
{
// Free the previous list of security groups
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pUser->dwSecurityGroupCount, pQuery->pUser->aszSecurityGroups );
pQuery->pUser->dwSecurityGroupCount = 0;
pQuery->pUser->aszSecurityGroups = NULL;
LocalFree( pQuery->pUser->adwSecurityGroupsAttr );
pQuery->pUser->adwSecurityGroupsAttr = NULL;
}
// Save the current list
pWizard->SaveSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
&(pQuery->pUser->dwSecurityGroupCount),
&(pQuery->pUser->aszSecurityGroups),
&(pQuery->pUser->adwSecurityGroupsAttr) );
// Compare the current list with the default list. If the default list
// matches the current list, then delete the current list and just use
// the defaults
if ( pWizard->CompareStringLists( pWizard->m_dwDefaultUserSecurityGroupCount,
pWizard->m_aszDefaultUserSecurityGroups,
pQuery->pUser->dwSecurityGroupCount,
pQuery->pUser->aszSecurityGroups ) )
{
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pUser->dwSecurityGroupCount, pQuery->pUser->aszSecurityGroups );
pQuery->pUser->dwSecurityGroupCount = 0;
pQuery->pUser->aszSecurityGroups = NULL;
LocalFree( pQuery->pUser->adwSecurityGroupsAttr );
pQuery->pUser->adwSecurityGroupsAttr = NULL;
}
}
// Now check where we should go
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTUSERSEC;
// skip to the diagnostic pages
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
if ( (NULL == pQuery->pComputer->szName) && (NULL == pQuery->pComputer->szSOM) )
{
// skip to the finish page
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTUSERSEC;
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLUSER);
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
}
break;
case PSN_WIZBACK:
{
// Free the previous list of security groups
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pUser->dwSecurityGroupCount, pQuery->pUser->aszSecurityGroups );
pQuery->pUser->dwSecurityGroupCount = 0;
pQuery->pUser->aszSecurityGroups = NULL;
LocalFree( pQuery->pUser->adwSecurityGroupsAttr );
pQuery->pUser->adwSecurityGroupsAttr = NULL;
}
// Save the current list
pWizard->SaveSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
&(pQuery->pUser->dwSecurityGroupCount),
&(pQuery->pUser->aszSecurityGroups),
&(pQuery->pUser->adwSecurityGroupsAttr) );
// Compare the current list with the default list. If the default list
// matches the current list, then delete the current list and just use
// the defaults
if ( pWizard->CompareStringLists( pWizard->m_dwDefaultUserSecurityGroupCount,
pWizard->m_aszDefaultUserSecurityGroups,
pQuery->pUser->dwSecurityGroupCount,
pQuery->pUser->aszSecurityGroups ) )
{
if ( pQuery->pUser->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pUser->dwSecurityGroupCount, pQuery->pUser->aszSecurityGroups );
pQuery->pUser->dwSecurityGroupCount = 0;
pQuery->pUser->aszSecurityGroups = NULL;
LocalFree( pQuery->pUser->adwSecurityGroupsAttr );
pQuery->pUser->adwSecurityGroupsAttr = NULL;
}
}
// Now check where we should go
if ( (pQuery->pUser->szName == NULL) && (pQuery->pComputer->szName == NULL) )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETDC);
return TRUE;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPAltCompSecDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_BUTTON1:
{
TCHAR * sz;
if ( ImplementBrowseButton(hDlg,
(DSOP_FILTER_UNIVERSAL_GROUPS_SE | DSOP_FILTER_GLOBAL_GROUPS_SE | DSOP_FILTER_DOMAIN_LOCAL_GROUPS_SE),
(DSOP_DOWNLEVEL_FILTER_GLOBAL_GROUPS),
(DSOP_SCOPE_FLAG_DEFAULT_FILTER_GROUPS),
GetDlgItem(hDlg, IDC_LIST1), sz) == S_OK )
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON2:
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
if ((SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETITEMDATA, (WPARAM) iIndex, 0) & 1) == 0)
{
SendDlgItemMessage (hDlg, IDC_LIST1, LB_DELETESTRING, (WPARAM) iIndex, 0);
SendDlgItemMessage (hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM) iIndex, 0);
}
}
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON3:
{
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pComputer->dwSecurityGroupCount, pQuery->pComputer->aszSecurityGroups );
pQuery->pComputer->dwSecurityGroupCount = 0;
pQuery->pComputer->aszSecurityGroups = NULL;
LocalFree( pQuery->pComputer->adwSecurityGroupsAttr );
pQuery->pComputer->adwSecurityGroupsAttr = NULL;
}
if ( pWizard->m_dwDefaultComputerSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultComputerSecurityGroupCount,
pWizard->m_aszDefaultComputerSecurityGroups,
pWizard->m_adwDefaultComputerSecurityGroupsAttr );
}
else
{
pWizard->BuildMembershipList( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_pComputerObject,
&(pWizard->m_dwDefaultComputerSecurityGroupCount),
&(pWizard->m_aszDefaultComputerSecurityGroups),
&(pWizard->m_adwDefaultComputerSecurityGroupsAttr) );
}
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_LIST1:
if (HIWORD(wParam) == LBN_SELCHANGE)
{
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
}
}
break;
case WM_REFRESHDISPLAY:
if (SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0) > 0)
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
if ((SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETITEMDATA, (WPARAM) iIndex, 0) & 1) == 0)
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
}
} else {
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pQuery->pComputer->dwSecurityGroupCount,
pQuery->pComputer->aszSecurityGroups,
pQuery->pComputer->adwSecurityGroupsAttr );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
}
else if ( pWizard->m_dwDefaultComputerSecurityGroupCount != 0 )
{
pWizard->FillListFromSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultComputerSecurityGroupCount,
pWizard->m_aszDefaultComputerSecurityGroups,
pWizard->m_adwDefaultComputerSecurityGroupsAttr );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
}
else
{
pWizard->BuildMembershipList( GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_pComputerObject,
&(pWizard->m_dwDefaultComputerSecurityGroupCount),
&(pWizard->m_aszDefaultComputerSecurityGroups),
&(pWizard->m_adwDefaultComputerSecurityGroupsAttr) );
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case PSN_WIZNEXT:
{
// Free the previous list of security groups
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pComputer->dwSecurityGroupCount, pQuery->pComputer->aszSecurityGroups );
pQuery->pComputer->dwSecurityGroupCount = 0;
pQuery->pComputer->aszSecurityGroups = NULL;
LocalFree( pQuery->pComputer->adwSecurityGroupsAttr );
pQuery->pComputer->adwSecurityGroupsAttr = NULL;
}
// Save the current list
pWizard->SaveSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
&(pQuery->pComputer->dwSecurityGroupCount),
&(pQuery->pComputer->aszSecurityGroups),
&(pQuery->pComputer->adwSecurityGroupsAttr) );
// Compare the current list with the default list. If the default list
// matches the current list, then delete the current list and just use
// the defaults
if ( pWizard->CompareStringLists( pWizard->m_dwDefaultComputerSecurityGroupCount,
pWizard->m_aszDefaultComputerSecurityGroups,
pQuery->pComputer->dwSecurityGroupCount,
pQuery->pComputer->aszSecurityGroups ) )
{
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pComputer->dwSecurityGroupCount, pQuery->pComputer->aszSecurityGroups );
pQuery->pComputer->dwSecurityGroupCount = 0;
pQuery->pComputer->aszSecurityGroups = NULL;
LocalFree( pQuery->pComputer->adwSecurityGroupsAttr );
pQuery->pComputer->adwSecurityGroupsAttr = NULL;
}
}
// Now check where to go
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTCOMPSEC;
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
if ( (NULL == pQuery->pUser->szName) && (NULL == pQuery->pUser->szSOM) && (RSOP_LOOPBACK_NONE == pQuery->LoopbackMode) )
{
pWizard->m_dwSkippedFrom = IDD_RSOP_ALTCOMPSEC;
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLCOMP);
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
}
break;
case PSN_WIZBACK:
{
// Free the previous list of security groups
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pComputer->dwSecurityGroupCount, pQuery->pComputer->aszSecurityGroups );
pQuery->pComputer->dwSecurityGroupCount = 0;
pQuery->pComputer->aszSecurityGroups = NULL;
LocalFree( pQuery->pComputer->adwSecurityGroupsAttr );
pQuery->pComputer->adwSecurityGroupsAttr = NULL;
}
// Save the current list
pWizard->SaveSecurityGroups( GetDlgItem(hDlg, IDC_LIST1),
&(pQuery->pComputer->dwSecurityGroupCount),
&(pQuery->pComputer->aszSecurityGroups),
&(pQuery->pComputer->adwSecurityGroupsAttr) );
// Compare the current list with the default list. If the default list
// matches the current list, then delete the current list and just use
// the defaults
if ( pWizard->CompareStringLists( pWizard->m_dwDefaultComputerSecurityGroupCount,
pWizard->m_aszDefaultComputerSecurityGroups,
pQuery->pComputer->dwSecurityGroupCount,
pQuery->pComputer->aszSecurityGroups ) )
{
if ( pQuery->pComputer->dwSecurityGroupCount != 0 )
{
FreeStringList( pQuery->pComputer->dwSecurityGroupCount, pQuery->pComputer->aszSecurityGroups );
pQuery->pComputer->dwSecurityGroupCount = 0;
pQuery->pComputer->aszSecurityGroups = NULL;
LocalFree( pQuery->pComputer->adwSecurityGroupsAttr );
pQuery->pComputer->adwSecurityGroupsAttr = NULL;
}
}
if ( (pQuery->pUser->szName == NULL) && (pQuery->pUser->szSOM == NULL) )
{
if ( pQuery->pComputer->szName != NULL )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTDIRS);
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETDC);
}
return TRUE;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPWQLUserDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
SetFocus(GetDlgItem(hDlg, IDC_RADIO2));
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_BUTTON2:
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
SendDlgItemMessage (hDlg, IDC_LIST1, LB_DELETESTRING, (WPARAM) iIndex, 0);
SendDlgItemMessage (hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM) iIndex, 0);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON1:
{
if ( pQuery->pUser->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilters );
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilterNames );
pQuery->pUser->dwWQLFilterCount = 0;
pQuery->pUser->aszWQLFilters = NULL;
pQuery->pUser->aszWQLFilterNames = NULL;
}
pQuery->pUser->bAssumeWQLFiltersTrue = FALSE;
if ( pWizard->m_dwDefaultUserWQLFilterCount != 0 )
{
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultUserWQLFilterCount,
pWizard->m_aszDefaultUserWQLFilterNames,
pWizard->m_aszDefaultUserWQLFilters );
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
else {
PostMessage (hDlg, WM_BUILDWQLLIST, 0, 0);
}
}
break;
case IDC_RADIO2:
{
if ( IsDlgButtonChecked( hDlg, IDC_RADIO2 ) )
{
if ( pQuery->pUser->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilters );
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilterNames );
pQuery->pUser->dwWQLFilterCount = 0;
pQuery->pUser->aszWQLFilters = NULL;
pQuery->pUser->aszWQLFilterNames = NULL;
}
pQuery->pUser->bAssumeWQLFiltersTrue = TRUE;
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_RADIO3:
{
if ( IsDlgButtonChecked( hDlg, IDC_RADIO3 ) )
{
pQuery->pUser->bAssumeWQLFiltersTrue = FALSE;
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
}
}
break;
case WM_BUILDWQLLIST:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
pWizard->BuildWQLFilterList (hDlg, TRUE, &(pWizard->m_dwDefaultUserWQLFilterCount),
&(pWizard->m_aszDefaultUserWQLFilterNames),
&(pWizard->m_aszDefaultUserWQLFilters) );
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case WM_REFRESHDISPLAY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( pQuery->pUser->bAssumeWQLFiltersTrue )
{
// set the listbox to null
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1), 0, NULL, NULL);
CheckDlgButton (hDlg, IDC_RADIO2, BST_CHECKED);
CheckDlgButton (hDlg, IDC_RADIO3, BST_UNCHECKED);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_LIST1), FALSE);
ShowWindow(GetDlgItem(hDlg, IDC_LIST2), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDC_LIST1), SW_HIDE);
}
else
{
CheckDlgButton (hDlg, IDC_RADIO2, BST_UNCHECKED);
CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_LIST1), TRUE);
ShowWindow(GetDlgItem(hDlg, IDC_LIST1), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDC_LIST2), SW_HIDE);
if (SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0) > 0)
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
if ( !pQuery->pUser->bAssumeWQLFiltersTrue )
{
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1),
pQuery->pUser->dwWQLFilterCount,
pQuery->pUser->aszWQLFilterNames,
pQuery->pUser->aszWQLFilters );
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case PSN_WIZNEXT:
{
// Free the previous list of WQL Filters
if ( pQuery->pUser->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilters );
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilterNames );
pQuery->pUser->dwWQLFilterCount = 0;
pQuery->pUser->aszWQLFilters = NULL;
pQuery->pUser->aszWQLFilterNames = NULL;
}
// Save the current list
if ( !pQuery->pUser->bAssumeWQLFiltersTrue )
{
pWizard->SaveWQLFilters(GetDlgItem(hDlg, IDC_LIST1), &(pQuery->pUser->dwWQLFilterCount),
&(pQuery->pUser->aszWQLFilterNames),
&(pQuery->pUser->aszWQLFilters) );
}
// Move to the next page
if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
{
pWizard->m_dwSkippedFrom = IDD_RSOP_WQLUSER;
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
if ( (NULL == pQuery->pComputer->szName) && (NULL == pQuery->pComputer->szSOM) )
{
// skip to the finish page
pWizard->m_dwSkippedFrom = IDD_RSOP_WQLUSER;
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
pWizard->m_dwSkippedFrom = 0;
}
break;
case PSN_WIZBACK:
{
// Free the previous list of WQL Filters
if ( pQuery->pUser->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilters );
FreeStringList( pQuery->pUser->dwWQLFilterCount, pQuery->pUser->aszWQLFilterNames );
pQuery->pUser->dwWQLFilterCount = 0;
pQuery->pUser->aszWQLFilters = NULL;
pQuery->pUser->aszWQLFilterNames = NULL;
}
// Save the current list
if ( !pQuery->pUser->bAssumeWQLFiltersTrue )
{
pWizard->SaveWQLFilters(GetDlgItem(hDlg, IDC_LIST1), &(pQuery->pUser->dwWQLFilterCount),
&(pQuery->pUser->aszWQLFilterNames),
&(pQuery->pUser->aszWQLFilters) );
}
// Check which page to go back to
if ( (pQuery->pComputer->szName == NULL) && (pQuery->pComputer->szSOM == NULL) )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTUSERSEC);
return TRUE;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPWQLCompDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
SetFocus(GetDlgItem(hDlg, IDC_RADIO2));
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (LOWORD(wParam))
{
case IDC_BUTTON2:
{
INT iIndex;
iIndex = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iIndex != LB_ERR)
{
SendDlgItemMessage (hDlg, IDC_LIST1, LB_DELETESTRING, (WPARAM) iIndex, 0);
SendDlgItemMessage (hDlg, IDC_LIST1, LB_SETCURSEL, (WPARAM) iIndex, 0);
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_BUTTON1:
{
if ( pQuery->pComputer->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilters );
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilterNames );
pQuery->pComputer->dwWQLFilterCount = 0;
pQuery->pComputer->aszWQLFilters = NULL;
pQuery->pComputer->aszWQLFilterNames = NULL;
}
pQuery->pComputer->bAssumeWQLFiltersTrue = FALSE;
if ( pWizard->m_dwDefaultComputerWQLFilterCount != 0 )
{
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1),
pWizard->m_dwDefaultComputerWQLFilterCount,
pWizard->m_aszDefaultComputerWQLFilterNames,
pWizard->m_aszDefaultComputerWQLFilters );
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
else
{
PostMessage (hDlg, WM_BUILDWQLLIST, 0, 0);
}
}
break;
case IDC_RADIO2:
{
if ( IsDlgButtonChecked( hDlg, IDC_RADIO2 ) )
{
if ( pQuery->pComputer->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilters );
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilterNames );
pQuery->pComputer->dwWQLFilterCount = 0;
pQuery->pComputer->aszWQLFilters = NULL;
pQuery->pComputer->aszWQLFilterNames = NULL;
}
pQuery->pComputer->bAssumeWQLFiltersTrue = TRUE;
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case IDC_RADIO3:
{
if ( IsDlgButtonChecked( hDlg, IDC_RADIO3 ) )
{
pQuery->pComputer->bAssumeWQLFiltersTrue = FALSE;
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
}
}
break;
case WM_BUILDWQLLIST:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
pWizard->BuildWQLFilterList (hDlg, FALSE, &(pWizard->m_dwDefaultComputerWQLFilterCount),
&(pWizard->m_aszDefaultComputerWQLFilterNames),
&(pWizard->m_aszDefaultComputerWQLFilters) );
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
case WM_REFRESHDISPLAY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( pQuery->pComputer->bAssumeWQLFiltersTrue )
{
// set the listbox to null
CheckDlgButton (hDlg, IDC_RADIO2, BST_CHECKED);
CheckDlgButton (hDlg, IDC_RADIO3, BST_UNCHECKED);
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1), 0, NULL, NULL);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_LIST1), FALSE);
ShowWindow(GetDlgItem(hDlg, IDC_LIST2), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDC_LIST1), SW_HIDE);
}
else
{
CheckDlgButton (hDlg, IDC_RADIO2, BST_UNCHECKED);
CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_LIST1), TRUE);
ShowWindow(GetDlgItem(hDlg, IDC_LIST1), SW_SHOW);
ShowWindow(GetDlgItem(hDlg, IDC_LIST2), SW_HIDE);
if (SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCOUNT, 0, 0) > 0)
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
}
else
{
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
}
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
if ( !pQuery->pComputer->bAssumeWQLFiltersTrue )
{
pWizard->FillListFromWQLFilters(GetDlgItem(hDlg, IDC_LIST1),
pQuery->pComputer->dwWQLFilterCount,
pQuery->pComputer->aszWQLFilterNames,
pQuery->pComputer->aszWQLFilters );
}
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
break;
case PSN_WIZNEXT:
{
// Free the previous list of WQL Filters
if ( pQuery->pComputer->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilters );
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilterNames );
pQuery->pComputer->dwWQLFilterCount = 0;
pQuery->pComputer->aszWQLFilters = NULL;
pQuery->pComputer->aszWQLFilterNames = NULL;
}
// Save the current list
if ( !pQuery->pComputer->bAssumeWQLFiltersTrue )
{
pWizard->SaveWQLFilters (GetDlgItem(hDlg, IDC_LIST1), &(pQuery->pComputer->dwWQLFilterCount),
&(pQuery->pComputer->aszWQLFilterNames),
&(pQuery->pComputer->aszWQLFilters) );
}
pWizard->m_dwSkippedFrom = 0;
// Skip to the last page in the wizard
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_lPlanningFinishedPage);
return TRUE;
}
case PSN_WIZBACK:
{
// Free the previous list of WQL Filters
if ( pQuery->pComputer->dwWQLFilterCount != 0 )
{
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilters );
FreeStringList( pQuery->pComputer->dwWQLFilterCount, pQuery->pComputer->aszWQLFilterNames );
pQuery->pComputer->dwWQLFilterCount = 0;
pQuery->pComputer->aszWQLFilters = NULL;
pQuery->pComputer->aszWQLFilterNames = NULL;
}
// Save the current list
if ( !pQuery->pComputer->bAssumeWQLFiltersTrue )
{
pWizard->SaveWQLFilters (GetDlgItem(hDlg, IDC_LIST1), &(pQuery->pComputer->dwWQLFilterCount),
&(pQuery->pComputer->aszWQLFilterNames),
&(pQuery->pComputer->aszWQLFilters) );
}
// Check which page to go back to
if ( (pQuery->pUser->szName == NULL) && (pQuery->pUser->szSOM == NULL) )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTCOMPSEC);
return TRUE;
}
}
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPFinishedDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// RSOP_LOGGING_MODE (IDD_RSOP_FINISHED)
// RSOP_PLANNING_MODE (IDD_RSOP_FINISHED3)
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
if (pWizard)
{
CRSOPWizard::InitializeResultsList (GetDlgItem (hDlg, IDC_LIST1));
}
}
break;
case WM_REFRESHDISPLAY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
UINT n;
n = (UINT) SendMessage(GetDlgItem(hDlg, IDC_EDIT1), WM_GETTEXTLENGTH, 0, 0);
if (n > 0 )
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
else
PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
}
}
break;
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg*) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
switch (LOWORD(wParam))
{
case IDC_BUTTON1:
if (DialogBoxParam (g_hInstance, MAKEINTRESOURCE(IDD_RSOP_BROWSEDC), hDlg,
BrowseDCDlgProc, (LPARAM) pWizard))
{
SetDlgItemText (hDlg, IDC_EDIT1, pQuery->szDomainController);
}
break;
case IDC_EDIT1:
if (HIWORD(wParam) == EN_CHANGE)
{
PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
}
break;
}
}
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_WIZBACK:
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
if ( pWizard->m_dwSkippedFrom != 0 )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, pWizard->m_dwSkippedFrom);
return TRUE;
}
else if ( (pQuery->pComputer->szName == NULL) && (pQuery->pComputer->szSOM == NULL) )
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLUSER);
return TRUE;
}
else
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLCOMP);
return TRUE;
}
}
else // RSOP_LOGGING_MODE
{
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETUSER);
return TRUE;
}
break;
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
if ( pQuery->szDomainController != NULL )
{
if ( !pWizard->IsComputerRSoPEnabled(pQuery->szDomainController))
{
LocalFree( pQuery->szDomainController );
pQuery->szDomainController = NULL;
}
}
if ( pQuery->szDomainController != NULL )
{
SetDlgItemText (hDlg, IDC_EDIT1, pQuery->szDomainController);
}
else
{
SetDlgItemText (hDlg, IDC_EDIT1, TEXT(""));
}
}
CRSOPWizard::FillResultsList (GetDlgItem (hDlg, IDC_LIST1), pQuery, NULL );
if ( pWizard->m_pExtendedProcessing != NULL )
{
CheckDlgButton(hDlg, IDC_RADIO1, pWizard->m_pExtendedProcessing->GetExtendedErrorInfo() ? BST_CHECKED : BST_UNCHECKED );
}
break;
case PSN_WIZNEXT:
{
pWizard->m_bFinalNextClicked = TRUE;
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
SetWaitCursor();
GetControlText(hDlg, IDC_EDIT1, pQuery->szDomainController, TRUE );
if ( ! pQuery->szDomainController || !pWizard->IsComputerRSoPEnabled( pQuery->szDomainController ) )
{
ClearWaitCursor();
ReportError(hDlg, GetLastError(), IDS_DCMISSINGRSOP);
pWizard->m_bFinalNextClicked = FALSE;
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
return TRUE;
}
ClearWaitCursor();
}
//PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_DISABLEDFINISH);
PropSheet_SetWizButtons (GetParent(hDlg), 0);
EnableWindow (GetDlgItem(GetParent(hDlg), IDCANCEL), FALSE);
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
EnableWindow( GetDlgItem(hDlg, IDC_BUTTON1), FALSE );
SendMessage( GetDlgItem(hDlg, IDC_EDIT1), EM_SETREADONLY, TRUE, 0 );
}
BOOL bGetExtendedInfo = FALSE;
if ( pWizard->m_pExtendedProcessing != NULL )
{
bGetExtendedInfo = (BOOL)SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0);
EnableWindow( GetDlgItem(hDlg, IDC_RADIO1), FALSE );
}
if ( bGetExtendedInfo )
{
pWizard->m_pRSOPQuery->dwFlags |= RSOP_90P_ONLY;
}
else
{
pWizard->m_pRSOPQuery->dwFlags = pWizard->m_pRSOPQuery->dwFlags & (RSOP_90P_ONLY ^ 0xffffffff);
}
// RM: InitializeRSOP used to be called here, but now we go directly to GenerateRSOPEx
{
pWizard->m_hrQuery = CRSOPWizard::GenerateRSOPDataEx(hDlg, pWizard->m_pRSOPQuery, &(pWizard->m_pRSOPQueryResults) );
if ( pWizard->m_hrQuery != S_OK )
{
PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK);
pWizard->m_bFinalNextClicked = FALSE;
EnableWindow (GetDlgItem(GetParent(hDlg), IDCANCEL), TRUE);
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
EnableWindow( GetDlgItem(hDlg, IDC_BUTTON1), TRUE );
SendMessage( GetDlgItem(hDlg, IDC_EDIT1), EM_SETREADONLY, FALSE, 0 );
}
if ( pWizard->m_pExtendedProcessing != NULL )
{
EnableWindow( GetDlgItem(hDlg, IDC_RADIO1), TRUE );
}
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
return TRUE;
}
}
if ( pWizard->m_pExtendedProcessing != NULL )
{
pWizard->m_pExtendedProcessing->DoProcessing( pWizard->m_pRSOPQuery,
pWizard->m_pRSOPQueryResults,
bGetExtendedInfo );
SendMessage( GetDlgItem(hDlg, IDC_PROGRESS1), PBM_SETRANGE32, 0, (LPARAM) 100);
SendMessage( GetDlgItem(hDlg, IDC_PROGRESS1), PBM_SETPOS, (WPARAM) 100, 0);
EnableWindow( GetDlgItem(hDlg, IDC_RADIO1), TRUE );
}
// skip to the VERY last page in the wizard
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
EnableWindow( GetDlgItem(hDlg, IDC_BUTTON1), TRUE );
SendMessage( GetDlgItem(hDlg, IDC_EDIT1), EM_SETREADONLY, FALSE, 0 );
}
SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED2);
pWizard->m_bFinalNextClicked = FALSE;
return TRUE;
}
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
case PSN_QUERYCANCEL:
{
if (pWizard->m_bFinalNextClicked)
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
return FALSE;
}
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::RSOPFinished2DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// Both modes
{
static BOOL iCancelQuery = FALSE;
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) (((LPPROPSHEETPAGE)lParam)->lParam);
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
SendMessage(GetDlgItem(hDlg, IDC_RSOP_BIG_BOLD1),
WM_SETFONT, (WPARAM)pWizard->m_BigBoldFont, (LPARAM)TRUE);
/*
if (!pWizard->m_hChooseBitmap)
{
pWizard->m_hChooseBitmap = (HBITMAP) LoadImage (g_hInstance,
MAKEINTRESOURCE(IDB_WIZARD),
IMAGE_BITMAP, 0, 0,
LR_DEFAULTCOLOR);
}
if (pWizard->m_hChooseBitmap)
{
SendDlgItemMessage (hDlg, IDC_BITMAP, STM_SETIMAGE,
IMAGE_BITMAP, (LPARAM) pWizard->m_hChooseBitmap);
}
*/
}
break;
case WM_NOTIFY:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
switch (((NMHDR FAR*)lParam)->code)
{
case PSN_SETACTIVE:
PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_FINISH);
break;
case PSN_WIZFINISH:
// fall through
case PSN_RESET:
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
return TRUE;
// Ignore the 'X' button on the upper right corner
case PSN_QUERYCANCEL:
{
SetWindowLongPtr (hDlg, DWLP_MSGRESULT, TRUE);
return TRUE;
}
}
}
break;
}
return FALSE;
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::SetupFonts()
{
HRESULT hr;
LOGFONT BigBoldLogFont;
LOGFONT BoldLogFont;
HDC pdc = NULL;
WCHAR largeFontSizeString[128];
INT largeFontSize;
WCHAR smallFontSizeString[128];
INT smallFontSize;
//
// Create the fonts we need based on the dialog font
//
NONCLIENTMETRICS ncm = {0};
ncm.cbSize = sizeof (ncm);
if (SystemParametersInfo (SPI_GETNONCLIENTMETRICS, 0, &ncm, 0) == FALSE) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto end;
}
BigBoldLogFont = ncm.lfMessageFont;
BoldLogFont = ncm.lfMessageFont;
//
// Create Big Bold Font and Bold Font
//
BigBoldLogFont.lfWeight = FW_BOLD;
BoldLogFont.lfWeight = FW_BOLD;
//
// Load size and name from resources, since these may change
// from locale to locale based on the size of the system font, etc.
//
if ( !LoadString (g_hInstance, IDS_LARGEFONTNAME, BigBoldLogFont.lfFaceName, LF_FACESIZE) )
{
ASSERT (0);
hr = StringCchCopy (BigBoldLogFont.lfFaceName, LF_FACESIZE, L"Verdana");
if (FAILED(hr))
{
goto end;
}
}
if ( LoadString (g_hInstance, IDS_LARGEFONTSIZE, largeFontSizeString, ARRAYSIZE(largeFontSizeString)) )
{
largeFontSize = wcstoul ((LPCWSTR) largeFontSizeString, NULL, 10);
}
else
{
ASSERT (0);
largeFontSize = 12;
}
if ( !LoadString (g_hInstance, IDS_SMALLFONTNAME, BoldLogFont.lfFaceName, LF_FACESIZE) )
{
ASSERT (0);
hr = StringCchCopy (BoldLogFont.lfFaceName, LF_FACESIZE, L"Verdana");
if (FAILED(hr))
{
goto end;
}
}
if ( LoadString (g_hInstance, IDS_SMALLFONTSIZE, smallFontSizeString, ARRAYSIZE(smallFontSizeString)) )
{
smallFontSize = wcstoul ((LPCWSTR) smallFontSizeString, NULL, 10);
}
else
{
ASSERT (0);
smallFontSize = 8;
}
pdc = GetDC (NULL);
if (pdc == NULL) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto end;
}
BigBoldLogFont.lfHeight = 0 - (GetDeviceCaps (pdc, LOGPIXELSY) * largeFontSize / 72);
BoldLogFont.lfHeight = 0 - (GetDeviceCaps (pdc, LOGPIXELSY) * smallFontSize / 72);
m_BigBoldFont = CreateFontIndirect (&BigBoldLogFont);
if (m_BigBoldFont == NULL) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto end;
}
m_BoldFont = CreateFontIndirect (&BoldLogFont);
if (m_BoldFont == NULL) {
hr = HRESULT_FROM_WIN32(GetLastError());
goto end;
}
hr = S_OK;
end:
if (pdc != NULL) {
ReleaseDC (NULL, pdc);
pdc = NULL;
}
return hr;
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::FillUserList (HWND hList, BOOL* pbFoundCurrentUser, BOOL* pbFoundFixedUser)
{
HRESULT hr, hrSuccess;
IWbemServices * pNamespace = NULL;
IWbemClassObject * pOutInst = NULL;
BSTR bstrParam = NULL;
BSTR bstrClassPath = NULL;
BSTR bstrMethodName = NULL;
VARIANT var;
TCHAR szBuffer[MAX_PATH];
IWbemLocator * pLocator = NULL;
SAFEARRAY * psa;
LONG lMax, lIndex;
BSTR bstrSid;
PSID pSid;
TCHAR szName[125];
TCHAR szDomain[125];
TCHAR szFullName[MAX_PATH];
DWORD dwNameSize, dwDomainSize;
SID_NAME_USE NameUse;
LPTSTR lpData, szUserSidPref = NULL;
INT iRet;
LVITEM item;
LPTSTR lpCurrentUserSid = NULL;
HANDLE hToken;
LPTSTR lpSystemName = NULL;
BOOL bFixUser = FALSE;
*pbFoundFixedUser = FALSE;
// This method only gets called from RSOPGetUserDlgProc, which means that it must be logging mode!
if ( m_pRSOPQuery->QueryType != RSOP_LOGGING_MODE )
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: Not called in planning mode.") ));
return E_FAIL;
}
if ( m_pRSOPQuery->szComputerName == NULL )
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: Called without computer name set.") ));
return E_FAIL;
}
bFixUser = (m_pRSOPQuery->dwFlags & RSOP_FIX_USER) == RSOP_FIX_USER;
// Get the "selected" user's Sid
if ( (m_pRSOPQuery->szUserName != NULL) && bFixUser )
{
szUserSidPref = MyLookupAccountName(
(lstrcmpi( m_pRSOPQuery->szComputerName, TEXT(".")) == 0) ? NULL : NameWithoutDomain(m_pRSOPQuery->szComputerName),
m_pRSOPQuery->szUserName );
if ( szUserSidPref == NULL )
{
hr = HRESULT_FROM_WIN32(GetLastError());
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: MyLookupAccountName failed with %d"), hr));
}
}
if ( lstrcmpi(m_pRSOPQuery->szComputerName, TEXT(".")) )
{
lpSystemName = m_pRSOPQuery->szComputerName;
}
*pbFoundCurrentUser = FALSE;
if (OpenProcessToken (GetCurrentProcess(), TOKEN_READ, &hToken))
{
lpCurrentUserSid = GetSidString(hToken);
CloseHandle (hToken);
}
hr = CoCreateInstance(CLSID_WbemLocator,
0,
CLSCTX_INPROC_SERVER,
IID_IWbemLocator,
(LPVOID *) &pLocator);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: CoCreateInstance failed with 0x%x"), hr));
goto Cleanup;
}
// Set up diagnostic mode
// Build a path to the target: "\\\\computer\\root\\rsop"
hr = StringCchPrintf (szBuffer, ARRAYSIZE(szBuffer), TEXT("\\\\%s\\root\\rsop"), NameWithoutDomain(m_pRSOPQuery->szComputerName));
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: Could not copy Name without domain with 0x%x"), hr));
goto Cleanup;
}
bstrParam = SysAllocString(szBuffer);
hr = pLocator->ConnectServer(bstrParam,
NULL,
NULL,
NULL,
0,
NULL,
NULL,
&pNamespace);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: ConnectServer to %s failed with 0x%x"), szBuffer, hr));
goto Cleanup;
}
// Set the proper security to prevent the ExecMethod call from failing and to enable encryption
hr = CoSetProxyBlanket(pNamespace,
RPC_C_AUTHN_DEFAULT,
RPC_C_AUTHZ_DEFAULT,
COLE_DEFAULT_PRINCIPAL,
RPC_C_AUTHN_LEVEL_PKT_PRIVACY,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
0);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: CoSetProxyBlanket failed with 0x%x"), hr));
goto Cleanup;
}
bstrClassPath = SysAllocString(TEXT("RsopLoggingModeProvider"));
bstrMethodName = SysAllocString(TEXT("RsopEnumerateUsers"));
hr = pNamespace->ExecMethod(bstrClassPath,
bstrMethodName,
0,
NULL,
NULL,
&pOutInst,
NULL);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: ExecMethod failed with 0x%x"), hr));
goto Cleanup;
}
hr = GetParameter(pOutInst, TEXT("hResult"), hrSuccess);
if (SUCCEEDED(hr) && SUCCEEDED(hrSuccess))
{
VariantInit(&var);
hr = pOutInst->Get(TEXT("userSids"), 0, &var, 0, 0);
if (SUCCEEDED(hr))
{
if (var.vt & VT_ARRAY)
{
psa = var.parray;
if (SUCCEEDED( SafeArrayGetUBound(psa, 1, &lMax)))
{
for (lIndex = 0; lIndex <= lMax; lIndex++)
{
if (SUCCEEDED(SafeArrayGetElement (psa, &lIndex, &bstrSid)))
{
ULONG ulNoChars = lstrlen(bstrSid) + 1;
lpData = new WCHAR[ulNoChars];
if (lpData)
{
hr = StringCchCopy (lpData, ulNoChars, bstrSid);
ASSERT(SUCCEEDED(hr));
if (lpCurrentUserSid)
{
if (!lstrcmpi(lpCurrentUserSid, lpData))
{
*pbFoundCurrentUser = TRUE;
}
}
if (NT_SUCCESS(AllocateAndInitSidFromString (bstrSid, &pSid)))
{
dwNameSize = ARRAYSIZE(szName);
dwDomainSize = ARRAYSIZE(szDomain);
if (LookupAccountSid (NameWithoutDomain(lpSystemName), pSid, szName, &dwNameSize,
szDomain, &dwDomainSize, &NameUse))
{
BOOL bAddUser;
bAddUser = (!bFixUser || (lstrcmpi(szUserSidPref, lpData) == 0));
if ( bFixUser && (lstrcmpi(szUserSidPref, lpData) == 0))
{
*pbFoundFixedUser = TRUE;
m_pRSOPQuery->szUserSid = szUserSidPref;
}
if (bAddUser)
{
hr = StringCchPrintf (szFullName, ARRAYSIZE(szFullName), TEXT("%s\\%s"), szDomain, szName);
if (SUCCEEDED(hr))
{
ZeroMemory (&item, sizeof(item));
item.mask = LVIF_TEXT | LVIF_PARAM;
item.pszText = szFullName;
item.lParam = (LPARAM) lpData;
iRet = ListView_InsertItem(hList, &item);
if (iRet == -1)
{
delete [] lpData;
}
else if ( (szUserSidPref != NULL) && !lstrcmpi(szUserSidPref, lpData) )
{
ListView_SetItemState( hList, iRet, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
}
}
}
}
else
{
delete [] lpData;
}
RtlFreeSid(pSid);
}
else
{
delete [] lpData;
}
}
}
}
}
}
}
VariantClear(&var);
item.mask = LVIF_STATE;
item.iItem = 0;
item.iSubItem = 0;
item.state = LVIS_SELECTED | LVIS_FOCUSED;
item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
SendMessage (hList, LVM_SETITEMSTATE, 0, (LPARAM) &item);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: Either GetParameter or the return value failed. hr = 0x%x, hrSuccess = 0x%x"), hr, hrSuccess));
}
if ( bFixUser && !(*pbFoundFixedUser) )
{
hr = HRESULT_FROM_WIN32(ERROR_NO_SUCH_USER);
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: User not found on the machine")));
}
Cleanup:
SysFreeString(bstrParam);
SysFreeString(bstrClassPath);
SysFreeString(bstrMethodName);
if (pOutInst)
{
pOutInst->Release();
}
if (pNamespace)
{
pNamespace->Release();
}
if (pLocator)
{
pLocator->Release();
}
if (lpCurrentUserSid)
{
DeleteSidString(lpCurrentUserSid);
}
if ( !(*pbFoundFixedUser))
{
LocalFree(szUserSidPref);
}
return hr;
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::EscapeString (LPTSTR *lpString)
{
IADsPathname * pADsPathnameDest = NULL;
IADsPathname * pADsPathnameSrc = NULL;
HRESULT hr;
BSTR bstr = NULL, bstrResult;
LPTSTR lpTemp;
LONG lIndex, lCount;
//
// Create a pathname object to put the source string into so we
// can take it apart one element at a time.
//
hr = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER,
IID_IADsPathname, (LPVOID*)&pADsPathnameSrc);
if (FAILED(hr))
{
goto Exit;
}
hr = pADsPathnameSrc->put_EscapedMode (ADS_ESCAPEDMODE_OFF_EX);
if (FAILED(hr))
{
goto Exit;
}
//
// Set the provider to LDAP and set the source string
//
BSTR bstrLDAP = SysAllocString(TEXT("LDAP"));
if ( bstrLDAP == NULL )
{
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = pADsPathnameSrc->Set (bstrLDAP, ADS_SETTYPE_PROVIDER);
SysFreeString( bstrLDAP );
if (FAILED(hr))
{
goto Exit;
}
BSTR bstrTmpString = SysAllocString( *lpString );
if ( bstrTmpString == NULL )
{
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = pADsPathnameSrc->Set (bstrTmpString, ADS_SETTYPE_DN);
SysFreeString( bstrTmpString );
if (FAILED(hr))
{
goto Exit;
}
//
// Query for the number of elements
//
hr = pADsPathnameSrc->GetNumElements (&lCount);
if (FAILED(hr))
{
goto Exit;
}
//
// Create a pathname object to put the freshly escaped string into
//
hr = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER,
IID_IADsPathname, (LPVOID*)&pADsPathnameDest);
if (FAILED(hr))
{
goto Exit;
}
hr = pADsPathnameDest->put_EscapedMode(ADS_ESCAPEDMODE_ON );
if (FAILED(hr))
{
goto Exit;
}
//
// Loop through the string one element at at time escaping the RDN
//
for (lIndex = lCount; lIndex > 0; lIndex--)
{
//
// Get this element
//
hr = pADsPathnameSrc->GetElement ((lIndex - 1), &bstr);
if (FAILED(hr))
{
goto Exit;
}
//
// Check for escape characters
//
hr = pADsPathnameDest->GetEscapedElement (0, bstr, &bstrResult);
if (FAILED(hr))
{
goto Exit;
}
//
// Add the new element to the destination pathname object
//
hr = pADsPathnameDest->AddLeafElement (bstrResult);
SysFreeString (bstrResult);
if (FAILED(hr))
{
goto Exit;
}
SysFreeString (bstr);
bstr = NULL;
}
//
// Get the final path
//
hr = pADsPathnameDest->Retrieve (ADS_FORMAT_X500_DN, &bstr);
if (FAILED(hr))
{
goto Exit;
}
//
// Allocate a new buffer to hold the string
//
ULONG ulNoChars = lstrlen(bstr) + 1;
lpTemp = new TCHAR [ulNoChars];
if (lpTemp)
{
hr = StringCchCopy (lpTemp, ulNoChars, bstr);
ASSERT(SUCCEEDED(hr));
delete [] *lpString;
*lpString = lpTemp;
}
Exit:
if (bstr)
{
SysFreeString (bstr);
}
if (pADsPathnameDest)
{
pADsPathnameDest->Release();
}
if (pADsPathnameSrc)
{
pADsPathnameSrc->Release();
}
}
//-------------------------------------------------------
INT CALLBACK CRSOPWizardDlg::DsBrowseCallback (HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
{
if (uMsg == DSBM_HELP)
{
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
(ULONG_PTR) (LPSTR) g_aBrowseForOUHelpIds);
}
else if (uMsg == DSBM_CONTEXTMENU)
{
WinHelp((HWND) lParam, HELP_FILE, HELP_CONTEXTMENU,
(ULONG_PTR) (LPSTR) g_aBrowseForOUHelpIds);
}
return 0;
}
//-------------------------------------------------------
INT_PTR CALLBACK CRSOPWizardDlg::BrowseDCDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
// Only called in RSOPFinishedDlgProc where QueryType == RSOP_PLANNING_MODE
{
switch (message)
{
case WM_INITDIALOG:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) lParam;
SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pWizard);
pWizard->InitializeDCInfo(hDlg);
return TRUE;
}
case WM_COMMAND:
{
CRSOPWizardDlg* pWizard = (CRSOPWizardDlg *) GetWindowLongPtr (hDlg, DWLP_USER);
if (!pWizard)
{
break;
}
LPRSOP_QUERY pQuery = pWizard->m_pRSOPQuery;
if (LOWORD(wParam) == IDOK)
{
INT iSel, iStrLen;
iSel = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETCURSEL, 0, 0);
if (iSel == LB_ERR)
{
break;
}
iStrLen = (INT) SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETTEXTLEN, (WPARAM) iSel, 0);
if (iStrLen == LB_ERR)
{
break;
}
if ( pQuery->QueryType == RSOP_PLANNING_MODE )
{
LocalFree( pQuery->szDomainController );
pQuery->szDomainController = (TCHAR*)LocalAlloc( LPTR, (iStrLen+1) * sizeof(TCHAR) );
if ( pQuery->szDomainController == NULL )
{
break;
}
SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETTEXT, (WPARAM) iSel, (LPARAM) pQuery->szDomainController );
}
EndDialog(hDlg, 1);
return TRUE;
}
if (LOWORD(wParam) == IDCANCEL)
{
EndDialog(hDlg, 0);
return TRUE;
}
}
break;
case WM_HELP: // F1
WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
(ULONG_PTR) (LPSTR) g_aBrowseDCHelpIds);
break;
case WM_CONTEXTMENU: // right mouse click
WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
(ULONG_PTR) (LPSTR) g_aBrowseDCHelpIds);
return (TRUE);
}
return FALSE;
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::InitializeSitesInfo (HWND hDlg)
// RSOP_PLANNING_MODE - only called from RSOPGetDCDlgProc
{
LPTSTR szDomain = NULL;
PDS_NAME_RESULTW pSites;
int iInitialSite = 0;
int iIndex, iDefault = CB_ERR;
HANDLE hDs;
DWORD dw, n;
SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_RESETCONTENT, 0, 0);
// Determine the focused domain.
if ( m_pRSOPQuery->pComputer->szName != NULL )
{
// Try and get the computer's domain
szDomain = ExtractDomain( m_pRSOPQuery->pComputer->szName );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pComputer->szSOM != NULL) )
{
// Try and get the computer's domain from the SOM
szDomain = GetDomainFromSOM( m_pRSOPQuery->pComputer->szSOM );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pUser->szName != NULL) )
{
// Try and get the user's domain
szDomain = ExtractDomain( m_pRSOPQuery->pUser->szName );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pUser->szSOM != NULL) )
{
// Try and get the user's domain from the SOM
szDomain = GetDomainFromSOM( m_pRSOPQuery->pUser->szSOM );
}
if ( szDomain == NULL )
{
// Use the local domain
LPTSTR szName;
szName = MyGetUserName(NameSamCompatible);
if ( szName != NULL )
{
szDomain = ExtractDomain(szName);
LocalFree( szName );
}
}
// Bind to the domain
dw = DsBindW(NULL, szDomain, &hDs);
if (dw == ERROR_SUCCESS)
{
// If we have a site pref, show only that..
if ( (m_pRSOPQuery->dwFlags & RSOP_FIX_SITENAME) == RSOP_FIX_SITENAME )
{
LPWSTR szSiteFriendlyName=NULL;
// Get the friendly name
if ( GetSiteFriendlyName(m_pRSOPQuery->szSite, &szSiteFriendlyName) )
{
SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING,
(WPARAM) 0, (LPARAM) (LPCTSTR) szSiteFriendlyName);
delete [] szSiteFriendlyName;
}
}
else
{
// Query for the list of sites
dw = DsListSitesW(hDs, &pSites);
if (dw == ERROR_SUCCESS)
{
for (n = 0; n < pSites->cItems; n++)
{
// Add the site name (if it has a name)
if (pSites->rItems[n].pName)
{
LPWSTR szSiteFriendlyName=NULL;
if (GetSiteFriendlyName(pSites->rItems[n].pName, &szSiteFriendlyName))
{
SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING,
(WPARAM) 0, (LPARAM) (LPCTSTR) szSiteFriendlyName);
delete [] szSiteFriendlyName;
}
}
}
DsFreeNameResultW(pSites);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeSitesInfo: DsListSites failed with 0x%x"), dw));
}
}
DsUnBindW(&hDs);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeSitesInfo: DsBindW failed with 0x%x"), dw));
}
if ( (m_pRSOPQuery->dwFlags & RSOP_FIX_SITENAME) == 0 )
{
TCHAR szString[1024];
LoadString (g_hInstance, IDS_NONE, szString, ARRAYSIZE(szString));
iIndex = (int) SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING,
(WPARAM) 0, (LPARAM) (LPCTSTR) szString);
}
// Set the initial selection
if ( (m_pRSOPQuery->dwFlags & RSOP_FIX_SITENAME) == RSOP_FIX_SITENAME )
{
iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_COMBO1), CB_FINDSTRINGEXACT,
(WPARAM) -1, (LPARAM) m_pRSOPQuery->szSite );
}
else if ( m_pRSOPQuery->szSite != NULL )
{
iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_COMBO1), CB_FINDSTRINGEXACT,
(WPARAM) -1, (LPARAM) m_pRSOPQuery->szSite);
}
SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_SETCURSEL,
(WPARAM) (iDefault == CB_ERR) ? iIndex : iDefault, NULL);
if ( szDomain != NULL )
{
delete [] szDomain;
}
}
//-------------------------------------------------------
BOOL CRSOPWizardDlg::IsComputerRSoPEnabled(LPTSTR lpComputerName)
{
LPSTR lpComputerNameA;
LPTSTR lpName, lpWMIPath;
HRESULT hr;
BOOL bRetVal = FALSE;
struct hostent *hostp;
DWORD dwResult, dwSize = (lstrlen(lpComputerName) + 1) * 2;
ULONG inaddr, ulSpeed;
IWbemLocator * pLocator = 0;
IWbemServices * pNamespace = 0;
BSTR bstrPath;
SetLastError(ERROR_SUCCESS);
//
// Allocate memory for a ANSI computer name
//
lpComputerNameA = new CHAR[dwSize];
if (lpComputerNameA)
{
//
// Skip the leading \\ if present
//
if ((*lpComputerName == TEXT('\\')) && (*(lpComputerName+1) == TEXT('\\')))
{
lpName = lpComputerName + 2;
}
else
{
lpName = lpComputerName;
}
//
// Convert the computer name to ANSI
//
if (WideCharToMultiByte (CP_ACP, 0, lpName, -1, lpComputerNameA, dwSize, NULL, NULL))
{
//
// Get the host information for the computer
//
hostp = gethostbyname(lpComputerNameA);
if (hostp)
{
//
// Get the ip address of the computer
//
inaddr = *(long *)hostp->h_addr;
//
// Create an instance of the WMI locator
//
hr = CoCreateInstance(CLSID_WbemLocator, 0, CLSCTX_INPROC_SERVER,
IID_IWbemLocator, (LPVOID *) &pLocator);
if (SUCCEEDED(hr))
{
//
// Try to connect to the rsop namespace
//
dwSize = lstrlen(lpName) + 20;
lpWMIPath = new TCHAR[dwSize];
if (lpWMIPath)
{
hr = StringCchPrintf (lpWMIPath, dwSize, TEXT("\\\\%s\\root\\rsop"), lpName);
if (SUCCEEDED(hr))
{
bstrPath = SysAllocString(lpWMIPath);
if (bstrPath)
{
hr = pLocator->ConnectServer(bstrPath,
NULL,
NULL,
NULL,
0,
NULL,
NULL,
&pNamespace);
if (SUCCEEDED(hr))
{
//
// Success. This computer has RSOP support
//
pNamespace->Release();
bRetVal = TRUE;
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: ConnectServer for %s failed with 0x%x"), bstrPath, hr));
}
SysFreeString (bstrPath);
//
// Set hr into the last error code. Note, this has to happen after
// the call to SysFreeString since it changes the last error code
// to success
//
if (hr != S_OK)
{
SetLastError(hr);
}
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: SysAllocString failed")));
SetLastError(ERROR_OUTOFMEMORY);
}
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: Could not copy WMI path")));
SetLastError(HRESULT_CODE(hr));
}
delete [] lpWMIPath;
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: Failed to alloc memory for wmi path.")));
SetLastError(ERROR_OUTOFMEMORY);
}
pLocator->Release();
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: CoCreateInstance failed with 0x%x."), hr));
SetLastError((DWORD)hr);
}
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: gethostbyname failed with %d."), WSAGetLastError()));
SetLastError(WSAGetLastError());
}
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: WideCharToMultiByte failed with %d"), GetLastError()));
}
delete [] lpComputerNameA;
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::IsComputerRSoPEnabled: Failed to allocate memory for ansi dc name")));
SetLastError(ERROR_OUTOFMEMORY);
}
return bRetVal;
}
//-------------------------------------------------------
BOOL CRSOPWizardDlg::TestAndValidateComputer(HWND hDlg)
// RSOP_LOGGING_MODE - only called in RSOPGetCompDlgProc
{
LPTSTR lpMachineName = NULL;
BOOL bOk = TRUE;
HKEY hKeyRoot = 0, hKey = 0;
DWORD dwType, dwSize, dwValue = 1;
INT iRet;
TCHAR szMessage[200];
TCHAR szCaption[100];
LONG lResult;
HRESULT hr;
ULONG ulNoChars;
if ( (m_pRSOPQuery->szComputerName != NULL) && lstrcmpi(m_pRSOPQuery->szComputerName, TEXT(".")) )
{
ulNoChars = lstrlen(m_pRSOPQuery->szComputerName) + 3;
lpMachineName = new TCHAR[ulNoChars];
if ( lpMachineName == NULL )
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: Failed to allocate memory with %d"), GetLastError()));
goto Exit;
}
hr = StringCchCopy (lpMachineName, ulNoChars, TEXT("\\\\"));
if (SUCCEEDED(hr))
{
if ((lstrlen (m_pRSOPQuery->szComputerName) > 2) && (m_pRSOPQuery->szComputerName[0] == TEXT('\\')) &&
(m_pRSOPQuery->szComputerName[1] == TEXT('\\')))
{
hr = StringCchCat (lpMachineName, ulNoChars, m_pRSOPQuery->szComputerName + 2);
}
else
{
hr = StringCchCat (lpMachineName, ulNoChars, NameWithoutDomain(m_pRSOPQuery->szComputerName) );
}
}
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: Could not copy machine name with 0x%x"), hr));
goto Exit;
}
}
SetWaitCursor();
//
// If we are testing a remote machine, test if the machine is alive and has
// the rsop namespace
//
if ( lpMachineName != NULL )
{
if (!IsComputerRSoPEnabled (lpMachineName))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: IsComputerRSoPEnabled failed on machine <%s>"), lpMachineName));
if (GetLastError() == WBEM_E_INVALID_NAMESPACE)
{
ReportError (hDlg, 0, IDS_DOWNLEVELCOMPUTER, m_pRSOPQuery->szComputerName);
}
else
{
ReportError (hDlg, GetLastError(), IDS_CONNECTSERVERFAILED, m_pRSOPQuery->szComputerName);
}
bOk = FALSE;
goto Exit;
}
}
//
// Check if the machine has rsop logging enabled or disabled
//
lResult = RegConnectRegistry (lpMachineName, HKEY_LOCAL_MACHINE, &hKeyRoot);
ClearWaitCursor();
if (lResult != ERROR_SUCCESS)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: Failed to connect to %s with %d"),
lpMachineName, lResult));
bOk = TRUE;
dwValue = 1; // Ignore errors at this point and assume that rsop is enabled on the machine
goto Exit;
}
lResult = RegOpenKeyEx (hKeyRoot, TEXT("Software\\Policies\\Microsoft\\Windows\\System"),
0, KEY_READ, &hKey);
if (lResult == ERROR_SUCCESS)
{
dwSize = sizeof (dwValue);
lResult = RegQueryValueEx (hKey, TEXT("RsopLogging"), NULL, &dwType, (LPBYTE) &dwValue,
&dwSize);
RegCloseKey (hKey);
if (lResult == ERROR_SUCCESS)
{
RegCloseKey (hKeyRoot);
goto Exit;
}
}
lResult = RegOpenKeyEx (hKeyRoot, TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"),
0, KEY_READ, &hKey);
if (lResult != ERROR_SUCCESS)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: Failed to open winlogon key with %d"),
lResult));
RegCloseKey (hKeyRoot);
goto Exit;
}
dwSize = sizeof (dwValue);
RegQueryValueEx (hKey, TEXT("RsopLogging"), NULL, &dwType, (LPBYTE) &dwValue, &dwSize);
RegCloseKey (hKey);
RegCloseKey (hKeyRoot);
Exit:
if (bOk && (dwValue == 0))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: RSOP Logging is not enabled on %s"),
lpMachineName));
LoadString(g_hInstance, IDS_RSOPLOGGINGDISABLED, szMessage, ARRAYSIZE(szMessage));
LoadString(g_hInstance, IDS_RSOPLOGGINGTITLE, szCaption, ARRAYSIZE(szCaption));
iRet = MessageBox (hDlg, szMessage, szCaption, MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2);
if (iRet == IDNO)
{
bOk = FALSE;
}
}
if (lpMachineName)
{
delete [] lpMachineName;
}
return bOk;
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::InitializeDCInfo (HWND hDlg)
// RSOP_PLANNING_MODE - ...
{
LPTSTR szDomain = NULL;
DWORD dwError = ERROR_SUCCESS;
INT iDefault = LB_ERR, nPDC = LB_ERR, nCount = 0;
if ( m_pRSOPQuery->QueryType != RSOP_PLANNING_MODE )
{
return;
}
// Determine the focused domain so we can focus on the correct DC.
// Determine the focused domain.
if ( m_pRSOPQuery->pComputer->szName != NULL )
{
// Try and get the computer's domain
szDomain = ExtractDomain( m_pRSOPQuery->pComputer->szName );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pComputer->szSOM != NULL) )
{
// Try and get the computer's domain from the SOM
szDomain = GetDomainFromSOM( m_pRSOPQuery->pComputer->szSOM );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pUser->szName != NULL) )
{
// Try and get the user's domain
szDomain = ExtractDomain( m_pRSOPQuery->pUser->szName );
}
if ( (szDomain == NULL) && (m_pRSOPQuery->pUser->szSOM != NULL) )
{
// Try and get the user's domain from the SOM
szDomain = GetDomainFromSOM( m_pRSOPQuery->pUser->szSOM );
}
if ( szDomain == NULL )
{
// Use the local domain
LPTSTR szName;
szName = MyGetUserName(NameSamCompatible);
if ( szName != NULL )
{
szDomain = ExtractDomain(szName);
LocalFree( szName );
}
}
if ( szDomain != NULL )
{
DWORD cInfo;
INT n;
PDS_DOMAIN_CONTROLLER_INFO_1 pInfo = NULL;
HANDLE hDs;
DWORD result;
ULONG uDCCount = 0;
result = DsBind(NULL, szDomain, &hDs);
if (ERROR_SUCCESS == result)
{
result = DsGetDomainControllerInfo(hDs,
szDomain,
1,
&cInfo,
(void **)&pInfo);
if (ERROR_SUCCESS == result)
{
// Enumerate the list
for (n = 0; (DWORD)n < cInfo; n++)
{
if (pInfo[n].DnsHostName != NULL)
{
uDCCount ++;
}
else
{
continue;
}
if (IsComputerRSoPEnabled(pInfo[n].DnsHostName))
{
SendMessage(GetDlgItem(hDlg, IDC_LIST1), LB_ADDSTRING, 0, (LPARAM)pInfo[n].DnsHostName);
if (pInfo[n].fIsPdc)
{
nPDC = n;
}
nCount++;
}
else
{
dwError = GetLastError();
}
}
if (nCount)
{
// Set the initial selection
if ( m_pRSOPQuery->szDomainController != NULL )
{
iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_LIST1), LB_FINDSTRING,
(WPARAM) -1, (LPARAM) m_pRSOPQuery->szDomainController);
}
else if (nPDC != LB_ERR)
{
iDefault = (INT) SendMessage(GetDlgItem(hDlg, IDC_LIST1), LB_FINDSTRINGEXACT,
(WPARAM) -1, (LPARAM) pInfo[nPDC].DnsHostName);
}
SendMessage(GetDlgItem(hDlg, IDC_LIST1), LB_SETCURSEL,
(WPARAM) (iDefault == LB_ERR) ? 0 : iDefault, NULL);
}
else
{
ReportError (hDlg, dwError, IDS_NORSOPDC, szDomain);
}
DsFreeDomainControllerInfo(1, cInfo, pInfo);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeDCInfo: DsGetDomainControllerInfo to %s failed with %d."), szDomain, result));
}
if (0 == uDCCount)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeDCInfo: DsGetDomainControllerInfo to %s returned DCs with no DNS host name"), szDomain));
}
DsUnBind(&hDs);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeDCInfo: DsBind to %s failed with %d."), szDomain, result));
ReportError(hDlg, result, IDS_DSBINDFAILED);
}
delete [] szDomain;
}
}
//-------------------------------------------------------
DWORD CRSOPWizardDlg::GetDefaultGroupCount()
{
return 2;
}
VOID CRSOPWizardDlg::AddDefaultGroups (HWND hLB)
{
SID_IDENTIFIER_AUTHORITY authNT = SECURITY_NT_AUTHORITY;
SID_IDENTIFIER_AUTHORITY authWORLD = SECURITY_WORLD_SID_AUTHORITY;
PSID psidUser, psidEveryone;
DWORD dwNameSize, dwDomainSize;
TCHAR szName[200];
TCHAR szDomain[65];
SID_NAME_USE SidName;
INT iIndex;
//
// Get the authenticated users sid
//
if (AllocateAndInitializeSid(&authNT, 1, SECURITY_AUTHENTICATED_USER_RID,
0, 0, 0, 0, 0, 0, 0, &psidUser))
{
//
// Get the friendly display name and add it to the list
//
dwNameSize = ARRAYSIZE(szName);
dwDomainSize = ARRAYSIZE(szDomain);
if (LookupAccountSid (NULL, psidUser, szName, &dwNameSize,
szDomain, &dwDomainSize, &SidName))
{
iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szName);
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) 1);
}
FreeSid(psidUser);
}
//
// Get the everyone sid
//
if (AllocateAndInitializeSid(&authWORLD, 1, SECURITY_WORLD_RID,
0, 0, 0, 0, 0, 0, 0, &psidEveryone))
{
//
// Get the friendly display name and add it to the list
//
dwNameSize = ARRAYSIZE(szName);
dwDomainSize = ARRAYSIZE(szDomain);
if (LookupAccountSid (NULL, psidEveryone, szName, &dwNameSize,
szDomain, &dwDomainSize, &SidName))
{
iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szName);
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) 1);
}
FreeSid(psidEveryone);
}
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::BuildMembershipList (HWND hLB, IDirectoryObject * pDSObj, DWORD* pdwCount, LPTSTR** paszSecGrps, DWORD** padwSecGrpAttr)
{
HRESULT hr;
PADS_ATTR_INFO spAttrs;
DWORD i, j, cAttrs = 0;
WCHAR wzMembershipAttr[MAX_PATH] = L"memberOf;range=0-*";
const WCHAR wcSep = L'-';
const WCHAR wcEnd = L'*';
const WCHAR wzFormat[] = L"memberOf;range=%ld-*";
BOOL fMoreRemain = FALSE;
PWSTR rgpwzAttrNames[] = {wzMembershipAttr};
TCHAR szDisplayName[MAX_PATH];
ULONG ulSize;
LPTSTR lpFullName, lpTemp;
IADs * pGroup;
VARIANT varType;
BSTR bstrGroupType = NULL;
SetWaitCursor();
SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
SendMessage (hLB, LB_RESETCONTENT, 0, 0);
AddDefaultGroups (hLB);
if (!pDSObj)
goto BuildMembershipListEnd;
GetPrimaryGroup (hLB, pDSObj);
bstrGroupType = SysAllocString( TEXT("groupType") );
if ( bstrGroupType == NULL )
{
goto BuildMembershipListEnd;
}
//
// Read the membership list from the object. First read the attribute off
// of the actual object which will give all memberships in the object's
// domain (including local groups which are not replicated to the GC).
//
do
{
hr = pDSObj->GetObjectAttributes(rgpwzAttrNames, 1, &spAttrs, &cAttrs);
if (SUCCEEDED(hr))
{
if (cAttrs > 0 && spAttrs != NULL)
{
for (i = 0; i < spAttrs->dwNumValues; i++)
{
ulSize = (lstrlen(spAttrs->pADsValues[i].CaseIgnoreString) + 10);
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulSize * sizeof(TCHAR));
if (lpFullName)
{
hr = StringCchCopy (lpFullName, ulSize, TEXT("LDAP://"));
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpFullName, ulSize, spAttrs->pADsValues[i].CaseIgnoreString);
}
if (SUCCEEDED(hr))
{
hr = OpenDSObject(lpFullName, IID_IADs, (void**)&pGroup);
if (SUCCEEDED(hr))
{
if (SUCCEEDED(pGroup->Get(bstrGroupType, &varType)))
{
if ( varType.lVal & 0x80000000)
{
if ( varType.lVal & 0x5)
{
lpTemp = lpFullName;
while (*lpTemp && (*lpTemp != TEXT(',')))
{
lpTemp++;
}
if (*lpTemp)
{
*lpTemp = TEXT('\0');
SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) (lpFullName+10));
}
}
else
{
if (TranslateName (spAttrs->pADsValues[i].CaseIgnoreString, NameFullyQualifiedDN,
NameSamCompatible, lpFullName, &ulSize))
{
SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) lpFullName);
}
}
}
VariantClear (&varType);
}
pGroup->Release();
}
}
LocalFree (lpFullName);
}
}
//
// Check to see if there is more data. If the last char of the
// attribute name string is an asterisk, then we have everything.
//
int cchEnd = wcslen(spAttrs->pszAttrName);
fMoreRemain = spAttrs->pszAttrName[cchEnd - 1] != wcEnd;
if (fMoreRemain)
{
PWSTR pwz = wcsrchr(spAttrs->pszAttrName, wcSep);
if (!pwz)
{
fMoreRemain = FALSE;
}
else
{
pwz++; // move past the hyphen to the range end value.
long lEnd = _wtol(pwz);
lEnd++; // start with the next value.
hr = StringCchPrintf (wzMembershipAttr, ARRAYSIZE(wzMembershipAttr), wzFormat, lEnd);
if (SUCCEEDED(hr))
{
DebugMsg((DM_VERBOSE, TEXT("Range returned is %s, now asking for %s"),
spAttrs->pszAttrName, wzMembershipAttr));
}
else
{
DebugMsg((DM_WARNING, TEXT("Could not copy membership attributes with 0x%x"),hr));
break;
}
}
}
}
FreeADsMem (spAttrs);
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildMembershipList: GetObjectAttributes failed with 0x%s"), hr));
}
} while (fMoreRemain);
BuildMembershipListEnd:
SendMessage (hLB, LB_SETCURSEL, 0, 0);
SendMessage (hLB, WM_SETREDRAW, TRUE, 0);
UpdateWindow (hLB);
SaveSecurityGroups (hLB, pdwCount, paszSecGrps, padwSecGrpAttr);
if ( bstrGroupType != NULL )
{
SysFreeString( bstrGroupType );
}
ClearWaitCursor();
return S_OK;
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::GetPrimaryGroup (HWND hLB, IDirectoryObject * pDSObj)
{
HRESULT hr;
PADS_ATTR_INFO spAttrs;
WCHAR wzObjectSID[] = L"objectSid";
WCHAR wzPrimaryGroup[] = L"primaryGroupID";
PWSTR rgpwzAttrNames[] = {wzObjectSID, wzPrimaryGroup};
DWORD cAttrs = 2, i;
DWORD dwOriginalPriGroup = 0;
LPBYTE pObjSID = NULL;
UCHAR * psaCount, iIndex;
PSID pSID = NULL;
PSID_IDENTIFIER_AUTHORITY psia;
DWORD rgRid[8];
TCHAR szName[200];
TCHAR szDomain[300];
TCHAR *szFullName;
DWORD dwNameSize, dwDomainSize;
SID_NAME_USE SidName;
//
// Get the SID and perhaps the Primary Group attribute values.
//
hr = pDSObj->GetObjectAttributes(rgpwzAttrNames, cAttrs, &spAttrs, &cAttrs);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: GetObjectAttributes failed with 0x%x"), hr));
return;
}
for (i = 0; i < cAttrs; i++)
{
if (_wcsicmp(spAttrs[i].pszAttrName, wzPrimaryGroup) == 0)
{
dwOriginalPriGroup = spAttrs[i].pADsValues->Integer;
continue;
}
if (_wcsicmp(spAttrs[i].pszAttrName, wzObjectSID) == 0)
{
pObjSID = new BYTE[spAttrs[i].pADsValues->OctetString.dwLength];
if (!pObjSID)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: Failed to allocate memory for sid with %d"), GetLastError()));
goto Exit;
}
memcpy(pObjSID, spAttrs[i].pADsValues->OctetString.lpValue,
spAttrs[i].pADsValues->OctetString.dwLength);
}
}
if (!IsValidSid (pObjSID))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: SID is not valid.")));
goto Exit;
}
psaCount = GetSidSubAuthorityCount(pObjSID);
if (psaCount == NULL)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: GetSidSubAuthorityCount failed with %d"), GetLastError()));
goto Exit;
}
if (*psaCount > 8)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: psaCount is greater than 8")));
goto Exit;
}
for (iIndex = 0; iIndex < (*psaCount - 1); iIndex++)
{
PDWORD pRid = GetSidSubAuthority(pObjSID, (DWORD)iIndex);
if (pRid == NULL)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: GetSidSubAuthority failed with %d"), GetLastError()));
goto Exit;
}
rgRid[iIndex] = *pRid;
}
rgRid[*psaCount - 1] = dwOriginalPriGroup;
for (iIndex = *psaCount; iIndex < 8; iIndex++)
{
rgRid[iIndex] = 0;
}
psia = GetSidIdentifierAuthority(pObjSID);
if (psia == NULL)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: GetSidIdentifierAuthorityCount failed with %d"), GetLastError()));
goto Exit;
}
if (!AllocateAndInitializeSid(psia, *psaCount, rgRid[0], rgRid[1],
rgRid[2], rgRid[3], rgRid[4],
rgRid[5], rgRid[6], rgRid[7], &pSID))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: AllocateAndInitializeSid failed with %d"), GetLastError()));
goto Exit;
}
dwNameSize = ARRAYSIZE(szName);
dwDomainSize = ARRAYSIZE(szDomain);
if (LookupAccountSid (NULL, pSID, szName, &dwNameSize, szDomain, &dwDomainSize,
&SidName))
{
ULONG ulNoChars = lstrlen(szDomain) + lstrlen(szName) + 1 + 1;
szFullName = (WCHAR *) LocalAlloc(LPTR, ulNoChars * sizeof(WCHAR));
if (szFullName != NULL)
{
hr = StringCchPrintf (szFullName, ulNoChars, TEXT("%s\\%s"), szDomain, szName);
ASSERT(SUCCEEDED(hr));
SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szFullName);
LocalFree(szFullName);
}
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: LookupAccountSid failed with %d"), GetLastError()));
}
FreeSid (pSID);
Exit:
FreeADsMem (spAttrs);
if (pObjSID)
{
delete [] pObjSID;
}
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::SaveSecurityGroups (HWND hLB, DWORD* pdwCount, LPTSTR** paszSecGrps, DWORD** padwSecGrpAttr)
{
LONG i, lCount = 0;
DWORD dwLen;
LPTSTR lpText;
BSTR bstrText;
HRESULT hr;
if ( (*paszSecGrps != NULL) || (*padwSecGrpAttr != NULL) )
{
DebugMsg( (DM_WARNING, TEXT("CRSOPComponentData::SaveSecurityGroups: Arrays passed in are not NULL!")) );
return E_FAIL;
}
// Get number of items from list box
lCount = (LONG) SendMessage (hLB, LB_GETCOUNT, 0, 0);
if ( lCount == 0 )
{
*pdwCount = 0;
return S_OK;
}
*paszSecGrps = (LPTSTR*)LocalAlloc( LPTR, sizeof(LPTSTR) * lCount );
if ( *paszSecGrps == NULL )
{
return E_OUTOFMEMORY;
}
*padwSecGrpAttr = (DWORD*)LocalAlloc( LPTR, sizeof(DWORD) * lCount );
if ( *padwSecGrpAttr == NULL )
{
LocalFree( *paszSecGrps );
*paszSecGrps = NULL;
return E_OUTOFMEMORY;
}
*pdwCount = lCount;
for ( i = 0; i < lCount; i++ )
{
dwLen = (DWORD) SendMessage (hLB, LB_GETTEXTLEN, (WPARAM) i, 0);
if (dwLen != LB_ERR)
{
lpText = (LPTSTR)LocalAlloc( LPTR, (dwLen+2) * sizeof(TCHAR) );
// RM: Should actually do something here if memory allocation fails!
if ( lpText != NULL )
{
if (SendMessage (hLB, LB_GETTEXT, (WPARAM) i, (LPARAM) lpText) != LB_ERR)
{
LONG lFlags;
BOOL bDollarRemoved;
lFlags = (LONG) SendMessage (hLB, LB_GETITEMDATA, (WPARAM) i, 0);
bDollarRemoved = (lFlags & 2);
if (bDollarRemoved)
{
lpText[wcslen(lpText)] = L'$';
}
if (lFlags & 1)
{ // default grps
(*padwSecGrpAttr)[i] = 1;
}
(*paszSecGrps)[i] = lpText;
}
}
}
}
return S_OK;
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::FillListFromSecurityGroups(HWND hLB, DWORD dwCount, LPTSTR* aszSecurityGroups, DWORD* adwSecGrpAttr)
{
DWORD dwIndex;
LPTSTR lpText;
SetWaitCursor();
SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
SendMessage (hLB, LB_RESETCONTENT, 0, 0);
if ( (dwCount != 0) && (aszSecurityGroups != NULL) )
{
for ( dwIndex = 0; dwIndex < dwCount; dwIndex++ )
{
BOOL bDollarRemoved = FALSE;
lpText = aszSecurityGroups[dwIndex];
if (lpText[wcslen(lpText)-1] == L'$')
{
bDollarRemoved = TRUE;
lpText[wcslen(lpText)-1] = 0;
}
INT iIndex;
iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) lpText);
if ( (adwSecGrpAttr != NULL) && (adwSecGrpAttr[dwIndex] & 1) )
{
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) 1);
}
else
{
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) (bDollarRemoved) ? 2 : 0);
}
// we just modified it, set it back
if (bDollarRemoved)
{
lpText[wcslen(lpText)] = L'$';
}
}
}
SendMessage (hLB, LB_SETCURSEL, 0, 0);
SendMessage (hLB, WM_SETREDRAW, TRUE, 0);
UpdateWindow (hLB);
ClearWaitCursor();
}
//-------------------------------------------------------
VOID CRSOPWizardDlg::FillListFromWQLFilters( HWND hLB, DWORD dwCount, LPTSTR* aszNames, LPTSTR* aszFilters )
{
INT iIndex;
DWORD dwIndex;
SetWaitCursor();
SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
SendMessage (hLB, LB_RESETCONTENT, 0, 0);
if ( dwCount != 0 )
{
for ( dwIndex = 0; dwIndex < dwCount; dwIndex++ )
{
iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) aszNames[dwIndex] );
DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::FillListFromSafeArrays: Added WQL filter %s"), aszNames[dwIndex]));
if (iIndex != LB_ERR)
{
SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) aszFilters[dwIndex] );
}
}
}
SendMessage (hLB, LB_SETCURSEL, 0, 0);
SendMessage (hLB, WM_SETREDRAW, TRUE, 0);
UpdateWindow (hLB);
ClearWaitCursor();
}
VOID CRSOPWizardDlg::BuildWQLFilterList (HWND hDlg, BOOL bUser, DWORD* pdwCount, LPTSTR** paszNames, LPTSTR** paszFilters )
{
HRESULT hr;
LPTSTR szNameSpace = NULL;
LPTSTR lpFullNameSpace, lpEnd;
TCHAR szBuffer[150];
HWND hLB = GetDlgItem (hDlg, IDC_LIST1);
ULONG ulErrorInfo;
//
// Prepare to generate the rsop data. Give the user a message in the listbox
// and disable the controls on the page
//
SetWaitCursor();
SendMessage (hLB, LB_RESETCONTENT, 0, 0);
LoadString(g_hInstance, IDS_PLEASEWAIT, szBuffer, ARRAYSIZE(szBuffer));
SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szBuffer);
PropSheet_SetWizButtons (GetParent(hDlg), 0);
EnableWindow (GetDlgItem(GetParent(hDlg), IDCANCEL), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
//
// Generate the rsop data using the info we have already
//
hr = CRSOPWizard::GenerateRSOPData(NULL, m_pRSOPQuery, &szNameSpace, TRUE, TRUE, bUser, FALSE, &ulErrorInfo);
SendMessage (hLB, LB_RESETCONTENT, 0, 0);
if (FAILED (hr))
{
ReportError (hDlg, hr, IDS_EXECFAILED);
goto Exit;
}
ULONG ulNoChars;
ulNoChars = lstrlen(szNameSpace) + 20;
lpFullNameSpace = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpFullNameSpace)
{
hr = StringCchCopy (lpFullNameSpace, ulNoChars, szNameSpace);
if (SUCCEEDED(hr))
{
lpEnd = CheckSlash(lpFullNameSpace);
if (bUser)
{
hr = StringCchCopy (lpEnd, ulNoChars - lstrlen(lpFullNameSpace), TEXT("User"));
}
else
{
hr = StringCchCopy (lpEnd, ulNoChars - lstrlen(lpFullNameSpace), TEXT("Computer"));
}
}
if (SUCCEEDED(hr))
{
if (SUCCEEDED(ExtractWQLFilters (lpFullNameSpace, pdwCount, paszNames, paszFilters) ))
{
FillListFromWQLFilters( hLB, *pdwCount, *paszNames, *paszFilters );
}
}
LocalFree (lpFullNameSpace);
}
CRSOPWizard:: DeleteRSOPData( szNameSpace, m_pRSOPQuery );
LocalFree( szNameSpace );
Exit:
PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
EnableWindow (GetDlgItem(GetParent(hDlg), IDCANCEL), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), TRUE);
EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), TRUE);
ClearWaitCursor();
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::SaveWQLFilters (HWND hLB, DWORD* pdwCount, LPTSTR** paszNames, LPTSTR**paszFilters )
{
LONG i, lLength, lCount = 0;
LPTSTR lpText, lpName;
BSTR bstrText;
HRESULT hr;
if ( (*paszNames != NULL) || (*paszFilters != NULL) )
{
DebugMsg( (DM_WARNING, TEXT("CRSOPComponentData::SaveWQLFilters: Arrays passed in are not NULL!")) );
return E_FAIL;
}
// Getting the number of items
lCount = (LONG) SendMessage (hLB, LB_GETCOUNT, 0, 0);
if ( lCount == 0 )
{
*pdwCount = 0;
return S_OK;
}
*paszNames = (LPTSTR*)LocalAlloc( LPTR, sizeof(LPTSTR) * lCount );
if ( *paszNames == NULL )
{
return E_OUTOFMEMORY;
}
*paszFilters = (LPTSTR*)LocalAlloc( LPTR, sizeof(LPTSTR) * lCount );
if ( *paszFilters == NULL )
{
LocalFree( *paszNames );
*paszNames = NULL;
return E_OUTOFMEMORY;
}
*pdwCount = lCount;
for ( i = 0; i < lCount; i++ )
{
lLength = (LONG) SendMessage (hLB, LB_GETTEXTLEN, (WPARAM) i, 0);
lpName = (LPTSTR)LocalAlloc( LPTR, sizeof(TCHAR) * (lLength + 1) );
if ( lpName != NULL )
{
if (SendMessage (hLB, LB_GETTEXT, (WPARAM) i, (LPARAM) lpName) != LB_ERR)
{
(*paszNames)[i] = lpName;
lpText = (LPTSTR) SendMessage (hLB, LB_GETITEMDATA, (WPARAM) i, 0);
if (lpText)
{
ULONG ulNoChars = wcslen(lpText) + 1;
(*paszFilters)[i] = (LPTSTR)LocalAlloc( LPTR, sizeof(TCHAR) * ulNoChars );
if ( (*paszFilters)[i] != NULL )
{
hr = StringCchCopy( (*paszFilters)[i], ulNoChars, lpText );
ASSERT(SUCCEEDED(hr));
}
}
}
else
{
LocalFree( lpName );
}
}
}
return S_OK;
}
//-------------------------------------------------------
BOOL CRSOPWizardDlg::CompareStringLists( DWORD dwCountA, LPTSTR* aszListA, DWORD dwCountB, LPTSTR* aszListB )
{
BOOL bFound;
DWORD dwA, dwB;
//
// Parameter checks
//
if ( dwCountA != dwCountB )
{
return FALSE;
}
if ( (dwCountA == 0) && (dwCountB == 0) )
{
return TRUE;
}
if ( dwCountA == 0 )
{
return FALSE;
}
if ( dwCountB == 0 )
{
return FALSE;
}
if ( (aszListA == NULL) || (aszListB == NULL) )
{
return FALSE;
}
//
// Loop through comparing item by item
//
for ( dwA = 0; dwA < dwCountA; dwA++ )
{
bFound = FALSE;
for ( dwB = 0; dwB < dwCountB; dwB++ )
{
if ( !lstrcmpi( aszListA[dwA], aszListB[dwB] ) )
{
bFound = TRUE;
}
}
if (!bFound)
{
return FALSE;
}
}
return TRUE;
}
//-------------------------------------------------------
LPTSTR CRSOPWizardDlg::GetDefaultSOM (LPTSTR lpDNName)
{
HRESULT hr;
LPTSTR lpPath = NULL;
IADsPathname * pADsPathname = NULL;
BSTR bstrContainer = NULL;
//
// Create a pathname object we can work with
//
hr = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER,
IID_IADsPathname, (LPVOID*)&pADsPathname);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to create adspathname instance with 0x%x"), hr));
goto Exit;
}
//
// Add the DN name
//
BSTR bstrDNName = SysAllocString( lpDNName );
if ( bstrDNName == NULL )
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to allocate BSTR memory.")));
hr = E_OUTOFMEMORY;
goto Exit;
}
hr = pADsPathname->Set (bstrDNName, ADS_SETTYPE_DN);
SysFreeString( bstrDNName );
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to set pathname with 0x%x"), hr));
goto Exit;
}
//
// Remove the user / computer name
//
hr = pADsPathname->RemoveLeafElement ();
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to retreive GPO name with 0x%x"), hr));
goto Exit;
}
//
// Get the new path
//
hr = pADsPathname->Retrieve (ADS_FORMAT_X500_DN, &bstrContainer);
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CGroupPolicyObject::New: Failed to retreive container path with 0x%x"), hr));
goto Exit;
}
//
// Allocate a new buffer for the path
//
ULONG ulNoChars = lstrlen(bstrContainer)+ 1;
lpPath = new TCHAR [ulNoChars];
if (!lpPath)
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to allocate memory with %d"), GetLastError()));
goto Exit;
}
//
// Build the path
//
hr = StringCchCopy (lpPath, ulNoChars, bstrContainer);
ASSERT(SUCCEEDED(hr));
Exit:
if (bstrContainer)
{
SysFreeString (bstrContainer);
}
if (pADsPathname)
{
pADsPathname->Release();
}
return lpPath;
}
//-------------------------------------------------------
HRESULT CRSOPWizardDlg::TestSOM (LPTSTR lpSOM, HWND hDlg)
{
HRESULT hr = E_OUTOFMEMORY;
LPTSTR lpFullName;
IDirectoryObject * pObject;
ADS_OBJECT_INFO *pInfo;
if (!lpSOM)
{
return E_INVALIDARG;
}
ULONG ulNoChars = lstrlen(lpSOM) + 10;
lpFullName = (LPTSTR) LocalAlloc (LPTR, ulNoChars * sizeof(TCHAR));
if (lpFullName)
{
hr = StringCchCopy (lpFullName, ulNoChars, TEXT("LDAP://"));
if (SUCCEEDED(hr))
{
hr = StringCchCat (lpFullName, ulNoChars, lpSOM);
}
if (FAILED(hr))
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestSOM: Could not copy SOM name with 0x%x"), hr));
LocalFree(lpFullName);
return hr;
}
hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pObject);
if (SUCCEEDED(hr))
{
hr = pObject->GetObjectInformation (&pInfo);
if (SUCCEEDED(hr))
{
if (CompareString (LOCALE_INVARIANT, NORM_IGNORECASE, pInfo->pszClassName, -1, TEXT("user"), -1) == CSTR_EQUAL)
{
hr = E_INVALIDARG;
ReportError (hDlg, hr, IDS_BADUSERSOM);
}
else if (CompareString (LOCALE_INVARIANT, NORM_IGNORECASE, pInfo->pszClassName, -1, TEXT("computer"), -1) == CSTR_EQUAL)
{
hr = E_INVALIDARG;
ReportError (hDlg, hr, IDS_BADCOMPUTERSOM);
}
FreeADsMem (pInfo);
}
pObject->Release();
}
else
{
DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestSOM: OpenDSObject to %s failed with 0x%x"), lpFullName, hr));
}
LocalFree (lpFullName);
}
return hr;
}