//+--------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1994 - 1997.
//
//  File:       rsoproot.cpp
//
//  Contents:   implementation of root RSOP snap-in node
//
//  Classes:    CRSOPComponentDataCF
//              CRSOPComponentData
//
//  Functions:
//
//  History:    09-13-1999   stevebl   Created
//
//---------------------------------------------------------------------------

#include "main.h"
#include "objsel.h" // for the object picker
#include "rsoputil.h"
#include <ntdsapi.h> // for the Ds*DomainController* API
#include "sddl.h"    // for sid to string functions

unsigned int CRSOPCMenu::m_cfDSObjectName  = RegisterClipboardFormat(CFSTR_DSOBJECTNAMES);

//
// Help ids
//

DWORD aBrowseForOUHelpIds[] =
{
    DSBID_BANNER,        IDH_RSOP_BANNER,
    DSBID_CONTAINERLIST, IDH_RSOP_CONTAINERLIST,

    0, 0
};

DWORD aGPOListHelpIds[] =
{
    IDC_LIST1,   IDH_RSOP_GPOLIST,
    IDC_CHECK1,  IDH_RSOP_GPOSOM,
    IDC_CHECK2,  IDH_RSOP_APPLIEDGPOS,
    IDC_CHECK3,  IDH_RSOP_REVISION,
    IDC_BUTTON1, IDH_RSOP_SECURITY,
    IDC_BUTTON2, IDH_RSOP_EDIT,

    0, 0
};

DWORD aErrorsHelpIds[] =
{
    IDC_LIST1,   IDH_RSOP_COMPONENTLIST,
    IDC_EDIT1,   IDH_RSOP_COMPONENTDETAILS,
    IDC_BUTTON1, IDH_RSOP_SAVEAS,

    0, 0
};


DWORD aQueryHelpIds[] =
{
    IDC_LIST1,  IDH_RSOP_QUERYLIST,

    0, 0
};


DWORD aBrowseDCHelpIds[] =
{
    IDC_LIST1,  IDH_RSOP_BROWSEDC,

    0, 0
};

BSTR ParseDomainName( LPWSTR szDSObject );

//************************************************************************
//  ParseDN
//
//  Purpose:    Parses the given name to get the pieces. 
//
//  Parameters:
//          lpDSObject  - Path to the DS Obkect in the format LDAP://<DC-Name>/DN
//          pwszDomain  - Returns the <DC-Name>. This is allocated in the fn.
//          pszDN       - The DN part of lpDSObject
//          szSOM       - THe actual SOM (the node on which we have the rsop rights on
// 
// No return value. If memory couldn't be allocated for the pwszDomain it is returned as NULL
//
//************************************************************************


void ParseDN(LPWSTR lpDSObject, LPWSTR *pwszDomain, LPWSTR *pszDN, LPWSTR *szSOM)
{
    LPWSTR  szContainer = lpDSObject;
    LPWSTR  lpEnd = NULL;

   *pszDN = szContainer;

   if (CompareString (LOCALE_USER_DEFAULT, NORM_STOP_ON_NULL, TEXT("LDAP://"),
                      7, szContainer, 7) != CSTR_EQUAL)
   {
       DebugMsg((DM_WARNING, TEXT("GetSOMFromDN: Object does not start with LDAP://")));
       return;
   }

   szContainer += 7;
   
   lpEnd = szContainer;

   //
   // Move till the end of the domain name
   //

   *pwszDomain = NULL;

   while (*lpEnd && (*lpEnd != TEXT('/'))) {
       lpEnd++;
   }

   if (*lpEnd == TEXT('/')) {
       *pwszDomain = (LPWSTR)LocalAlloc(LPTR, sizeof(WCHAR)*( (lpEnd - szContainer) + 1));

       if (*pwszDomain) {
           wcsncpy(*pwszDomain, szContainer, (lpEnd - szContainer));
       }

       szContainer = lpEnd + 1;
   }


   *pszDN = szContainer;
   
   while (*szContainer) {

       //
       // See if the DN name starts with OU=
       //

       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE,
                          szContainer, 3, TEXT("OU="), 3) == CSTR_EQUAL) {
           break;
       }

       //
       // See if the DN name starts with DC=
       //

       else if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE,
                               szContainer, 3, TEXT("DC="), 3) == CSTR_EQUAL) {
           break;
       }


       //
       // Move to the next chunk of the DN name
       //

       while (*szContainer && (*szContainer != TEXT(','))) {
           szContainer++;
       }

       if (*szContainer == TEXT(',')) {
           szContainer++;
       }
   }

   *szSOM = szContainer;
   return;
}


BOOL IsPlanningModeAllowed()
{
    //
    // Check the SKU to see if planning is allowed -- it
    // is not implemented for the pro SKU
    //
    
    OSVERSIONINFOEXW version;
    
    version.dwOSVersionInfoSize = sizeof(version);
    
    if ( GetVersionEx( (LPOSVERSIONINFO) &version ) )
    {
        if ( version.wProductType != VER_NT_WORKSTATION )
        {
            //
            // This is a non-pro SKU, so we allow planning mode
            //
            return TRUE;
        }
    }

    return FALSE;
}



//*************************************************************
//
//  MyTranslateName()
//
//  Purpose:    Gets the user name in the requested format
//
//  Return:     lpUserName if successful
//              NULL if an error occurs
//
// Allocates and retries with the appropriate buffer size
//
//*************************************************************

LPTSTR MyTranslateName (LPTSTR lpAccName, EXTENDED_NAME_FORMAT  NameFormat, EXTENDED_NAME_FORMAT  desiredNameFormat)
{
    DWORD dwError = ERROR_SUCCESS;
    LPTSTR lpUserName = NULL, lpTemp;
    ULONG ulUserNameSize;


    //
    // Allocate a buffer for the user name
    //

    ulUserNameSize = 75;

    if (desiredNameFormat == NameFullyQualifiedDN) {
        ulUserNameSize = 200;
    }


    lpUserName = (LPTSTR) LocalAlloc (LPTR, ulUserNameSize * sizeof(TCHAR));

    if (!lpUserName) {
        dwError = GetLastError();
        DebugMsg((DM_WARNING, TEXT("MyGetUserName:  Failed to allocate memory with %d"),
                 dwError));
        goto Exit;
    }


    //
    // Get the username in the requested format
    //

    if (!TranslateName (lpAccName, NameFormat, desiredNameFormat, lpUserName, &ulUserNameSize)) {

        //
        // If the call failed due to insufficient memory, realloc
        // the buffer and try again.  Otherwise, exit now.
        //

        dwError = GetLastError();

        if (dwError != ERROR_INSUFFICIENT_BUFFER) {
            DebugMsg((DM_WARNING, TEXT("MyGetTranslateName:  TranslateName failed with %d"),
                     dwError));
            LocalFree (lpUserName);
            lpUserName = NULL;
            goto Exit;
        }

        lpTemp = (LPTSTR) LocalReAlloc (lpUserName, (ulUserNameSize * sizeof(TCHAR)),
                                       LMEM_MOVEABLE);

        if (!lpTemp) {
            dwError = GetLastError();
            DebugMsg((DM_WARNING, TEXT("MyGetTranslateName:  Failed to realloc memory with %d"),
                     dwError));
            LocalFree (lpUserName);
            lpUserName = NULL;
            goto Exit;
        }


        lpUserName = lpTemp;

        if (!TranslateName (lpAccName, NameFormat, desiredNameFormat, lpUserName, &ulUserNameSize)) {
            dwError = GetLastError();
            DebugMsg((DM_WARNING, TEXT("MyGetTranslateName:  TranslateName failed with %d"),
                     dwError));
            LocalFree (lpUserName);
            lpUserName = NULL;
            goto Exit;
        }

        dwError = ERROR_SUCCESS;
    }


Exit:

    SetLastError(dwError);

    return lpUserName;
}

//*************************************************************
//
//  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;
    }
}

WCHAR * NameWithoutDomain(WCHAR * szName)
{
    // The name passed in could be of the form
    // "domain/name"
    // or it could be just
    // "name"

    int cch = 0;
    if (NULL != szName)
    {
        while (szName[cch])
        {
            if (szName[cch] == L'/' || szName[cch] == L'\\')
            {
                return &szName[cch + 1];
            }
            cch++;
        }
    }
    return szName;
}

WCHAR* NormalizedComputerName(WCHAR * szComputerName )
{
    TCHAR* szNormalizedComputerName;
     
    // Computer names may start with '\\', so we will return
    // the computer name without that prefix if it exists

    szNormalizedComputerName = szComputerName;

    if ( szNormalizedComputerName )
    {
        // Make sure that the computer name string is at least 2 characters in length --
        // if the first character is non-zero, we know the second character must exist
        // since this is a zero terminated string -- in this case, it is safe to compare
        // the first 2 characters
        if ( *szNormalizedComputerName )
        {
            if ( ( TEXT('\\') == szNormalizedComputerName[0] ) &&
                 ( TEXT('\\') == szNormalizedComputerName[1] ) )
            {
                szNormalizedComputerName += 2;
            }
        }
    }

    return szNormalizedComputerName;
}

CRSOPComponentData::CRSOPComponentData()
{
    InterlockedIncrement(&g_cRefThisDll);

    m_cRef = 1;
    m_hwndFrame = NULL;
    m_bOverride = FALSE;
    m_bDirty = FALSE;
    m_bRefocusInit = FALSE;
    m_bArchiveData = FALSE;
    m_bViewIsArchivedData = FALSE;
    m_pScope = NULL;
    m_pConsole = NULL;
    m_hRoot = NULL;
    m_hMachine = NULL;
    m_hUser = NULL;

    m_pDisplayName = NULL;
    m_bDiagnostic = FALSE;
    m_szNamespace = NULL;
    m_bInitialized = FALSE;

    m_szComputerName = NULL;
    m_szComputerDNName = NULL;
    m_szComputerSOM = NULL;
    m_szDefaultComputerSOM = NULL;
    m_saComputerSecurityGroups = NULL;
    m_saDefaultComputerSecurityGroups = NULL;
    m_saComputerSecurityGroupsAttr = NULL;
    m_saDefaultComputerSecurityGroupsAttr = NULL;
    m_saComputerWQLFilters = NULL;
    m_saComputerWQLFilterNames = NULL;
    m_saDefaultComputerWQLFilters = NULL;
    m_saDefaultComputerWQLFilterNames = NULL;
    m_pComputerObject = NULL;
    m_bNoComputerData = FALSE;
    m_bComputerDeniedAccess = FALSE;

    m_szSite = NULL;
    m_szDC = NULL;
    m_bSlowLink = FALSE;
    m_loopbackMode = LoopbackNone;

    m_szUserName = NULL;
    m_szUserDNName = NULL;
    m_szUserDisplayName = NULL;
    m_szUserSOM = NULL;
    m_szDefaultUserSOM = NULL;
    m_saUserSecurityGroups = NULL;
    m_saUserSecurityGroupsAttr = NULL;
    m_saDefaultUserSecurityGroups = NULL;
    m_saDefaultUserSecurityGroupsAttr = NULL;
    m_saUserWQLFilters = NULL;
    m_saUserWQLFilterNames = NULL;
    m_saDefaultUserWQLFilters = NULL;
    m_saDefaultUserWQLFilterNames = NULL;
    m_pUserObject = NULL;
    m_bNoUserData = FALSE;
    m_bUserDeniedAccess = FALSE;

    m_dwSkippedFrom = 0;

    m_hChooseBitmap = NULL;

    m_pUserGPOList = NULL;
    m_pComputerGPOList = NULL;

    m_pUserCSEList = NULL;
    m_pComputerCSEList = NULL;

    m_bUserCSEError = FALSE;
    m_bComputerCSEError = FALSE;
    m_bUserGPCoreError = FALSE;
    m_bComputerGPCoreError = FALSE;

    m_szUserSOMPref = NULL;
    m_szComputerSOMPref = NULL;
    m_szUserNamePref = NULL;
    m_szComputerNamePref = NULL;
    m_szSitePref = NULL;
    m_szDCPref = NULL;
    m_bSkipUserWQLFilter = TRUE;
    m_bSkipComputerWQLFilter = TRUE;

    m_dwLoadFlags = RSOP_NOMSC;
    
    m_pEvents = new CEvents;

    m_hRichEdit = LoadLibrary (TEXT("riched20.dll"));

    m_BigBoldFont = NULL;
    m_BoldFont = NULL;


}

CRSOPComponentData::~CRSOPComponentData()
{
    FreeUserData();
    FreeComputerData();

    if (m_pEvents)
    {
        delete m_pEvents;
    }

    if (m_pUserCSEList)
    {
        FreeCSEData (m_pUserCSEList);
    }

    if (m_pComputerCSEList)
    {
        FreeCSEData (m_pComputerCSEList);
    }

    if (m_pUserGPOList)
    {
        FreeGPOListData (m_pUserGPOList);
    }

    if (m_pComputerGPOList)
    {
        FreeGPOListData (m_pComputerGPOList);
    }

    if (m_szSite)
    {
        delete [] m_szSite;
    }

    if (m_szDC)
    {
        delete [] m_szDC;
    }

    if (m_pDisplayName)
    {
        delete [] m_pDisplayName;
    }

    if (m_szNamespace)
    {
        delete [] m_szNamespace;
    }

    if (m_szUserSOMPref)
        LocalFree(m_szUserSOMPref);

    if (m_szComputerSOMPref)
        LocalFree(m_szComputerSOMPref);

    if (m_szUserNamePref)
        LocalFree(m_szUserNamePref);
                                                           
    if (m_szComputerNamePref)
        LocalFree(m_szComputerNamePref);

    if (m_szSitePref)
        LocalFree(m_szSitePref);

    if (m_szDCPref)
        LocalFree(m_szDCPref);

    if (m_hChooseBitmap)
    {
        DeleteObject (m_hChooseBitmap);
    }

    if (m_pScope)
    {
        m_pScope->Release();
    }

    if (m_pConsole)
    {
        m_pConsole->Release();
    }

    if (m_hRichEdit)
    {
        FreeLibrary (m_hRichEdit);
    }

    if ( m_BoldFont )
    {
        DeleteObject(m_BoldFont); m_BoldFont = NULL;
    }

    if ( m_BoldFont )
    {
        DeleteObject(m_BigBoldFont); m_BigBoldFont = NULL;
    }


    InterlockedDecrement(&g_cRefThisDll);
}

VOID CRSOPComponentData::FreeUserData (VOID)
{
    if (m_szUserName)
    {
        delete [] m_szUserName;
        m_szUserName = NULL;
    }

    if (m_szUserDNName)
    {
        delete [] m_szUserDNName;
        m_szUserDNName = NULL;
    }

    if (m_szUserDisplayName)
    {
        delete [] m_szUserDisplayName;
        m_szUserDisplayName = NULL;
    }

    if (m_szUserSOM)
    {
        delete [] m_szUserSOM;
        m_szUserSOM = NULL;
    }

    if (m_szDefaultUserSOM)
    {
        delete [] m_szDefaultUserSOM;
        m_szDefaultUserSOM = NULL;
    }

    if (m_saUserSecurityGroups)
    {
        SafeArrayDestroy (m_saUserSecurityGroups);
        m_saUserSecurityGroups = NULL;
    }

    if (m_saUserSecurityGroupsAttr)
    {
        LocalFree(m_saUserSecurityGroupsAttr);
        m_saUserSecurityGroupsAttr = NULL;
    }


    if (m_saDefaultUserSecurityGroups)
    {
        SafeArrayDestroy (m_saDefaultUserSecurityGroups);
        m_saDefaultUserSecurityGroups = NULL;
    }

    if (m_saDefaultUserSecurityGroupsAttr)
    {
        LocalFree (m_saDefaultUserSecurityGroupsAttr);
        m_saDefaultUserSecurityGroupsAttr = NULL;
    }

    if (m_saUserWQLFilters)
    {
        SafeArrayDestroy (m_saUserWQLFilters);
        m_saUserWQLFilters = NULL;
    }

    if (m_saUserWQLFilterNames)
    {
        SafeArrayDestroy (m_saUserWQLFilterNames);
        m_saUserWQLFilterNames = NULL;
    }

    if (m_saDefaultUserWQLFilters)
    {
        SafeArrayDestroy (m_saDefaultUserWQLFilters);
        m_saDefaultUserWQLFilters = NULL;
    }

    if (m_saDefaultUserWQLFilterNames)
    {
        SafeArrayDestroy (m_saDefaultUserWQLFilterNames);
        m_saDefaultUserWQLFilterNames = NULL;
    }

    m_bSkipUserWQLFilter = TRUE;

    if (m_pUserObject)
    {
        m_pUserObject->Release();
        m_pUserObject = NULL;
    }
}

VOID CRSOPComponentData::FreeComputerData (VOID)
{
    if (m_szComputerName)
    {
        delete [] m_szComputerName;
        m_szComputerName = NULL;
    }

    if (m_szComputerDNName)
    {
        delete [] m_szComputerDNName;
        m_szComputerDNName = NULL;
    }

    if (m_szComputerSOM)
    {
        delete [] m_szComputerSOM;
        m_szComputerSOM = NULL;
    }

    if (m_szDefaultComputerSOM)
    {
        delete [] m_szDefaultComputerSOM;
        m_szDefaultComputerSOM = NULL;
    }

    if (m_saComputerSecurityGroups)
    {
        SafeArrayDestroy (m_saComputerSecurityGroups);
        m_saComputerSecurityGroups = NULL;
    }

    if (m_saDefaultComputerSecurityGroups)
    {
        SafeArrayDestroy (m_saDefaultComputerSecurityGroups);
        m_saDefaultComputerSecurityGroups = NULL;
    }

    if (m_saComputerSecurityGroupsAttr)
    {
        LocalFree (m_saComputerSecurityGroupsAttr);
        m_saComputerSecurityGroupsAttr = NULL;
    }

    if (m_saDefaultComputerSecurityGroupsAttr)
    {
        LocalFree (m_saDefaultComputerSecurityGroupsAttr);
        m_saDefaultComputerSecurityGroupsAttr = NULL;
    }

    if (m_saComputerWQLFilters)
    {
        SafeArrayDestroy (m_saComputerWQLFilters);
        m_saComputerWQLFilters = NULL;
    }

    if (m_saComputerWQLFilterNames)
    {
        SafeArrayDestroy (m_saComputerWQLFilterNames);
        m_saComputerWQLFilterNames = NULL;
    }

    if (m_saDefaultComputerWQLFilters)
    {
        SafeArrayDestroy (m_saDefaultComputerWQLFilters);
        m_saDefaultComputerWQLFilters = NULL;
    }

    if (m_saDefaultComputerWQLFilterNames)
    {
        SafeArrayDestroy (m_saDefaultComputerWQLFilterNames);
        m_saDefaultComputerWQLFilterNames = NULL;
    }

    m_bSkipComputerWQLFilter = TRUE;

    if (m_pComputerObject)
    {
        m_pComputerObject->Release();
        m_pComputerObject = NULL;
    }


}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (IUnknown)                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


HRESULT CRSOPComponentData::QueryInterface (REFIID riid, void **ppv)
{
    if (IsEqualIID(riid, IID_IComponentData) || IsEqualIID(riid, IID_IUnknown))
    {
        *ppv = (LPCOMPONENT)this;
        m_cRef++;
        return S_OK;
    }
    else if (IsEqualIID(riid, IID_IExtendPropertySheet2))
    {
        *ppv = (LPEXTENDPROPERTYSHEET)this;
        m_cRef++;
        return S_OK;
    }
    else if (IsEqualIID(riid, IID_IExtendContextMenu))
    {
        *ppv = (LPEXTENDCONTEXTMENU)this;
        m_cRef++;
        return S_OK;
    }
    else if (IsEqualIID(riid, IID_IPersistStreamInit))
    {
        *ppv = (LPPERSISTSTREAMINIT)this;
        m_cRef++;
        return S_OK;
    }
    else if (IsEqualIID(riid, IID_ISnapinHelp))
    {
        *ppv = (LPSNAPINHELP)this;
        m_cRef++;
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}

ULONG CRSOPComponentData::AddRef (void)
{
    return ++m_cRef;
}

ULONG CRSOPComponentData::Release (void)
{
    if (--m_cRef == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP CRSOPComponentData::GetNamespace (DWORD dwSection, LPOLESTR pszName, int cchMaxLength)
{
    TCHAR szPath[2*MAX_PATH];
    LPTSTR lpEnd;


    //
    // Check parameters
    //

    if (!pszName || (cchMaxLength <= 0))
        return E_INVALIDARG;


    if (!m_bInitialized)
    {
        return OLE_E_BLANK;
    }

    if ((dwSection != GPO_SECTION_ROOT) &&
        (dwSection != GPO_SECTION_USER) &&
        (dwSection != GPO_SECTION_MACHINE))
        return E_INVALIDARG;


    //
    // Build the path
    //

    lstrcpy (szPath, m_szNamespace);

    if (dwSection != GPO_SECTION_ROOT)
    {
        if (dwSection == GPO_SECTION_USER)
        {
            lpEnd = CheckSlash (szPath);
            lstrcpy (lpEnd, USER_SECTION);
        }
        else if (dwSection == GPO_SECTION_MACHINE)
        {
            lpEnd = CheckSlash (szPath);
            lstrcpy (lpEnd, COMPUTER_SECTION);
        }
        else
        {
            return E_INVALIDARG;
        }
    }


    //
    // Save the name
    //

    if ((lstrlen (szPath) + 1) <= cchMaxLength)
    {
        lstrcpy (pszName, szPath);
        return S_OK;
    }

    return E_OUTOFMEMORY;
}

STDMETHODIMP CRSOPComponentData::GetFlags (DWORD * pdwFlags)
{
    if (!pdwFlags)
    {
        return E_INVALIDARG;
    }

    *pdwFlags = m_bDiagnostic ? RSOP_INFO_FLAG_DIAGNOSTIC_MODE : 0;

    return S_OK;
}

STDMETHODIMP CRSOPComponentData::GetEventLogEntryText (LPOLESTR pszEventSource,
                                                       LPOLESTR pszEventLogName,
                                                       LPOLESTR pszEventTime,
                                                       DWORD dwEventID,
                                                       LPOLESTR *ppszText)
{
    return (m_pEvents ? m_pEvents->GetEventLogEntryText(pszEventSource, pszEventLogName, pszEventTime,
                                            dwEventID, ppszText) : E_NOINTERFACE);
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (IComponentData)                 //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRSOPComponentData::Initialize(LPUNKNOWN pUnknown)
{
    HRESULT hr;
    HBITMAP bmp16x16;
    HBITMAP hbmp32x32;
    LPIMAGELIST lpScopeImage;


    //
    // QI for IConsoleNameSpace
    //

    hr = pUnknown->QueryInterface(IID_IConsoleNameSpace, (LPVOID *)&m_pScope);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Initialize: Failed to QI for IConsoleNameSpace.")));
        return hr;
    }


    //
    // QI for IConsole
    //

    hr = pUnknown->QueryInterface(IID_IConsole, (LPVOID *)&m_pConsole);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Initialize: Failed to QI for IConsole.")));
        m_pScope->Release();
        m_pScope = NULL;
        return hr;
    }

    m_pConsole->GetMainWindow (&m_hwndFrame);


    //
    // Query for the scope imagelist interface
    //

    hr = m_pConsole->QueryScopeImageList(&lpScopeImage);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Initialize: Failed to QI for scope imagelist.")));
        m_pScope->Release();
        m_pScope = NULL;
        m_pConsole->Release();
        m_pConsole=NULL;
        return hr;
    }

    // Load the bitmaps from the dll
    bmp16x16=LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_16x16));
    hbmp32x32 = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_32x32));

    // Set the images
    lpScopeImage->ImageListSetStrip(reinterpret_cast<LONG_PTR *>(bmp16x16),
                                    reinterpret_cast<LONG_PTR *>(hbmp32x32),
                                    0, RGB(255, 0, 255));

    lpScopeImage->Release();


    return S_OK;
}

STDMETHODIMP CRSOPComponentData::Destroy(VOID)
{
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    BSTR bstrParam = NULL;
    LPTSTR lpTemp = NULL;
    BSTR bstrTemp = NULL;
    HRESULT hr = S_OK;


    if (m_bInitialized)
    {
        if (m_bViewIsArchivedData)
        {

            //
            // Delete the namespace
            //

            hr = CoCreateInstance(CLSID_WbemLocator,
                                  0,
                                  CLSCTX_INPROC_SERVER,
                                  IID_IWbemLocator,
                                  (LPVOID *) &pLocator);
            if (FAILED(hr))
            {
                goto Cleanup;
            }


            //
            // Delete the namespace we created when loading the data
            //

            bstrParam = SysAllocString(TEXT("\\\\.\\root\\rsop"));

            if (!bstrParam)
            {
                hr = E_FAIL;
                goto Cleanup;
            }

            hr = pLocator->ConnectServer(bstrParam,
                                         NULL,
                                         NULL,
                                         NULL,
                                         0,
                                         NULL,
                                         NULL,
                                         &pNamespace);
            if (FAILED(hr))
            {
                goto Cleanup;
            }


            //
            // Allocate a temp buffer to store the fully qualified path in
            //

            lpTemp = new TCHAR [(lstrlen(m_szArchivedDataGuid) + 30)];

            if (!lpTemp)
            {
                hr = HRESULT_FROM_WIN32(GetLastError());
                goto Cleanup;
            }

            wsprintf (lpTemp, TEXT("__Namespace.name=\"%ws\""), m_szArchivedDataGuid);


            //
            // Delete the namespace
            //

            bstrTemp = SysAllocString (lpTemp);

            if (!bstrTemp)
            {
                hr = E_FAIL;
                goto Cleanup;
            }


            hr = pNamespace->DeleteInstance( bstrTemp, 0, NULL, NULL);


Cleanup:
            if (lpTemp)
            {
                delete [] lpTemp;
            }

            if (bstrTemp)
            {
                SysFreeString(bstrTemp);
            }

            if (bstrParam)
            {
                SysFreeString(bstrParam);
            }

            if (pNamespace)
            {
                pNamespace->Release();
            }

            if (pLocator)
            {
                pLocator->Release();
            }
        }
        else
        {
            hr = DeleteRSOPData (m_szNamespace);
        }

        if (SUCCEEDED(hr))
        {
            m_bInitialized = FALSE;
        }
    }


    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Destroy: Failed to delete namespace with 0x%x"), hr ));
    }

    return hr;
}

STDMETHODIMP CRSOPComponentData::CreateComponent(LPCOMPONENT *ppComponent)
{
    HRESULT hr;
    CRSOPSnapIn *pSnapIn;


    DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::CreateComponent: Entering.")));

    //
    // Initialize
    //

    *ppComponent = NULL;


    //
    // Create the snapin view
    //

    pSnapIn = new CRSOPSnapIn(this);

    if (!pSnapIn)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateComponent: Failed to create CRSOPSnapIn.")));
        return E_OUTOFMEMORY;
    }


    //
    // QI for IComponent
    //

    hr = pSnapIn->QueryInterface(IID_IComponent, (LPVOID *)ppComponent);
    pSnapIn->Release();     // release QI


    return hr;
}

STDMETHODIMP CRSOPComponentData::QueryDataObject(MMC_COOKIE cookie, DATA_OBJECT_TYPES type,
                                                 LPDATAOBJECT* ppDataObject)
{
    HRESULT hr = E_NOINTERFACE;
    CRSOPDataObject *pDataObject;
    LPRSOPDATAOBJECT pRSOPDataObject;


    //
    // Create a new DataObject
    //

    pDataObject = new CRSOPDataObject(this);   // ref == 1

    if (!pDataObject)
        return E_OUTOFMEMORY;


    //
    // QI for the private RSOPDataObject interface so we can set the cookie
    // and type information.
    //

    hr = pDataObject->QueryInterface(IID_IRSOPDataObject, (LPVOID *)&pRSOPDataObject);

    if (FAILED(hr))
    {
        pDataObject->Release();
        return(hr);
    }

    pRSOPDataObject->SetType(type);
    pRSOPDataObject->SetCookie(cookie);
    pRSOPDataObject->Release();


    //
    // QI for a normal IDataObject to return.
    //

    hr = pDataObject->QueryInterface(IID_IDataObject, (LPVOID *)ppDataObject);

    pDataObject->Release();     // release initial ref

    return hr;
}

STDMETHODIMP CRSOPComponentData::Notify(LPDATAOBJECT lpDataObject, MMC_NOTIFY_TYPE event, LPARAM arg, LPARAM param)
{
    HRESULT hr = S_OK;

    switch (event)
    {
    case MMCN_EXPAND:
        if (arg == TRUE)
            hr = EnumerateScopePane(lpDataObject, (HSCOPEITEM)param);
        break;

    case MMCN_PRELOAD:
        if (!m_bRefocusInit)
        {
            SCOPEDATAITEM item;

            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::Notify:  Received MMCN_PRELOAD event.")));
            m_bRefocusInit = TRUE;

            ZeroMemory (&item, sizeof(SCOPEDATAITEM));
            item.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE;
            item.displayname = MMC_CALLBACK;

            if (m_bInitialized)
            {
                if (m_bUserGPCoreError || m_bComputerGPCoreError)
                {
                    item.nImage = 3;
                    item.nOpenImage = 3;
                }
                else if (m_bUserCSEError || m_bComputerCSEError ||
                         m_bUserDeniedAccess || m_bComputerDeniedAccess)
                {
                    item.nImage = 11;
                    item.nOpenImage = 11;
                }
                else
                {
                    item.nImage = 2;
                    item.nOpenImage = 2;
                }
            }
            else
            {
                item.nImage = 3;
                item.nOpenImage = 3;
            }

            item.ID = (HSCOPEITEM) arg;

            m_pScope->SetItem (&item);
        }
        break;

    default:
        break;
    }

    return hr;
}

STDMETHODIMP CRSOPComponentData::GetDisplayInfo(LPSCOPEDATAITEM pItem)
{
    DWORD dwIndex;

    if (pItem == NULL)
        return E_POINTER;

    for (dwIndex = 0; dwIndex < g_dwNameSpaceItems; dwIndex++)
    {
        if (g_RsopNameSpace[dwIndex].dwID == (DWORD) pItem->lParam)
            break;
    }

    if (dwIndex == g_dwNameSpaceItems)
        pItem->displayname = NULL;
    else
    {
        if (((DWORD) pItem->lParam == 0) && m_pDisplayName)
            pItem->displayname = m_pDisplayName;
        else
            pItem->displayname = g_RsopNameSpace[dwIndex].szDisplayName;
    }

    return S_OK;
}

STDMETHODIMP CRSOPComponentData::CompareObjects(LPDATAOBJECT lpDataObjectA, LPDATAOBJECT lpDataObjectB)
{
    HRESULT hr = S_FALSE;
    LPRSOPDATAOBJECT pRSOPDataObjectA, pRSOPDataObjectB;
    MMC_COOKIE cookie1, cookie2;


    if (lpDataObjectA == NULL || lpDataObjectB == NULL)
        return E_POINTER;

    //
    // QI for the private RSOPDataObject interface
    //

    if (FAILED(lpDataObjectA->QueryInterface(IID_IRSOPDataObject,
                                             (LPVOID *)&pRSOPDataObjectA)))
    {
        return S_FALSE;
    }


    if (FAILED(lpDataObjectB->QueryInterface(IID_IRSOPDataObject,
                                             (LPVOID *)&pRSOPDataObjectB)))
    {
        pRSOPDataObjectA->Release();
        return S_FALSE;
    }

    pRSOPDataObjectA->GetCookie(&cookie1);
    pRSOPDataObjectB->GetCookie(&cookie2);

    if (cookie1 == cookie2)
    {
        hr = S_OK;
    }


    pRSOPDataObjectA->Release();
    pRSOPDataObjectB->Release();

    return hr;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (IExtendPropertySheet2)          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRSOPComponentData::CreatePropertyPages(LPPROPERTYSHEETCALLBACK lpProvider,
                                                     LONG_PTR handle, LPDATAOBJECT lpDataObject)

{
    return SetupPropertyPages(RSOP_NOMSC, lpProvider, handle, lpDataObject);
}

STDMETHODIMP CRSOPComponentData::QueryPagesFor(LPDATAOBJECT lpDataObject)
{
    HRESULT hr;

    hr = IsSnapInManager(lpDataObject);

    if (hr != S_OK)
    {
        hr = IsNode(lpDataObject, 0); // check for root
        if (S_OK == hr)
        {
            return hr;
        }
        hr = IsNode(lpDataObject, 1); // check for machine
        if (S_OK == hr)
        {
            return hr;
        }
        hr = IsNode(lpDataObject, 2); // check for user
        if (S_OK == hr)
        {
            return hr;
        }
        hr = E_FAIL;
    }

    return hr;
}

STDMETHODIMP CRSOPComponentData::GetWatermarks(LPDATAOBJECT lpIDataObject,
                                               HBITMAP* lphWatermark,
                                               HBITMAP* lphHeader,
                                               HPALETTE* lphPalette,
                                               BOOL* pbStretch)
{
    *lphPalette = NULL;
    *lphHeader = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_HEADER));
    *lphWatermark = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_WIZARD));;
    *pbStretch = TRUE;

    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (IExtendContextMenu)             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRSOPComponentData::AddMenuItems(LPDATAOBJECT piDataObject,
                                              LPCONTEXTMENUCALLBACK pCallback,
                                              LONG *pInsertionAllowed)
{
    HRESULT hr = S_OK;
    TCHAR szMenuItem[100];
    TCHAR szDescription[250];
    CONTEXTMENUITEM item;


    if (*pInsertionAllowed & CCM_INSERTIONALLOWED_VIEW)
    {
        if (IsNode(piDataObject, 0) == S_OK)
        {
            LoadString (g_hInstance, IDS_ARCHIVEDATA, szMenuItem, 100);
            LoadString (g_hInstance, IDS_ARCHIVEDATADESC, szDescription, 250);

            item.strName = szMenuItem;
            item.strStatusBarText = szDescription;
            item.lCommandID = IDM_ARCHIVEDATA;
            item.lInsertionPointID = CCM_INSERTIONPOINTID_PRIMARY_VIEW;
            item.fFlags = m_bArchiveData ? MFS_CHECKED : 0;
            item.fSpecialFlags = 0;

            hr = pCallback->AddItem(&item);
        }
    }


    return(hr);
}

STDMETHODIMP CRSOPComponentData::Command(LONG lCommandID, LPDATAOBJECT piDataObject)
{
    TCHAR szCaption[100];
    TCHAR szMessage[300];
    INT iRet;

    if (lCommandID == IDM_ARCHIVEDATA)
    {
        m_bArchiveData = !m_bArchiveData;

        if (m_bViewIsArchivedData && !m_bArchiveData)
        {
            LoadString(g_hInstance, IDS_ARCHIVEDATA_CAPTION, szCaption, ARRAYSIZE(szCaption));
            LoadString(g_hInstance, IDS_ARCHIVEDATA_MESSAGE, szMessage, ARRAYSIZE(szMessage));

            m_pConsole->MessageBox (szMessage, szCaption, MB_OK, &iRet);
        }

        SetDirty();
    }

    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (IPersistStreamInit)             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRSOPComponentData::GetClassID(CLSID *pClassID)
{

    if (!pClassID)
    {
        return E_FAIL;
    }

    *pClassID = CLSID_RSOPSnapIn;

    return S_OK;
}

STDMETHODIMP CRSOPComponentData::IsDirty(VOID)
{
    return ThisIsDirty() ? S_OK : S_FALSE;
}

HRESULT CRSOPComponentData::DeleteRSOPData(LPTSTR lpNameSpace)
{
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    IWbemClassObject * pClass = NULL;
    IWbemClassObject * pOutInst = NULL;
    IWbemClassObject * pInClass = NULL;
    IWbemClassObject * pInInst = NULL;
    BSTR bstrParam = NULL;
    BSTR bstrClassPath = NULL;
    BSTR bstrMethodName = NULL;
    VARIANT var;
    TCHAR szBuffer[MAX_PATH];
    LPTSTR szLocalNameSpace = NULL;

    HRESULT hr;
    HRESULT hrSuccess;

    szLocalNameSpace = (LPTSTR)LocalAlloc(LPTR, (2+lstrlen(lpNameSpace))*sizeof(TCHAR));

    if (!szLocalNameSpace) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::DeleteRSOPData: LocalAlloc failed with 0x%x"), hr));
        goto Cleanup;
    }

    if (CompareString (LOCALE_USER_DEFAULT, NORM_STOP_ON_NULL, 
                       TEXT("\\\\"), 2, lpNameSpace, 2) == CSTR_EQUAL) {

        if (CompareString (LOCALE_USER_DEFAULT, NORM_STOP_ON_NULL, 
                           TEXT("\\\\."), 3, lpNameSpace, 3) != CSTR_EQUAL) {
            LPTSTR lpEnd;
            lpEnd = wcschr(lpNameSpace+2, L'\\');

            if (!lpEnd) {
                hr = E_FAIL;
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::DeleteRSOPData: Invalid format for name space")));
                goto Cleanup;
            }
            else {
                lstrcpy(szLocalNameSpace, TEXT("\\\\."));
                lstrcat(szLocalNameSpace, lpEnd);
            }
        }
        else {
            lstrcpy(szLocalNameSpace, lpNameSpace);
        }
    }
    else {
        lstrcpy(szLocalNameSpace, lpNameSpace);
    }

    DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::DeleteRSOPData: Namespace passed to the provider = %s"), szLocalNameSpace));

    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *) &pLocator);
    if (FAILED(hr))
    {
        goto Cleanup;
    }

    if (m_bDiagnostic)
    {
        // set up diagnostic mode
        // build a path to the target: "\\\\computer\\root\\rsop"
        _stprintf(szBuffer, TEXT("\\\\%s\\root\\rsop"), NameWithoutDomain(m_szComputerName));
        bstrParam = SysAllocString(szBuffer);

        if (!bstrParam)
        {
            hr = E_FAIL;
            goto Cleanup;
        }

        hr = pLocator->ConnectServer(bstrParam,
                                     NULL,
                                     NULL,
                                     NULL,
                                     0,
                                     NULL,
                                     NULL,
                                     &pNamespace);
        if (FAILED(hr))
        {
            goto Cleanup;
        }

        bstrClassPath = SysAllocString(TEXT("RsopLoggingModeProvider"));
        hr = pNamespace->GetObject(bstrClassPath,
                                   WBEM_FLAG_RETURN_WBEM_COMPLETE,
                                   NULL,
                                   &pClass,
                                   NULL);
        if (FAILED(hr))
        {
            goto Cleanup;
        }
    }
    else
    {
        // set up planning mode
        // build a path to the DC: "\\\\dc\\root\\rsop"
        _stprintf(szBuffer, TEXT("\\\\%s\\root\\rsop"), m_szDC);
        bstrParam = SysAllocString(szBuffer);

        if (!bstrParam)
        {
            hr = E_FAIL;
            goto Cleanup;
        }

        hr = pLocator->ConnectServer(bstrParam,
                                     NULL,
                                     NULL,
                                     NULL,
                                     0,
                                     NULL,
                                     NULL,
                                     &pNamespace);
        if (FAILED(hr))
        {
            goto Cleanup;
        }

        bstrClassPath = SysAllocString(TEXT("RsopPlanningModeProvider"));
        hr = pNamespace->GetObject(bstrClassPath,
                                   WBEM_FLAG_RETURN_WBEM_COMPLETE,
                                   NULL,
                                   &pClass,
                                   NULL);
        if (FAILED(hr))
        {
            goto Cleanup;
        }
    }

    bstrMethodName = SysAllocString(TEXT("RsopDeleteSession"));

    if (!bstrMethodName)
    {
        hr = E_FAIL;
        goto Cleanup;
    }

    hr = pClass->GetMethod(bstrMethodName,
                           0,
                           &pInClass,
                           NULL);
    if (FAILED(hr))
    {
        goto Cleanup;
    }

    hr = pInClass->SpawnInstance(0, &pInInst);
    if (FAILED(hr))
    {
        goto Cleanup;
    }

    hr = SetParameter(pInInst, TEXT("nameSpace"), szLocalNameSpace);
    if (FAILED(hr))
    {
        goto Cleanup;
    }

    // Set the proper security to prevent the ExecMethod call from failing
    hr = CoSetProxyBlanket(pNamespace,
                           RPC_C_AUTHN_DEFAULT,
                           RPC_C_AUTHZ_DEFAULT,
                           COLE_DEFAULT_PRINCIPAL,
                           RPC_C_AUTHN_LEVEL_CALL,
                           RPC_C_IMP_LEVEL_IMPERSONATE,
                           NULL,
                           0);
    if (FAILED(hr))
    {
        goto Cleanup;
    }
    hr = pNamespace->ExecMethod(bstrClassPath,
                                bstrMethodName,
                                0,
                                NULL,
                                pInInst,
                                &pOutInst,
                                NULL);
    if (FAILED(hr))
    {
        goto Cleanup;
    }

    hr = GetParameter(pOutInst, TEXT("hResult"), hrSuccess);
    if (SUCCEEDED(hr))
    {
        if (FAILED(hrSuccess))
        {
            hr = hrSuccess;
        }
    }

Cleanup:

    if (szLocalNameSpace) {
        LocalFree(szLocalNameSpace);
        szLocalNameSpace = NULL;
    }

    SysFreeString(bstrParam);
    SysFreeString(bstrClassPath);
    SysFreeString(bstrMethodName);
    if (pInInst)
    {
        pInInst->Release();
    }
    if (pOutInst)
    {
        pOutInst->Release();
    }
    if (pInClass)
    {
        pInClass->Release();
    }
    if (pClass)
    {
        pClass->Release();
    }
    if (pNamespace)
    {
        pNamespace->Release();
    }
    if (pLocator)
    {
        pLocator->Release();
    }
    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   GenerateRSOPDataEx
//
//  Synopsis:   Wrapper around GenerateRSOPData.  This version adds retry
//              support.  If the user doesn't have access to half of the data
//              this method will re-issue the query for only the part of the data
//              the user has access to.
//
//---------------------------------------------------------------------------

HRESULT CRSOPComponentData::GenerateRSOPDataEx(HWND hDlg, LPTSTR *lpNameSpace)
{
    HRESULT hr;
    ULONG ulErrorInfo;
    BOOL bSkipCSEs, bLimitData, bUser, bForceCreate;


    bSkipCSEs = bLimitData = bUser =  bForceCreate = FALSE;

    hr = GenerateRSOPData (hDlg, lpNameSpace, bSkipCSEs, bLimitData, bUser, bForceCreate, &ulErrorInfo);

    if (FAILED(hr))
    {
        if (ulErrorInfo == RSOP_USER_ACCESS_DENIED)
        {
            ReportError (hDlg, hr, IDS_EXECFAILED_USER);
            m_bUserDeniedAccess = TRUE;
            FillResultsList (GetDlgItem (hDlg, IDC_LIST1));

            bSkipCSEs = bUser =  bForceCreate = FALSE;
            bLimitData = TRUE;
            hr = GenerateRSOPData (hDlg, lpNameSpace, bSkipCSEs, bLimitData, bUser, bForceCreate, &ulErrorInfo);
        }
        else if (ulErrorInfo == RSOP_COMPUTER_ACCESS_DENIED)
        {
            ReportError (hDlg, hr, IDS_EXECFAILED_COMPUTER);
            m_bComputerDeniedAccess = TRUE;
            FillResultsList (GetDlgItem (hDlg, IDC_LIST1));

            bSkipCSEs =  bForceCreate = FALSE;
            bLimitData = bUser = TRUE;
            hr = GenerateRSOPData (hDlg, lpNameSpace, bSkipCSEs, bLimitData, bUser, bForceCreate, &ulErrorInfo);
        }
        
        if (FAILED(hr)) {
            if ((ulErrorInfo & RSOP_COMPUTER_ACCESS_DENIED) && 
                     (ulErrorInfo & RSOP_USER_ACCESS_DENIED)) {
                // both are denied access
                ReportError (hDlg, hr, IDS_EXECFAILED_BOTH);
            }
            else if (ulErrorInfo & RSOP_TEMPNAMESPACE_EXISTS) {
                TCHAR szConfirm[MAX_PATH], szTitle[MAX_PATH];

                szConfirm[0] = szTitle[0] = TEXT('\0');
                LoadString(g_hInstance, IDS_RSOPDELNAMESPACE, szConfirm, ARRAYSIZE(szConfirm));
                LoadString(g_hInstance, IDS_RSOPDELNS_TITLE, szTitle, ARRAYSIZE(szTitle));

                if (MessageBox(hDlg, szConfirm, szTitle, MB_OKCANCEL | MB_ICONQUESTION | MB_DEFBUTTON2) == IDOK) {
                    // use the same options as before
                    bForceCreate = TRUE;
                    hr = GenerateRSOPData (hDlg, lpNameSpace, bSkipCSEs, bLimitData, bUser, bForceCreate,  &ulErrorInfo);
                }
            }
        }

        if (hr == HRESULT_FROM_WIN32(WAIT_TIMEOUT)) {
            ReportError (hDlg, hr, IDS_EXECFAILED_TIMEDOUT);
        }
        else
        {
            if (FAILED(hr)) {
                ReportError (hDlg, hr, IDS_EXECFAILED);
            }
        }
    }

    return hr;
}

//+--------------------------------------------------------------------------
//
//  Function:   GenerateRSOPData
//
//  Synopsis:   Calls the rsop provider based on the settings made in the
//              initialization wizard
//
//  Arguments:
//
//  Returns:
//
//  Modifies:
//
//  History:    10-04-1999   stevebl   Created
//
//  Notes:
//
//---------------------------------------------------------------------------

HRESULT CRSOPComponentData::GenerateRSOPData(HWND hDlg, LPTSTR *lpNameSpace,
                                             BOOL bSkipCSEs, BOOL bLimitData,
                                             BOOL bUser, BOOL bForceCreate, 
                                             ULONG *pulErrorInfo)
{
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    IWbemClassObject * pClass = NULL;
    IWbemClassObject * pOutInst = NULL;
    IWbemClassObject * pInClass = NULL;
    IWbemClassObject * pInInst = NULL;
    IUnsecuredApartment *pSpawner = NULL;
    IUnknown *pSubstitute = NULL;
    IWbemObjectSink *pSubstituteSink = NULL;
    BSTR bstrParam = NULL;
    BSTR bstrClassPath = NULL;
    BSTR bstrMethodName = NULL;
    VARIANT var;
    TCHAR szBuffer[MAX_PATH];
    HRESULT hr;
    HRESULT hrSuccess;
    CCreateSessionSink *pCSS = NULL;
    MSG msg;
    UINT uiFlags = 0;
    BOOL bSetData;


    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *) &pLocator);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: CoCreateInstance failed with 0x%x"), hr));
        goto Cleanup;
    }

    if (m_bDiagnostic)
    {
        // set up diagnostic mode
        // build a path to the target: "\\\\computer\\root\\rsop"
        _stprintf(szBuffer, TEXT("\\\\%s\\root\\rsop"), NameWithoutDomain(m_szComputerName));
        bstrParam = SysAllocString(szBuffer);
        hr = pLocator->ConnectServer(bstrParam,
                                     NULL,
                                     NULL,
                                     NULL,
                                     0,
                                     NULL,
                                     NULL,
                                     &pNamespace);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: ConnectServer failed with 0x%x"), hr));
            ReportError (hDlg, hr, IDS_CONNECTSERVERFAILED, m_szComputerName);
            goto Cleanup;
        }

        bstrClassPath = SysAllocString(TEXT("RsopLoggingModeProvider"));
        hr = pNamespace->GetObject(bstrClassPath,
                                   WBEM_FLAG_RETURN_WBEM_COMPLETE,
                                   NULL,
                                   &pClass,
                                   NULL);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: GetObject failed with 0x%x"), hr));
            goto Cleanup;
        }

        bstrMethodName = SysAllocString(TEXT("RsopCreateSession"));
        hr = pClass->GetMethod(bstrMethodName,
                               0,
                               &pInClass,
                               NULL);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: GetMethod failed with 0x%x"), hr));
            goto Cleanup;
        }

        hr = pInClass->SpawnInstance(0, &pInInst);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SpawnInstance failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_bNoUserData || m_bUserDeniedAccess)
        {
            uiFlags |= FLAG_NO_USER;
        }

        if (m_bNoComputerData || m_bComputerDeniedAccess)
        {
            uiFlags |= FLAG_NO_COMPUTER;
        }

        if (bForceCreate) {
            uiFlags |= FLAG_FORCE_CREATENAMESPACE;
        }

        hr = SetParameter(pInInst, TEXT("flags"), uiFlags);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (!lstrcmpi(m_szUserName, TEXT(".")))
        {
            hr = SetParameterToNull(pInInst, TEXT("userSid"));
        }
        else
        {
            hr = SetParameter(pInInst, TEXT("userSid"), m_szUserName);
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }
    }
    else if ( IsPlanningModeAllowed() )
    {
        // set up planning mode
        // build a path to the DC: "\\\\dc\\root\\rsop"
        _stprintf(szBuffer, TEXT("\\\\%s\\root\\rsop"), m_szDC);
        bstrParam = SysAllocString(szBuffer);
        hr = pLocator->ConnectServer(bstrParam,
                                     NULL,
                                     NULL,
                                     NULL,
                                     0,
                                     NULL,
                                     NULL,
                                     &pNamespace);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: ConnectServer failed with 0x%x"), hr));
            ReportError (hDlg, hr, IDS_CONNECTSERVERFAILED, m_szDC);
            goto Cleanup;
        }

        bstrClassPath = SysAllocString(TEXT("RsopPlanningModeProvider"));
        hr = pNamespace->GetObject(bstrClassPath,
                                   WBEM_FLAG_RETURN_WBEM_COMPLETE,
                                   NULL,
                                   &pClass,
                                   NULL);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: GetObject failed with 0x%x"), hr));
            goto Cleanup;
        }

        bstrMethodName = SysAllocString(TEXT("RsopCreateSession"));
        hr = pClass->GetMethod(bstrMethodName,
                               0,
                               &pInClass,
                               NULL);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: GetMethod failed with 0x%x"), hr));
            goto Cleanup;
        }

        hr = pInClass->SpawnInstance(0, &pInInst);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SpawnInstance failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_bSlowLink)
        {
            uiFlags |= FLAG_ASSUME_SLOW_LINK;
        }

        if (!bSkipCSEs || bUser)
        {
            switch (m_loopbackMode)
            {
            case LoopbackReplace:
                uiFlags |= FLAG_LOOPBACK_REPLACE;
                break;
            case LoopbackMerge:
                uiFlags |= FLAG_LOOPBACK_MERGE;
                break;
            default:
                break;
            }
        }

        if (bSkipCSEs)
        {
            uiFlags |= (FLAG_NO_GPO_FILTER | FLAG_NO_CSE_INVOKE);
        }
        else {
            if (m_bSkipComputerWQLFilter) {
                uiFlags |= FLAG_ASSUME_COMP_WQLFILTER_TRUE;
            }

            if (m_bSkipUserWQLFilter) {
                uiFlags |= FLAG_ASSUME_USER_WQLFILTER_TRUE;
            }
        }

        hr = SetParameter(pInInst, TEXT("flags"), uiFlags);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        //
        // If this method is being called to generate temporary rsop data for the
        // wmi filter UI, we only want to initialize half of the args (either user
        // or computer).  Decide if we want to set the computer information here.
        //

        bSetData = TRUE;

        if (bLimitData)
        {
            if (bUser && (LoopbackNone == m_loopbackMode))
            {
                bSetData = FALSE;
            }
        }

        if (m_szComputerName && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("computerName"), m_szComputerName);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("computerName"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_szComputerSOM && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("computerSOM"), m_szComputerSOM);
        }
        else
        {
            hr = SetParameterToNull (pInInst, TEXT("computerSOM"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_saComputerSecurityGroups && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("computerSecurityGroups"), m_saComputerSecurityGroups);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("computerSecurityGroups"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_saComputerWQLFilters && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("computerGPOFilters"), m_saComputerWQLFilters);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("computerGPOFilters"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }


        //
        // If this method is being called to generate temporary rsop data for the
        // wmi filter UI, we only want to initialize half of the args (either user
        // or computer).  Decide if we want to set the user information here.
        //

        bSetData = TRUE;

        if (bLimitData)
        {
            if (!bUser)
            {
                bSetData = FALSE;
            }
        }

        if (m_szUserName && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("userName"), m_szUserName);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("userName"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_szUserSOM && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("userSOM"), m_szUserSOM);
        }
        else
        {
            hr = SetParameterToNull (pInInst, TEXT("userSOM"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_saUserSecurityGroups && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("userSecurityGroups"), m_saUserSecurityGroups);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("userSecurityGroups"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_saUserWQLFilters && bSetData)
        {
            hr = SetParameter(pInInst, TEXT("userGPOFilters"), m_saUserWQLFilters);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("userGPOFilters"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }

        if (m_szSite)
        {
            hr = SetParameter(pInInst, TEXT("site"), m_szSite);
        }
        else
        {
            hr = SetParameterToNull(pInInst, TEXT("site"));
        }

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed with 0x%x"), hr));
            goto Cleanup;
        }
    }
    else
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: SetParameter failed because planning mode view is not implemented on non-server SKUs")));
        hr = E_NOTIMPL;
        goto Cleanup;
    }

    hr = CoCreateInstance(CLSID_UnsecuredApartment, NULL, CLSCTX_ALL,
                          IID_IUnsecuredApartment, (void **)&pSpawner);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: CoCreateInstance for unsecure apartment failed with 0x%x"), hr));
        goto Cleanup;
    }


    pCSS = new CCreateSessionSink (hDlg ? GetDlgItem(hDlg, IDC_PROGRESS1) : NULL, GetCurrentThreadId());

    if (!pCSS)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: Failed to create createsessionsink")));
        goto Cleanup;
    }


    hr = pSpawner->CreateObjectStub(pCSS, &pSubstitute);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: CreateObjectStub failed with 0x%x"), hr));
        goto Cleanup;
    }

    hr = pSubstitute->QueryInterface(IID_IWbemObjectSink, (LPVOID *)&pSubstituteSink);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: QI failed with 0x%x"), hr));
        goto Cleanup;
    }


    // Set the proper security to prevent the ExecMethod call from failing
    hr = CoSetProxyBlanket(pNamespace,
                           RPC_C_AUTHN_DEFAULT,
                           RPC_C_AUTHZ_DEFAULT,
                           COLE_DEFAULT_PRINCIPAL,
                           RPC_C_AUTHN_LEVEL_CALL,
                           RPC_C_IMP_LEVEL_IMPERSONATE,
                           NULL,
                           0);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: CoSetProxyBlanket failed with 0x%x"), hr));
        goto Cleanup;
    }

    pCSS->SendQuitMessage (TRUE);

    hr = pNamespace->ExecMethodAsync(bstrClassPath,
                                     bstrMethodName,
                                     WBEM_FLAG_SEND_STATUS,
                                     NULL,
                                     pInInst,
                                     pSubstituteSink);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GenerateRSOPData: ExecMethodAsync failed with 0x%x"), hr));
        pCSS->SendQuitMessage (FALSE);
        goto Cleanup;
    }

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }


    pCSS->SendQuitMessage (FALSE);
    pCSS->GetResult (&hrSuccess);
    pCSS->GetErrorInfo (pulErrorInfo);

    if (SUCCEEDED(hrSuccess))
    {
        LPTSTR lpComputerName;
        BSTR bstrNamespace = NULL;

        pCSS->GetNamespace (&bstrNamespace);

        if (bstrNamespace)
        {
            if (m_bDiagnostic)
            {
                lpComputerName = NameWithoutDomain(m_szComputerName);
            }
            else
            {
                lpComputerName = m_szDC;
            }

            *lpNameSpace = new TCHAR[_tcslen(bstrNamespace) + _tcslen(lpComputerName) + 1];

            if (*lpNameSpace)
            {
                lstrcpy (*lpNameSpace, TEXT("\\\\"));
                lstrcat (*lpNameSpace, lpComputerName);
                lstrcat (*lpNameSpace, (bstrNamespace+3));

                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::GenerateRSOPData: Complete namespace is: %s"), *lpNameSpace));
            }
            else
            {
                hr = E_OUTOFMEMORY;
            }
        }

    }
    else
    {
        hr = hrSuccess;
        if (hDlg)
        {
            SendMessage (GetDlgItem(hDlg, IDC_PROGRESS1), PBM_SETPOS, 0, 0);
        }
        goto Cleanup;
    }

Cleanup:
    SysFreeString(bstrParam);
    SysFreeString(bstrClassPath);
    SysFreeString(bstrMethodName);

    if (pInInst)
    {
        pInInst->Release();
    }

    if (pOutInst)
    {
        pOutInst->Release();
    }

    if (pInClass)
    {
        pInClass->Release();
    }

    if (pClass)
    {
        pClass->Release();
    }

    if (pNamespace)
    {
        pNamespace->Release();
    }

    if (pLocator)
    {
        pLocator->Release();
    }

    if (pSubstitute)
    {
        pSubstitute->Release();
    }

    if (pSubstituteSink)
    {
        pSubstituteSink->Release();
    }

    if (pSpawner)
    {
        pSpawner->Release();
    }

    if (pCSS)
    {
        pCSS->Release();
    }

    return hr;
}


HRESULT CRSOPComponentData::SetupPropertyPages(DWORD dwFlags, LPPROPERTYSHEETCALLBACK lpProvider,
                                               LONG_PTR handle, LPDATAOBJECT lpDataObject)
{
    HRESULT hr = E_FAIL;
    PROPSHEETPAGE psp;
    HPROPSHEETPAGE hPage;
    TCHAR szTitle[150];
    TCHAR szSubTitle[300];
    BOOL  bShowNow;
    
    HPROPSHEETPAGE hShowNowPages[20];
    DWORD          dwCount=0, dwDiagStartPage = 0, dwPlanStartPage = 0, dwDiagFinishPage = 0, dwPlanFinishPage = 0;



    hr = this->SetupFonts();
    if (FAILED(hr))
        return hr;


    bShowNow = (!(dwFlags & RSOP_NOMSC));

    if (bShowNow || (IsSnapInManager(lpDataObject) == S_OK))
    {
        //
        // Create the wizard property sheets
        //

        //
        // Welcome sheet and the mode are only applicable in no override mode
        //

        if (!bShowNow) {
//            LoadString (g_hInstance, IDS_TITLE_WELCOME, szTitle, ARRAYSIZE(szTitle));
            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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                          GetLastError()));
                return E_FAIL;
            }


            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }

            LoadString (g_hInstance, IDS_TITLE_CHOOSEMODE, szTitle, ARRAYSIZE(szTitle));
            LoadString (g_hInstance, IDS_SUBTITLE_CHOOSEMODE, szSubTitle, ARRAYSIZE(szSubTitle));
            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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                          GetLastError()));
                return E_FAIL;
            }

            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }

        LoadString (g_hInstance, IDS_TITLE_GETCOMP, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_GETCOMP, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwDiagStartPage = dwCount;
            dwCount++;
        }

        LoadString (g_hInstance, IDS_TITLE_GETUSER, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_GETUSER, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }



        LoadString (g_hInstance, IDS_TITLE_GETTARGET, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_GETTARGET, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwPlanStartPage = dwCount;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_GETDC, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_GETDC, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_ALTDIRS, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_ALTDIRS, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }



        LoadString (g_hInstance, IDS_TITLE_USERSECGRPS, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_USERSECGRPS, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_COMPSECGRPS, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_COMPSECGRPS, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_WQLUSER, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_WQL, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_WQLCOMP, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_WQL, szSubTitle, ARRAYSIZE(szSubTitle));
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }

        LoadString (g_hInstance, IDS_TITLE_FINISHED, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_FINISHED, szSubTitle, ARRAYSIZE(szSubTitle));
        psp.dwSize = sizeof(PROPSHEETPAGE);
        psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
        psp.hInstance = g_hInstance;
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwDiagFinishPage = dwCount;
            dwCount++;
        }


        LoadString (g_hInstance, IDS_TITLE_FINISHED, szTitle, ARRAYSIZE(szTitle));
        LoadString (g_hInstance, IDS_SUBTITLE_FINISHED, szSubTitle, ARRAYSIZE(szSubTitle));
        psp.dwSize = sizeof(PROPSHEETPAGE);
        psp.dwFlags = PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
        psp.hInstance = g_hInstance;
        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwPlanFinishPage = dwCount;
            dwCount++;
        }

        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("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                      GetLastError()));
            return E_FAIL;
        }

        if (!bShowNow) {
            hr = lpProvider->AddPage(hPage);

            if (FAILED(hr))
            {
                return hr;
            }
        }
        else {
            hShowNowPages[dwCount] = hPage;
            dwCount++;
        }


        if (bShowNow) {
            INT_PTR         iRet;
            PROPSHEETHEADER psph;

            psph.dwSize = sizeof(PROPSHEETHEADER);

            psph.dwFlags = PSH_WIZARD97 | PSH_HEADER | PSH_WATERMARK;
            /*PSH_NOCONTEXTHELP | PSH_NOAPPLYNOW | PSH_WIZARD | PSH_WIZARD97 |
                           PSH_STRETCHWATERMARK | PSH_HEADER |  PSH_USEHBMHEADER |*/

            psph.hwndParent = NULL;
            psph.hInstance = g_hInstance;
            psph.nPages = dwCount;

//            psph.hbmHeader = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_HEADER));
            psph.pszbmHeader = MAKEINTRESOURCE(IDB_HEADER);
            psph.pszbmWatermark = MAKEINTRESOURCE(IDB_WIZARD);
            //psph.hbmWatermark = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_WIZARD));

/*
            if (!psph.hbmHeader) {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreatePropertyPages: couldn't load bitmap. Error %d."), GetLastError()));
            }
            else {
                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::CreatePropertyPages: loaded bitmap")));
            }
*/

            if (dwFlags & RSOPMSC_OVERRIDE) {   
                psph.nStartPage = m_bDiagnostic ? dwDiagStartPage : dwPlanStartPage;
                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::CreatePropertyPages: Showing prop sheet in override mode.")));
            }
            else {
                psph.nStartPage = m_bDiagnostic ? dwDiagFinishPage : dwPlanFinishPage;
                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::CreatePropertyPages: Showing prop sheet in no override mode.")));
            }

            psph.phpage  = hShowNowPages;


            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::CreatePropertyPages: Showing prop sheet.")));
            iRet = PropertySheet(&psph);

            if (iRet == -1) {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreatePropertyPages: PropertySheet failed with error %d."),
                          GetLastError()));
            }

            // user cancelled in the wizard
            if (iRet != IDOK) {
                return S_FALSE;
            }
            else {
                return S_OK;
            }
        }
    }
    else
    {
        BOOL fRoot, fMachine, fUser;
        hr = IsNode(lpDataObject, 0); // check for root node
        fRoot = (S_OK == hr);
        hr = IsNode(lpDataObject, 1); // check for machine node
        fMachine = (S_OK == hr);
        hr = IsNode(lpDataObject, 2); // check for user
        fUser = (S_OK == hr);
        hr = E_FAIL;
        if (fMachine || fUser)
        {
            //
            // Create the GPO property sheet
            //

            psp.dwSize = sizeof(PROPSHEETPAGE);
            psp.dwFlags = 0;
            psp.hInstance = g_hInstance;
            psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_GPOLIST);
            psp.pfnDlgProc = fMachine ? RSOPGPOListMachineProc : RSOPGPOListUserProc;
            psp.lParam = (LPARAM) this;

            hPage = CreatePropertySheetPage(&psp);

            if (!hPage)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                          GetLastError()));
                return E_FAIL;
            }

            hr = lpProvider->AddPage(hPage);


            //
            // Create the Error information property sheet
            //

            psp.dwSize = sizeof(PROPSHEETPAGE);
            psp.dwFlags = 0;
            psp.hInstance = g_hInstance;
            psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_ERRORS);
            psp.pfnDlgProc = fMachine ? RSOPErrorsMachineProc : RSOPErrorsUserProc;
            psp.lParam = (LPARAM) this;

            hPage = CreatePropertySheetPage(&psp);

            if (!hPage)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                          GetLastError()));
                return E_FAIL;
            }

            hr = lpProvider->AddPage(hPage);

        }

        if (fRoot)
        {
            //
            // Create the GPO property sheet
            //
    
            psp.dwSize = sizeof(PROPSHEETPAGE);
            psp.dwFlags = 0;
            psp.hInstance = g_hInstance;
            psp.pszTemplate = MAKEINTRESOURCE(IDD_RSOP_QUERY);
            psp.pfnDlgProc = QueryDlgProc;
            psp.lParam = (LPARAM) this;
    
            hPage = CreatePropertySheetPage(&psp);
    
            if (!hPage)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreatePropertyPages: Failed to create property sheet page with %d."),
                          GetLastError()));
                return E_FAIL;
            }
    
            hr = lpProvider->AddPage(hPage);
        }
    }
    
    return S_OK;
}

HRESULT CRSOPComponentData::InitializeRSOPFromMSC(DWORD dwFlags)
{
    HRESULT hr;
    hr = SetupPropertyPages(dwFlags, NULL, NULL, NULL);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOP: SetupPropertyPages failed with 0x%x"), hr));
    }
  
    if (hr == S_FALSE) {
        DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::InitializeRSOP: User cancelled in the init wizard")));
    }

    return hr;
}

HRESULT CRSOPComponentData::InitializeRSOP(HWND hDlg)
{
    HRESULT hr;

    hr = GenerateRSOPDataEx (hDlg, &m_szNamespace);

    if (SUCCEEDED(hr))
    {
        m_bInitialized = TRUE;

        BuildGPOLists();
        BuildCSELists();

        if (m_pEvents)
        {
            m_pEvents->DumpDebugInfo();
        }

        if (hDlg)
        {
            SetDirty();
        }

        BuildDisplayName();
    }
    else
    {
        m_bInitialized = FALSE;
    }

    return hr;
}

STDMETHODIMP CRSOPComponentData::BuildDisplayName (void)
{
    TCHAR szArchiveData[100];
    TCHAR szBuffer[MAX_PATH];
    TCHAR szComputerName[100];
    LPTSTR lpUserName, lpComputerName, lpEnd;
    LPTSTR lpUserOU = NULL, lpComputerOU = NULL;
    DWORD dwSize;
    int n;


    //
    // Make the display name (needs to handle empty names)
    //

    if (m_bViewIsArchivedData)
    {
        LoadString(g_hInstance, IDS_ARCHIVEDATATAG, szArchiveData, ARRAYSIZE(szArchiveData));
    }
    else
    {
        szArchiveData[0] = TEXT('\0');
    }


    if (m_szUserDisplayName && !m_bNoUserData)
    {
        lpUserName = NameWithoutDomain(m_szUserDisplayName);
    }
    else if (m_szUserName && !m_bNoUserData)
    {
        lpUserName = NameWithoutDomain(m_szUserName);
    }
    else if (m_szUserSOM && !m_bNoUserData)
    {
        lpUserOU = GetContainerFromLDAPPath (m_szUserSOM);
        lpUserName = lpUserOU;
    }
    else
    {
        lpUserName =  NULL;
    }

    if (m_szComputerName && !m_bNoComputerData)
    {
        if (!lstrcmpi(m_szComputerName, TEXT(".")))
        {
            szComputerName[0] = TEXT('\0');
            dwSize = ARRAYSIZE(szComputerName);
            GetComputerNameEx (ComputerNameNetBIOS, szComputerName, &dwSize);
            lpComputerName = szComputerName;
        }
        else
        {
            lstrcpyn (szComputerName, NameWithoutDomain(m_szComputerName),
                      ARRAYSIZE(szComputerName));

            lpComputerName = szComputerName;

            lpEnd = lpComputerName + lstrlen(lpComputerName) - 1;

            if (*lpEnd == TEXT('$'))
            {
                *lpEnd =  TEXT('\0');
            }

        }
    }
    else if (m_szComputerSOM && !m_bNoComputerData)
    {
        lpComputerOU = GetContainerFromLDAPPath (m_szComputerSOM);
        lpComputerName = lpComputerOU;
    }
    else
    {
        lpComputerName =  NULL;
    }


    if (lpUserName && lpComputerName)
    {
        LoadString(g_hInstance, IDS_RSOP_DISPLAYNAME1, szBuffer, ARRAYSIZE(szBuffer));

        n = wcslen(szBuffer) + wcslen (szArchiveData) +
            wcslen(lpUserName) + wcslen(lpComputerName) + 1;

        m_pDisplayName = new WCHAR[n];

        if (m_pDisplayName)
        {
            wsprintf(m_pDisplayName, szBuffer, lpUserName, lpComputerName);
        }
    }
    else if (lpUserName && !lpComputerName)
    {
        LoadString(g_hInstance, IDS_RSOP_DISPLAYNAME2, szBuffer, ARRAYSIZE(szBuffer));

        n = wcslen(szBuffer) + wcslen (szArchiveData) +
            wcslen(lpUserName) + 1;

        m_pDisplayName = new WCHAR[n];

        if (m_pDisplayName)
        {
            wsprintf(m_pDisplayName, szBuffer, lpUserName);
        }
    }
    else
    {
        LoadString(g_hInstance, IDS_RSOP_DISPLAYNAME2, szBuffer, ARRAYSIZE(szBuffer));

        n = wcslen(szBuffer) + wcslen (szArchiveData) +
            (lpComputerName ? wcslen(lpComputerName) : 0) + 1;

        m_pDisplayName = new WCHAR[n];

        if (m_pDisplayName)
        {
            wsprintf(m_pDisplayName, szBuffer, (lpComputerName ? lpComputerName : L""));
        }
    }


    if (m_pDisplayName && m_bViewIsArchivedData)
    {
        lstrcat (m_pDisplayName, szArchiveData);
    }

    if (lpUserOU)
    {
        delete [] lpUserOU;
    }

    if (lpComputerOU)
    {
        delete [] lpComputerOU;
    }


    return S_OK;
}


STDMETHODIMP CRSOPComponentData::CopyMSCToFile (IStream *pStm, LPTSTR *lpMofFileName)
{
    HRESULT hr;
    LPTSTR lpFileName;
    ULARGE_INTEGER FileSize, SubtractAmount;
    ULONG nBytesRead;
    LPBYTE lpData;
    DWORD dwError, dwReadAmount, dwRead, dwBytesWritten;
    HANDLE hFile;


    //
    // Get the filename to work with
    //

    lpFileName = CreateTempFile();

    if (!lpFileName)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Failed to create temp filename with %d"), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }


    //
    // Read in the data length
    //

    hr = pStm->Read(&FileSize, sizeof(FileSize), &nBytesRead);

    if ((hr != S_OK) || (nBytesRead != sizeof(FileSize)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Failed to read data size with 0x%x."), hr));
        return E_FAIL;
    }


    //
    // Allocate a buffer to use for the transfer
    //

    lpData = (LPBYTE) LocalAlloc (LPTR, 4096);

    if (!lpData)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Failed to allocate memory with %d."), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }


    //
    // Open the temp file
    //

    hFile = CreateFile (lpFileName, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
                        FILE_ATTRIBUTE_NORMAL, NULL);

    if (hFile == INVALID_HANDLE_VALUE)
    {
        dwError = GetLastError();
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: CreateFile for %s failed with %d"), lpFileName, dwError));
        LocalFree (lpData);
        return HRESULT_FROM_WIN32(dwError);
    }


    while (FileSize.QuadPart)
    {

        //
        // Determine how much to read
        //

        dwReadAmount = (FileSize.QuadPart > 4096) ? 4096 : FileSize.LowPart;


        //
        // Read from the msc file
        //

        hr = pStm->Read(lpData, dwReadAmount, &nBytesRead);

        if ((hr != S_OK) || (nBytesRead != dwReadAmount))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Read failed with 0x%x"), hr));
            LocalFree (lpData);
            CloseHandle (hFile);
            return hr;
        }


        //
        // Write to the temp file
        //

        if (!WriteFile(hFile, lpData, dwReadAmount, &dwBytesWritten, NULL))
        {
            dwError = GetLastError();
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Failed to write data with %d."), dwError));
            LocalFree (lpData);
            CloseHandle (hFile);
            return HRESULT_FROM_WIN32(dwError);
        }

        if (dwBytesWritten != dwReadAmount)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyMSCToFile: Failed to write the correct amount of data.")));
            LocalFree (lpData);
            CloseHandle (hFile);
            return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
        }

        SubtractAmount.LowPart = dwReadAmount;
        SubtractAmount.HighPart = 0;

        FileSize.QuadPart = FileSize.QuadPart - SubtractAmount.QuadPart;
    }


    CloseHandle (hFile);
    LocalFree (lpData);

    *lpMofFileName = lpFileName;

    return S_OK;
}

STDMETHODIMP CRSOPComponentData::CreateNameSpace (LPTSTR lpNameSpace, LPTSTR lpParentNameSpace)
{
    IWbemLocator *pIWbemLocator;
    IWbemServices *pIWbemServices;
    IWbemClassObject *pIWbemClassObject = NULL, *pObject = NULL;
    VARIANT var;
    BSTR bstrName, bstrNameProp;
    HRESULT hr;


    //
    // Create a locater instance
    //

    hr = CoCreateInstance(CLSID_WbemLocator, NULL, CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator, (LPVOID *) &pIWbemLocator);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: CoCreateInstance failed with 0x%x"), hr));
        return hr;
    }


    //
    // Connect to the server
    //

    hr = pIWbemLocator->ConnectServer(lpParentNameSpace, NULL, NULL, 0, 0, NULL, NULL, &pIWbemServices);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: ConnectServer to %s failed with 0x%x"), lpNameSpace, hr));
        pIWbemLocator->Release();
        return hr;
    }


    //
    // Get the namespace class
    //

    bstrName = SysAllocString (TEXT("__Namespace"));

    if (!bstrName)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: SysAllocString failed with %d"), GetLastError()));
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }

    hr = pIWbemServices->GetObject( bstrName, 0, NULL, &pIWbemClassObject, NULL);

    SysFreeString (bstrName);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: GetObject failed with 0x%x"), hr));
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }


    //
    // Spawn Instance
    //

    hr = pIWbemClassObject->SpawnInstance(0, &pObject);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: SpawnInstance failed with 0x%x"), hr));
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }


    //
    // Convert new namespace to a bstr
    //

    bstrName = SysAllocString (lpNameSpace);

    if (!bstrName)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: SysAllocString failed with %d"), GetLastError()));
        pObject->Release();
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }


    //
    // Set the display name
    //

    var.vt = VT_BSTR;
    var.bstrVal = bstrName;

    bstrNameProp = SysAllocString (TEXT("Name"));

    if (!bstrNameProp)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: SysAllocString failed with %d"), GetLastError()));
        pObject->Release();
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }


    hr = pObject->Put( bstrNameProp, 0, &var, 0 );

    SysFreeString (bstrNameProp);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: Put failed with 0x%x"), hr));
        SysFreeString (bstrName);
        pObject->Release();
        pIWbemServices->Release();
        pIWbemLocator->Release();
        return hr;
    }


    //
    // Commit the instance
    //

    hr = pIWbemServices->PutInstance( pObject, WBEM_FLAG_CREATE_OR_UPDATE, NULL, NULL );

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CreateNameSpace: PutInstance failed with 0x%x"), hr));
    }

    SysFreeString (bstrName);
    pObject->Release();
    pIWbemServices->Release();
    pIWbemLocator->Release();

    return hr;
}

STDMETHODIMP CRSOPComponentData::InitializeRSOPFromArchivedData(IStream *pStm)
{
    HRESULT hr;
    TCHAR szNameSpace[100];
    GUID guid;
    LPTSTR lpEnd, lpFileName, lpTemp;


    //
    // Create a guid to work with
    //

    hr = CoCreateGuid( &guid );

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CoCreateGuid failed with 0x%x"), hr));
        return hr;
    }

    wsprintf( m_szArchivedDataGuid,
              L"NS%08lX_%04X_%04X_%02X%02X_%02X%02X%02X%02X%02X%02X",
              guid.Data1,
              guid.Data2,
              guid.Data3,
              guid.Data4[0], guid.Data4[1],
              guid.Data4[2], guid.Data4[3],
              guid.Data4[4], guid.Data4[5],
              guid.Data4[6], guid.Data4[7] );

    lstrcpy (szNameSpace, TEXT("\\\\.\\root\\rsop"));


    //
    // Build the parent namespace
    //

    hr = CreateNameSpace (m_szArchivedDataGuid, szNameSpace);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CreateNameSpace failed with 0x%x"), hr));
        return hr;
    }

    lpEnd = CheckSlash (szNameSpace);
    lstrcpy (lpEnd, m_szArchivedDataGuid);


    //
    // Build the user subnamespace
    //

    hr = CreateNameSpace (TEXT("User"), szNameSpace);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CreateNameSpace failed with 0x%x"), hr));
        return hr;
    }


    //
    // Build the computer subnamespace
    //

    hr = CreateNameSpace (TEXT("Computer"), szNameSpace);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CreateNameSpace failed with 0x%x"), hr));
        return hr;
    }


    //
    // Save the namespace for future use
    //

    m_szNamespace = new TCHAR[(lstrlen(szNameSpace) + 1)];

    if (!m_szNamespace) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: Failed to allocate memory with %d"), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }

    lstrcpy (m_szNamespace, szNameSpace);

    DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: Namespace name is: %s"), m_szNamespace));



    //
    // Make a copy of the namespace that we can manipulate (to load the data with)
    //

    lpTemp = new TCHAR[(lstrlen(szNameSpace) + 10)];

    if (!lpTemp) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: Failed to allocate memory with %d"), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }

    lstrcpy (lpTemp, m_szNamespace);
    lpEnd = CheckSlash (lpTemp);
    lstrcpy (lpEnd, TEXT("Computer"));


    //
    // Extract the computer data to a temp file
    //

    hr = CopyMSCToFile (pStm, &lpFileName);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CopyMSCToFile failed with 0x%x"), hr));
        return hr;
    }


    //
    // Use the mof compiler to pull the data from the file and put it in the
    // new namespace
    //

    hr = ImportRSoPData (lpTemp, lpFileName);

    DeleteFile (lpFileName);
    delete [] lpFileName;

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: ImportRSoPData failed with 0x%x"), hr));
        return hr;
    }


    //
    // Now extract the user data to a temp file
    //

    lstrcpy (lpEnd, TEXT("User"));


    hr = CopyMSCToFile (pStm, &lpFileName);

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: CopyMSCToFile failed with 0x%x"), hr));
        return hr;
    }


    //
    // Use the mof compiler to pull the data from the file and put it in the
    // new namespace
    //

    hr = ImportRSoPData (lpTemp, lpFileName);

    DeleteFile (lpFileName);
    delete [] lpFileName;

    if (FAILED(hr)) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: ImportRSoPData failed with 0x%x"), hr));
        return hr;
    }

    delete [] lpTemp;


    //
    // Pull the event log information and initialize the database
    //

    hr = m_pEvents->LoadEntriesFromStream(pStm);

    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeRSOPFromArchivedData: LoadEntriesFromStream failed with 0x%x."), hr));
        return hr;
    }


    //
    // Build the common data structures used by various property sheets
    //

    BuildGPOLists();
    BuildCSELists();

    if (m_pEvents)
    {
        m_pEvents->DumpDebugInfo();
    }


    //
    // Build the display name
    //

    BuildDisplayName();

    m_bInitialized = TRUE;

    return S_OK;
}


//************************************************************************
//  ParseCommandLine
//
//  Purpose:    Parse the command line to return the value associated with options
//
//  Parameters:
//          szCommandLine   - Part remaining in the unparsed command lines
//          szArgPrefix     - Argument prefix
//          szArgVal        - Argument value. expected in unescaped quotes
//          pbFoundArg      - Whether the argument was found or not
// 
// 
//  Return
//          The remaining cmd line
//
//************************************************************************

LPTSTR ParseCommandLine(LPTSTR szCommandLine, LPTSTR szArgPrefix, LPTSTR *szArgVal, BOOL *pbFoundArg)
{
    LPTSTR lpEnd = NULL;
    int    iTemp;

    iTemp = lstrlen (szArgPrefix);
    if (CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | NORM_STOP_ON_NULL,
                   szArgPrefix, iTemp,
                   szCommandLine, iTemp) == CSTR_EQUAL)
    {
        *pbFoundArg = TRUE;
    
         //
         // Found the switch
         //
        
         szCommandLine += iTemp + 1;
        
         lpEnd = szCommandLine;
         while (*lpEnd && 
                (!( ( (*(lpEnd-1)) != TEXT('\\') ) && ( (*lpEnd) == TEXT('\"') ) ) ) ) /* look for an unesced quote */
             lpEnd++;
        
         // lpEnd is at the end or at the last quote
         *szArgVal = (LPTSTR) LocalAlloc (LPTR, ((lpEnd - szCommandLine) + 1) * sizeof(TCHAR));
        
         if (*szArgVal)
         {
             lstrcpyn (*szArgVal, szCommandLine, (int)((lpEnd - szCommandLine) + 1));
             DebugMsg((DM_VERBOSE, TEXT("ParseCOmmandLine: Argument %s = <%s>"), szArgPrefix, *szArgVal));
         }
        
         if ((*lpEnd) == TEXT('\"'))
             szCommandLine = lpEnd+1;
         
    }
    else
         *pbFoundArg = FALSE;

    return szCommandLine;
}

STDMETHODIMP CRSOPComponentData::Load(IStream *pStm)
{
    HRESULT hr = E_FAIL;
    DWORD dwVersion, dwFlags;
    ULONG nBytesRead;
    SAFEARRAYBOUND rgsabound[1];
    LONG lIndex, lMax;
    LPTSTR lpText = NULL;
    BSTR bstrText;
    LPTSTR lpCommandLine = NULL;
    LPTSTR lpTemp, lpMode;
    BOOL   bFoundArg;
    int    iStrLen;



    //
    // Parameter / initialization check
    //

    if (!pStm)
        return E_FAIL;

    //
    // Get the command line
    //

    lpCommandLine = GetCommandLine();


    //
    // Read in the saved data version number
    //

    hr = pStm->Read(&dwVersion, sizeof(dwVersion), &nBytesRead);

    if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read version number with 0x%x."), hr));
        hr = E_FAIL;
        goto Exit;
    }


    //
    // Confirm that we are working with the correct version
    //

    if (dwVersion != RSOP_PERSIST_DATA_VERSION)
    {
        ReportError(m_hwndFrame, 0, IDS_INVALIDMSC);
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Wrong version number (%d)."), dwVersion));
        hr = E_FAIL;
        goto Exit;
    }


    //
    // Read the flags
    //

    hr = pStm->Read(&dwFlags, sizeof(dwFlags), &nBytesRead);

    if ((hr != S_OK) || (nBytesRead != sizeof(dwFlags)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read flags with 0x%x."), hr));
        hr = E_FAIL;
        goto Exit;
    }


    //
    // Parse the command line
    //

    DebugMsg((DM_VERBOSE, TEXT("CComponentData::Load: Command line switch override enabled.  Command line = %s"), lpCommandLine));

    lpTemp = lpCommandLine;
    iStrLen = lstrlen (RSOP_CMD_LINE_START);

    do
    {
        if (CompareString(LOCALE_USER_DEFAULT, NORM_IGNORECASE | NORM_STOP_ON_NULL,
                          RSOP_CMD_LINE_START, iStrLen,
                          lpTemp, iStrLen) == CSTR_EQUAL)
        {

            m_bOverride = TRUE;
            m_dwLoadFlags = RSOPMSC_OVERRIDE;
            lpTemp = ParseCommandLine(lpTemp, RSOP_MODE, &lpMode, &bFoundArg);

            if (bFoundArg) {
                if (lpMode && lpMode[0]) {
                    m_bDiagnostic = (_ttoi(lpMode) == 0);
                }
                else {
                    m_bDiagnostic = FALSE;
                }

                if (lpMode) {
                    LocalFree(lpMode);
                }

                m_bOverride = TRUE;
                continue;
            }


            lpTemp = ParseCommandLine(lpTemp, RSOP_USER_OU_PREF, &m_szUserSOMPref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }
           
            lpTemp = ParseCommandLine(lpTemp, RSOP_COMP_OU_PREF, &m_szComputerSOMPref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }
           
            lpTemp = ParseCommandLine(lpTemp, RSOP_USER_NAME, &m_szUserNamePref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }
           
            lpTemp = ParseCommandLine(lpTemp, RSOP_COMP_NAME, &m_szComputerNamePref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }
           
            lpTemp = ParseCommandLine(lpTemp, RSOP_SITENAME, &m_szSitePref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }

            lpTemp = ParseCommandLine(lpTemp, RSOP_DCNAME_PREF, &m_szDCPref, &bFoundArg);

            if (bFoundArg) {
                continue;
            }

            lpTemp += iStrLen;
            continue;
        }
        lpTemp++;

    } while (*lpTemp);
        
    
    if (!m_bOverride) {
        m_dwLoadFlags = RSOPMSC_NOOVERRIDE;

        m_bOverride = FALSE;

        if (dwFlags & MSC_RSOP_FLAG_DIAGNOSTIC)
        {
            m_bDiagnostic = TRUE;
        }
    
    
        if (dwFlags & MSC_RSOP_FLAG_ARCHIVEDATA)
        {
            m_bArchiveData = TRUE;
            m_bViewIsArchivedData = TRUE;
        }
    
    
        if (dwFlags & MSC_RSOP_FLAG_SLOWLINK)
        {
            m_bSlowLink = TRUE;
        }
        
        if (dwFlags & MSC_RSOP_FLAG_LOOPBACK_REPLACE)
        {
            m_loopbackMode = LoopbackReplace;
        }
        else if (dwFlags & MSC_RSOP_FLAG_LOOPBACK_MERGE)
        {
            m_loopbackMode = LoopbackMerge;
        }
        else
        {
            m_loopbackMode = LoopbackNone;
        }
  
    
        if (dwFlags & MSC_RSOP_FLAG_NOUSER)
        {
            m_bNoUserData = TRUE;
        }
    
    
        if (dwFlags & MSC_RSOP_FLAG_NOCOMPUTER)
        {
            m_bNoComputerData = TRUE;
        }


        if (dwFlags & MSC_RSOP_FLAG_USERDENIED)
        {
            m_bUserDeniedAccess = TRUE;
        }


        if (dwFlags & MSC_RSOP_FLAG_COMPUTERDENIED)
        {
            m_bComputerDeniedAccess = TRUE;
        }


        //
        // Read the computer name
        //
    
        hr = ReadString (pStm, &m_szComputerName);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the computer name with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read the computer SOM
        //
    
        hr = ReadString (pStm, &m_szComputerSOM);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the computer SOM with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the security group count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read security group count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the security groups
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saComputerSecurityGroups = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saComputerSecurityGroups)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read security group with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saComputerSecurityGroups, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
    
        //
        // Read in the WQL filter count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filter count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the WQL filters
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saComputerWQLFilters = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saComputerWQLFilters)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filter with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saComputerWQLFilters, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
    
        //
        // Read in the WQL filter name count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filter name count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the WQL filter names
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saComputerWQLFilterNames = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saComputerWQLFilterNames)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filter with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saComputerWQLFilterNames, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
    
        //
        // Read the user name
        //
    
        hr = ReadString (pStm, &m_szUserName);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the user name with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read the user display name (only used in diagnostic mode)
        //
    
        hr = ReadString (pStm, &m_szUserDisplayName);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the user display name with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
        if (m_bDiagnostic && !lstrcmpi(m_szUserName, TEXT(".")) && !m_bArchiveData)
        {
            LPTSTR lpTemp;
    
            lpTemp = MyGetUserName (NameSamCompatible);
    
            if (lpTemp)
            {
                if (m_szUserDisplayName)
                {
                    delete [] m_szUserDisplayName;
                }
    
                m_szUserDisplayName = new TCHAR[lstrlen(lpTemp) + 1];
    
                if (m_szUserDisplayName)
                {
                    lstrcpy (m_szUserDisplayName, lpTemp);
                }
    
                LocalFree (lpTemp);
            }
        }
    
    
        //
        // Read the user SOM
        //
    
        hr = ReadString (pStm, &m_szUserSOM);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the user SOM with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the security group count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read security group count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the security groups
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saUserSecurityGroups = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saUserSecurityGroups)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read security group with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saUserSecurityGroups, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
    
        //
        // Read in the WQL filter count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read WQL filter count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the WQL filters
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saUserWQLFilters = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saUserWQLFilters)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filters with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saUserWQLFilters, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
    
        //
        // Read in the WQL filter name count
        //
    
        hr = pStm->Read(&lMax, sizeof(lMax), &nBytesRead);
    
        if ((hr != S_OK) || (nBytesRead != sizeof(dwVersion)))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read WQL filter name count with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read in the WQL filter names
        //
    
        if (lMax)
        {
            rgsabound[0].lLbound = 0;
            rgsabound[0].cElements = lMax + 1;
    
            m_saUserWQLFilterNames = SafeArrayCreate (VT_BSTR, 1, rgsabound);
    
            if (m_saUserWQLFilterNames)
            {
                for (lIndex = 0; lIndex <= lMax; lIndex++)
                {
                    hr = ReadString (pStm, &lpText);
    
                    if (hr != S_OK)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read wql filters with 0x%x."), hr));
                        hr = E_FAIL;
                        goto Exit;
                    }
    
                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(m_saUserWQLFilterNames, &lIndex, bstrText);
    
                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: SafeArrayPutElement failed with 0x%x."), hr));
                            goto Exit;
                        }
                    }
    
                    delete [] lpText;
                }
            }
        }
    
        //
        // Read the site
        //
    
        hr = ReadString (pStm, &m_szSite);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the site with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    
    
        //
        // Read the DC
        //
    
        hr = ReadString (pStm, &m_szDC);
    
        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Failed to read the dc with 0x%x."), hr));
            hr = E_FAIL;
            goto Exit;
        }
    }
    
    //
    // Read in the WMI data if appropriate
    //

    if (m_bArchiveData)
    {
        m_pStm = pStm;
        DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::Load: Launching RSOP status dialog box.")));

        if (DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_RSOP_STATUSMSC),
                           NULL, InitRsopDlgProc, (LPARAM) this ) == -1) {

            m_pStm = NULL;
            hr = HRESULT_FROM_WIN32(GetLastError());
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Falied to create dialog box. 0x%x"), hr));
            goto Exit;
        }
        m_pStm = NULL;
    }
    else
    {
        //
        // Initialize the snapin
        //

        if (m_dwLoadFlags == RSOPMSC_OVERRIDE) {
            hr = InitializeRSOPFromMSC(m_dwLoadFlags);

            if (hr == S_FALSE) {
                // this is a hack to get mmc to not launch itself when user cancelled the wizard
                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::Load: User cancelled the wizard. Exitting the process")));
                TerminateProcess (GetCurrentProcess(), ERROR_CANCELLED);
            }
            else {
                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: InitializeRSOP failed with 0x%x."), hr));
                    goto Exit;
                }
            }
        }
        else {
            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::Load: Launching RSOP status dialog box.")));

            if (DialogBoxParam(g_hInstance, MAKEINTRESOURCE(IDD_RSOP_STATUSMSC),
                               NULL, InitRsopDlgProc, (LPARAM) this ) == -1) {

                hr = HRESULT_FROM_WIN32(GetLastError());
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Load: Falied to create dialog box. 0x%x"), hr));
                goto Exit;
            }
        }
    }
    
    

Exit:
    return hr;
}

INT_PTR CALLBACK CRSOPComponentData::InitRsopDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;
    HRESULT hr = S_OK;
    TCHAR szMessage[200];


    switch (message)
    {
        case WM_INITDIALOG:
        {
            pCD = (CRSOPComponentData *) lParam;
            SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

            if (pCD)
            {
                pCD->InitializeResultsList (GetDlgItem (hDlg, IDC_LIST1));
                pCD->FillResultsList (GetDlgItem (hDlg, IDC_LIST1));
                if (pCD->m_bArchiveData) {
                    LoadString(g_hInstance, IDS_PLEASEWAIT1, szMessage, ARRAYSIZE(szMessage));
                    SetWindowText(GetDlgItem(hDlg, IDC_STATIC1), szMessage);
                    ShowWindow(GetDlgItem(hDlg, IDC_PROGRESS1), SW_HIDE);
                }
            }


            PostMessage(hDlg, WM_INITRSOP, 0, 0);
            return TRUE;
        }

        case WM_INITRSOP:

            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
                        
            if (pCD->m_bArchiveData) {
                hr = pCD->InitializeRSOPFromArchivedData(pCD->m_pStm);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitRsopDlgProc: InitializeRSOPFromArchivedData failed with 0x%x."), hr));
                    EndDialog(hDlg, 0);
                    return TRUE;
                }
            }
            else {
                hr = pCD->InitializeRSOP(hDlg);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitRsopDlgProc: InitializeRSOP failed with 0x%x."), hr));
                    EndDialog(hDlg, 0);
                    return TRUE;
                }
            }
            EndDialog(hDlg, 1);
            return TRUE;
    }

    return FALSE;
}

STDMETHODIMP CRSOPComponentData::CopyFileToMSC (LPTSTR lpFileName, IStream *pStm)
{
    ULONG nBytesWritten;
    WIN32_FILE_ATTRIBUTE_DATA info;
    ULARGE_INTEGER FileSize, SubtractAmount;
    HANDLE hFile;
    DWORD dwError, dwReadAmount, dwRead;
    LPBYTE lpData;
    HRESULT hr;


    //
    // Get the file size
    //

    if (!GetFileAttributesEx (lpFileName, GetFileExInfoStandard, &info))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to get file attributes with %d."), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }

    FileSize.LowPart = info.nFileSizeLow;
    FileSize.HighPart = info.nFileSizeHigh;


    //
    // Save the file size
    //

    hr = pStm->Write(&FileSize, sizeof(FileSize), &nBytesWritten);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to write string length with %d."), hr));
        return hr;
    }

    if (nBytesWritten != sizeof(FileSize))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to write the correct amount of data.")));
        return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
    }


    //
    // Allocate a buffer to use for the transfer
    //

    lpData = (LPBYTE) LocalAlloc (LPTR, 4096);

    if (!lpData)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to allocate memory with %d."), GetLastError()));
        return HRESULT_FROM_WIN32(GetLastError());
    }


    //
    // Open the temp file
    //

    hFile = CreateFile (lpFileName, GENERIC_READ, 0, NULL, OPEN_EXISTING,
                        FILE_ATTRIBUTE_NORMAL, NULL);

    if (hFile == INVALID_HANDLE_VALUE)
    {
        dwError = GetLastError();
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: CreateFile for %s failed with %d"), lpFileName, dwError));
        LocalFree (lpData);
        return HRESULT_FROM_WIN32(dwError);
    }


    while (FileSize.QuadPart)
    {

        //
        // Determine how much to read
        //

        dwReadAmount = (FileSize.QuadPart > 4096) ? 4096 : FileSize.LowPart;


        //
        // Read from the temp file
        //

        if (!ReadFile (hFile, lpData, dwReadAmount, &dwRead, NULL))
        {
            dwError = GetLastError();
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: ReadFile failed with %d"), dwError));
            LocalFree (lpData);
            CloseHandle (hFile);
            return HRESULT_FROM_WIN32(dwError);
        }


        //
        // Make sure we read enough
        //

        if (dwReadAmount != dwRead)
        {
            dwError = ERROR_INVALID_DATA;
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to read enough data")));
            LocalFree (lpData);
            CloseHandle (hFile);
            return HRESULT_FROM_WIN32(dwError);
        }


        //
        // Write to the stream
        //

        hr = pStm->Write(lpData, dwReadAmount, &nBytesWritten);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to write data with %d."), hr));
            LocalFree (lpData);
            CloseHandle (hFile);
            return hr;
        }

        if (nBytesWritten != dwReadAmount)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::CopyFileToMSC: Failed to write the correct amount of data.")));
            LocalFree (lpData);
            CloseHandle (hFile);
            return HRESULT_FROM_WIN32(ERROR_INVALID_DATA);
        }

        SubtractAmount.LowPart = dwReadAmount;
        SubtractAmount.HighPart = 0;

        FileSize.QuadPart = FileSize.QuadPart - SubtractAmount.QuadPart;
    }


    CloseHandle (hFile);
    LocalFree (lpData);

    return S_OK;
}

STDMETHODIMP CRSOPComponentData::Save(IStream *pStm, BOOL fClearDirty)
{
    HRESULT hr = STG_E_CANTSAVE;
    ULONG nBytesWritten;
    DWORD dwTemp;
    DWORD dwFlags;
    GROUP_POLICY_OBJECT_TYPE gpoType;
    LPTSTR lpPath = NULL;
    LPTSTR lpTemp;
    DWORD dwPathSize = 1024;
    LONG lIndex, lMax;
    LPTSTR lpText;
    LPTSTR lpUserData = NULL, lpComputerData = NULL;
    TCHAR szPath[2*MAX_PATH];


    //
    // Save the version number
    //

    dwTemp = RSOP_PERSIST_DATA_VERSION;

    hr = pStm->Write(&dwTemp, sizeof(dwTemp), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write version number with %d."), hr));
        goto Exit;
    }


    //
    // Save the flags
    //

    dwTemp = 0;

    if (m_bDiagnostic)
    {
        dwTemp |= MSC_RSOP_FLAG_DIAGNOSTIC;
    }

    if (m_bArchiveData)
    {
        dwTemp |= MSC_RSOP_FLAG_ARCHIVEDATA;
    }

    if (m_bSlowLink)
    {
        dwTemp |= MSC_RSOP_FLAG_SLOWLINK;
    }
    
    switch (m_loopbackMode)
    {
    case LoopbackReplace:
        dwTemp |= MSC_RSOP_FLAG_LOOPBACK_REPLACE;
        break;
    case LoopbackMerge:
        dwTemp |= MSC_RSOP_FLAG_LOOPBACK_MERGE;
        break;
    default:
        break;
    }

    if (m_bNoUserData)
    {
        dwTemp |= MSC_RSOP_FLAG_NOUSER;
    }

    if (m_bNoComputerData)
    {
        dwTemp |= MSC_RSOP_FLAG_NOCOMPUTER;
    }

    if (m_bUserDeniedAccess)
    {
        dwTemp |= MSC_RSOP_FLAG_USERDENIED;
    }

    if (m_bComputerDeniedAccess)
    {
        dwTemp |= MSC_RSOP_FLAG_COMPUTERDENIED;
    }

    hr = pStm->Write(&dwTemp, sizeof(dwTemp), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write flags with %d."), hr));
        goto Exit;
    }


    //
    // Save the computer name
    //

    TCHAR szLocalComputerName[MAX_PATH+1];
    ULONG ulSize;

    if ( (m_bArchiveData) && (!lstrcmpi(m_szComputerName, TEXT("."))) )
    {
        ulSize = ARRAYSIZE(szLocalComputerName);
        if (!GetComputerObjectName (NameSamCompatible, szLocalComputerName, &ulSize))
        {
            GetComputerNameEx (ComputerNameNetBIOS, szLocalComputerName, &ulSize);
        }
    }
    else {
        lstrcpyn(szLocalComputerName, m_szComputerName, MAX_PATH);
    }

    hr = SaveString (pStm, szLocalComputerName);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save computer name with %d."), hr));
        goto Exit;
    }


    //
    // Save the computer SOM
    //

    hr = SaveString (pStm, m_szComputerSOM);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save computer SOM with %d."), hr));
        goto Exit;
    }


    //
    // Save the computer security groups
    //

    lMax = 0;

    if (m_saComputerSecurityGroups)
    {
        SafeArrayGetUBound (m_saComputerSecurityGroups, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saComputerSecurityGroups, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save security group with %d."), hr));
                    goto Exit;
                }
            }
        }
    }


    //
    // Save the computer WQL filters
    //

    lMax = 0;

    if (m_saComputerWQLFilters)
    {
        SafeArrayGetUBound (m_saComputerWQLFilters, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saComputerWQLFilters, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save wql filter with %d."), hr));
                    goto Exit;
                }
            }
        }
    }


    //
    // Save the computer WQL filter names
    //

    lMax = 0;

    if (m_saComputerWQLFilterNames)
    {
        SafeArrayGetUBound (m_saComputerWQLFilterNames, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saComputerWQLFilterNames, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save wql filter with %d."), hr));
                    goto Exit;
                }
            }
        }
    }

    //
    // Save the user name/
    // fyi, This is not used in diagnostic mode archive data
    //
    
    hr = SaveString (pStm, m_szUserName);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save user name with %d."), hr));
        goto Exit;
    }


    //
    // Save the user display name (only used in diagnostic mode)
    //

    if (m_bDiagnostic && !lstrcmpi(m_szUserName, TEXT(".")))
    {
        if (m_bArchiveData) {
            LPTSTR lpTemp;

            lpTemp = MyGetUserName (NameSamCompatible);

            if (lpTemp)
            {
                hr = SaveString (pStm, lpTemp);
                LocalFree (lpTemp);
            }
        }
    }
    else
    {
        hr = SaveString (pStm, m_szUserDisplayName);
    }

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save user display name with %d."), hr));
        goto Exit;
    }


    //
    // Save the user SOM
    //

    hr = SaveString (pStm, m_szUserSOM);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save user SOM with %d."), hr));
        goto Exit;
    }


    //
    // Save the user security groups
    //

    lMax = 0;

    if (m_saUserSecurityGroups)
    {
        SafeArrayGetUBound (m_saUserSecurityGroups, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saUserSecurityGroups, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save security group with %d."), hr));
                    goto Exit;
                }
            }
        }
    }


    //
    // Save the user WQL filters
    //

    lMax = 0;

    if (m_saUserWQLFilters)
    {
        SafeArrayGetUBound (m_saUserWQLFilters, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saUserWQLFilters, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save wql filter with %d."), hr));
                    goto Exit;
                }
            }
        }
    }


    //
    // Save the user WQL filter names
    //

    lMax = 0;

    if (m_saUserWQLFilterNames)
    {
        SafeArrayGetUBound (m_saUserWQLFilterNames, 1, &lMax);
    }

    hr = pStm->Write(&lMax, sizeof(lMax), &nBytesWritten);

    if ((hr != S_OK) || (nBytesWritten != sizeof(dwTemp)))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to write security group count with %d."), hr));
        goto Exit;
    }

    if (lMax)
    {
        for (lIndex = 0; lIndex <= lMax; lIndex++)
        {
            if (SUCCEEDED(SafeArrayGetElement(m_saUserWQLFilterNames, &lIndex, &lpText)))
            {
                hr = SaveString (pStm, lpText);

                if (hr != S_OK)
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save wql filter with %d."), hr));
                    goto Exit;
                }
            }
        }
    }


    //
    // Save the site
    //

    hr = SaveString (pStm, m_szSite);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save site with %d."), hr));
        goto Exit;
    }


    //
    // Save the DC
    //

    hr = SaveString (pStm, m_szDC);

    if (hr != S_OK)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: Failed to save DC with %d."), hr));
        goto Exit;
    }


    //
    // Save the WMI and event log data if appropriate
    //

    if (m_bArchiveData)
    {
        lpComputerData = CreateTempFile();

        if (!lpComputerData)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: CreateTempFile failed with %d."), GetLastError()));
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto Exit;
        }


        lstrcpy (szPath, m_szNamespace);
        lpTemp = CheckSlash (szPath);
        lstrcpy (lpTemp, COMPUTER_SECTION);

        hr = ExportRSoPData (szPath, lpComputerData);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: ExportRSoPData failed with 0x%x."), hr));
            goto Exit;
        }

        hr = CopyFileToMSC (lpComputerData, pStm);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: CopyFileToMSC failed with 0x%x."), hr));
            goto Exit;
        }


        lpUserData = CreateTempFile();

        if (!lpUserData)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: CreateTempFile failed with %d."), GetLastError()));
            hr = HRESULT_FROM_WIN32(GetLastError());
            goto Exit;
        }

        lstrcpy (lpTemp, USER_SECTION);

        hr = ExportRSoPData (szPath, lpUserData);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: ExportRSoPData failed with 0x%x."), hr));
            goto Exit;
        }

        hr = CopyFileToMSC (lpUserData, pStm);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: CopyFileToMSC failed with 0x%x."), hr));
            goto Exit;
        }


        //
        //  Save the event log entries
        //

        hr = m_pEvents->SaveEntriesToStream(pStm);

        if (hr != S_OK)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::Save: SaveEntriesToStream failed with 0x%x."), hr));
            goto Exit;
        }
    }

    if (fClearDirty)
    {
        ClearDirty();
    }

Exit:

    if (lpUserData)
    {
        DeleteFile (lpUserData);
        delete [] lpUserData;
    }

    if (lpComputerData)
    {
        DeleteFile (lpComputerData);
        delete [] lpComputerData;
    }

    return hr;
}


STDMETHODIMP CRSOPComponentData::GetSizeMax(ULARGE_INTEGER *pcbSize)
{
    return E_NOTIMPL;
}

STDMETHODIMP CRSOPComponentData::InitNew(void)
{
    return S_OK;
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (ISnapinHelp)                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CRSOPComponentData::GetHelpTopic(LPOLESTR *lpCompiledHelpFile)
{
    LPOLESTR lpHelpFile;


    lpHelpFile = (LPOLESTR) CoTaskMemAlloc (MAX_PATH * sizeof(WCHAR));

    if (!lpHelpFile)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetHelpTopic: Failed to allocate memory.")));
        return E_OUTOFMEMORY;
    }

    ExpandEnvironmentStringsW (L"%SystemRoot%\\Help\\rsopsnp.chm",
                               lpHelpFile, MAX_PATH);

    *lpCompiledHelpFile = lpHelpFile;

    return S_OK;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPComponentData object implementation (Internal functions)             //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

HRESULT CRSOPComponentData::IsNode (LPDATAOBJECT lpDataObject, MMC_COOKIE cookie)
{
    HRESULT hr = S_FALSE;
    LPRSOPDATAOBJECT pRSOPDataObject;
    DATA_OBJECT_TYPES type;
    MMC_COOKIE testcookie;


    //
    // We can determine if this is a GPO DataObject by trying to
    // QI for the private IGPEDataObject interface.  If found,
    // it belongs to us.
    //

    if (SUCCEEDED(lpDataObject->QueryInterface(IID_IRSOPDataObject,
                 (LPVOID *)&pRSOPDataObject)))
    {

        pRSOPDataObject->GetType(&type);
        pRSOPDataObject->GetCookie(&testcookie);

        if ((type == CCT_SCOPE) && (cookie == testcookie))
        {
            hr = S_OK;
        }

        pRSOPDataObject->Release();
    }

    return (hr);
}


HRESULT CRSOPComponentData::IsSnapInManager (LPDATAOBJECT lpDataObject)
{
    HRESULT hr = S_FALSE;
    LPRSOPDATAOBJECT pRSOPDataObject;
    DATA_OBJECT_TYPES type;


    //
    // We can determine if this is a RSOP DataObject by trying to
    // QI for the private IRSOPDataObject interface.  If found,
    // it belongs to us.
    //

    if (SUCCEEDED(lpDataObject->QueryInterface(IID_IRSOPDataObject,
                                               (LPVOID *)&pRSOPDataObject)))
    {

        //
        // This is a GPO object.  Now see if is a scope pane
        // data object.  We only want to display the property
        // sheet for the scope pane.
        //

        if (SUCCEEDED(pRSOPDataObject->GetType(&type)))
        {
            if (type == CCT_SNAPIN_MANAGER)
            {
                hr = S_OK;
            }
        }
        pRSOPDataObject->Release();
    }

    return(hr);
}


HRESULT CRSOPComponentData::EnumerateScopePane (LPDATAOBJECT lpDataObject, HSCOPEITEM hParent)
{
    SCOPEDATAITEM item;
    HRESULT hr;
    DWORD dwIndex, i;


    if (!m_hRoot)
    {

        m_hRoot = hParent;

        if (!m_bRefocusInit)
        {
            SCOPEDATAITEM item;

            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::EnumerateScopePane:  Resetting the root node")));
            m_bRefocusInit = TRUE;

            ZeroMemory (&item, sizeof(SCOPEDATAITEM));
            item.mask = SDI_STR | SDI_IMAGE | SDI_OPENIMAGE;
            item.displayname = MMC_CALLBACK;

            if (m_bInitialized)
            {
                if (m_bUserGPCoreError || m_bComputerGPCoreError)
                {
                    item.nImage = 3;
                    item.nOpenImage = 3;
                }
                else if (m_bUserCSEError || m_bComputerCSEError ||
                         m_bUserDeniedAccess || m_bComputerDeniedAccess)
                {
                    item.nImage = 11;
                    item.nOpenImage = 11;
                }
                else
                {
                    item.nImage = 2;
                    item.nOpenImage = 2;
                }
            }
            else
            {
                item.nImage = 3;
                item.nOpenImage = 3;
            }

            item.ID = hParent;

            m_pScope->SetItem (&item);
        }
    }


    if (!m_bInitialized)
    {
        if (m_hRoot == hParent)
        {
            SCOPEDATAITEM item;

            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::EnumerateScopePane: No GPO available.  Exiting.")));

            ZeroMemory (&item, sizeof(SCOPEDATAITEM));
            item.mask = SDI_STR | SDI_STATE | SDI_IMAGE | SDI_OPENIMAGE | SDI_PARAM | SDI_CHILDREN;
            item.displayname = MMC_CALLBACK;
            item.nImage = 3;
            item.nOpenImage = 3;
            item.nState = 0;
            item.cChildren = 0;
            item.lParam = g_NameSpace[0].dwID;
            item.relativeID =  hParent;

            m_pScope->InsertItem (&item);
        }

        return S_OK;
    }


    if (m_hRoot == hParent)
    {
        dwIndex = 0;
    }
    else
    {
        item.mask = SDI_PARAM;
        item.ID = hParent;

        hr = m_pScope->GetItem (&item);

        if (FAILED(hr))
            return hr;

        dwIndex = (DWORD)item.lParam;
    }

    for (i = 0; i < g_dwNameSpaceItems; i++)
    {
        if (g_RsopNameSpace[i].dwParent == dwIndex)
        {
            BOOL bAdd = TRUE;

            if (g_RsopNameSpace[i].dwID == 1)
            {
                if (!m_szComputerName && !m_szComputerSOM)
                {
                    bAdd = FALSE;
                }

                if (m_bNoComputerData)
                {
                    bAdd = FALSE;
                }

                if (m_bComputerDeniedAccess)
                {
                    bAdd = FALSE;
                }
            }

            if (g_RsopNameSpace[i].dwID == 2)
            {
                if (!m_szUserName && !m_szUserSOM && LoopbackNone == m_loopbackMode)
                {
                    bAdd = FALSE;
                }

                if (m_bNoUserData)
                {
                    bAdd = FALSE;
                }

                if (m_bUserDeniedAccess)
                {
                    bAdd = FALSE;
                }
            }

            if (bAdd)
            {
                INT iIcon, iOpenIcon;

                iIcon = g_RsopNameSpace[i].iIcon;
                iOpenIcon = g_RsopNameSpace[i].iOpenIcon;

                if ((i == 1) && m_bComputerGPCoreError)
                {
                    iIcon = 12;
                    iOpenIcon = 12;
                }

                else if ((i == 1) && m_bComputerCSEError)
                {
                    iIcon = 14;
                    iOpenIcon = 14;
                }
                else if ((i == 2) && m_bUserGPCoreError)
                {
                    iIcon = 13;
                    iOpenIcon = 13;
                }
                else if ((i == 2) && m_bUserCSEError)
                {
                    iIcon = 15;
                    iOpenIcon = 15;
                }

                item.mask = SDI_STR | SDI_STATE | SDI_IMAGE | SDI_OPENIMAGE | SDI_PARAM | SDI_CHILDREN;
                item.displayname = MMC_CALLBACK;
                item.nImage = iIcon;
                item.nOpenImage = iOpenIcon;
                item.nState = 0;
                item.cChildren = g_RsopNameSpace[i].cChildren;
                item.lParam = g_RsopNameSpace[i].dwID;
                item.relativeID =  hParent;

                if (SUCCEEDED(m_pScope->InsertItem (&item)))
                {
                    if (i == 1)
                    {
                        m_hMachine = item.ID;
                    }
                    else if (i == 2)
                    {
                        m_hUser = item.ID;
                    }
                }
            }
        }
    }

    return S_OK;
}

HRESULT ImplementBrowseButton(HWND hDlg, DWORD dwFlagsUp, DWORD dwFlagsDown,
                              DWORD dwflScope, HWND hLB, TCHAR * &sz)
{
        // 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;

        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
           //

           sz = new WCHAR[ulSize];
           if (sz)
           {
                if (TranslateName (lpTemp, NameFullyQualifiedDN,
                                   NameSamCompatible, sz, &ulSize))
                {
                    BOOL bDollarRemoved = FALSE;

                    if (sz[wcslen(sz)-1] == L'$')
                    {
                        bDollarRemoved = TRUE;
                        sz[wcslen(sz)-1] = 0;
                    }

                    if (hLB)
                    {
                        INT iIndex;

                        iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) sz);
                        SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) ((bDollarRemoved) ? 2: 0));

                        SendMessage (hLB, LB_SETCURSEL, (WPARAM) iIndex, 0);
                        delete [] sz;
                        sz = NULL;
                    }
                }
                else
                {
                    hr = HRESULT_FROM_WIN32(GetLastError());
                    DebugMsg((DM_WARNING, TEXT("ImplementBrowseButton: TranslateName for %s to SAM style failed with %d."),
                             lpTemp, GetLastError()));
                    delete [] sz;
                    goto Browse_Cleanup;
                }
           }
           else
           {
               hr = E_OUTOFMEMORY;
           }
       }


    Browse_Cleanup:
        if (pDsSelList)
            GlobalUnlock (pDsSelList);
        if (bAllocatedStgMedium)
            ReleaseStgMedium (&stgmedium);
        if (pdo)
            pdo->Release();
        if (pDsObjectPicker)
            pDsObjectPicker->Release();
    return hr;
}
 
void GetControlText(HWND hDlg, DWORD ctrlid, TCHAR * &sz)
{
    UINT n;

    if (sz)
    {
        delete [] sz;
        sz = NULL;
    }
    n = (UINT) SendMessage(GetDlgItem(hDlg, ctrlid),
                    WM_GETTEXTLENGTH, 0, 0);
    if (n > 0)
    {
        sz =  new TCHAR[n + 1];
        if (sz)
        {
            LPTSTR lpDest, lpSrc;

            GetDlgItemText(hDlg, ctrlid, sz, n + 1);

            if (sz[0] == TEXT(' '))
            {
                //
                // Remove leading blanks by shuffling the characters forward
                //

                lpDest = lpSrc = sz;

                while ((*lpSrc == TEXT(' ')) && *lpSrc)
                    lpSrc++;

                if (*lpSrc)
                {
                    while (*lpSrc)
                    {
                        *lpDest = *lpSrc;
                        lpDest++;
                        lpSrc++;
                    }
                    *lpDest = TEXT('\0');
                }
            }

            //
            // Remove trailing blanks
            //

            lpDest = sz + lstrlen(sz) - 1;

            while ((*lpDest == TEXT(' ')) && (lpDest >= sz))
                lpDest--;

            *(lpDest+1) = TEXT('\0');
        }
    }
}

INT_PTR CALLBACK CRSOPComponentData::RSOPWelcomeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        {
            TCHAR szDefaultGPO[128];


            pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
            SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

            SendMessage(GetDlgItem(hDlg, IDC_RSOP_BIG_BOLD1),
                        WM_SETFONT, (WPARAM)pCD->m_BigBoldFont, (LPARAM)TRUE);

/*

            if (!pCD->m_hChooseBitmap)
            {
                pCD->m_hChooseBitmap = (HBITMAP) LoadImage (g_hInstance,
                                                            MAKEINTRESOURCE(IDB_WIZARD),
                                                            IMAGE_BITMAP, 0, 0,
                                                            LR_DEFAULTCOLOR);
            }

            if (pCD->m_hChooseBitmap)
            {
                SendDlgItemMessage (hDlg, IDC_BITMAP, STM_SETIMAGE,
                                    IMAGE_BITMAP, (LPARAM) pCD->m_hChooseBitmap);
            }
*/
        }

        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
        }

        break;
    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg),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 CRSOPComponentData::RSOPChooseModeDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        SendMessage(GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_CHECKED, 0);

        if (IsStandaloneComputer() || 
            ! IsPlanningModeAllowed())
        {
            EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
        }
        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_WIZNEXT:
            pCD->m_bDiagnostic = TRUE;
            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                // skip to the planning mode pages
                pCD->m_bDiagnostic = FALSE;
                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;
}

BOOL CRSOPComponentData::TestAndValidateComputer(HWND hDlg)
{
    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;

    if (m_szComputerName && lstrcmpi(m_szComputerName, TEXT(".")))
    {
        lpMachineName = new TCHAR[(lstrlen(m_szComputerName) + 3)];

        if (!lpMachineName)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::TestAndValidateComputer: Failed to allocate memory with %d"), GetLastError()));
            goto Exit;
        }

        lstrcpy (lpMachineName, TEXT("\\\\"));

        if ((lstrlen (m_szComputerName) > 2) && (m_szComputerName[0] == TEXT('\\')) &&
            (m_szComputerName[1] == TEXT('\\')))
        {
            lstrcat (lpMachineName, m_szComputerName + 2);
        }
        else
        {
            lstrcat (lpMachineName, NameWithoutDomain(m_szComputerName));
        }
    }

    SetWaitCursor();

    //
    // If we are testing a remote machine, test if the machine is alive and has
    // the rsop namespace
    //

    if (lpMachineName)
    {
        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_szComputerName);
            }
            else
            {
                ReportError (hDlg, GetLastError(), IDS_CONNECTSERVERFAILED, m_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));
        ReportError (hDlg, lResult, IDS_CONNECTSERVERFAILED, m_szComputerName);
        bOk = FALSE;
        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;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPGetCompDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        if (pCD->m_szComputerNamePref) {
            if (pCD->m_szComputerName)
            {
                delete [] pCD->m_szComputerName;
            }

            pCD->m_szComputerName =  new WCHAR[wcslen(pCD->m_szComputerNamePref)+1];
            if (pCD->m_szComputerName)
            {
                wcscpy (pCD->m_szComputerName, NormalizedComputerName(pCD->m_szComputerNamePref));
                if (wcslen(pCD->m_szComputerName) >= 1) {
                    // this is being called from dsa. A terminating '$' will be passed in
                    pCD->m_szComputerName[wcslen(pCD->m_szComputerName)-1] = L'\0';
                }
            }

            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);
            EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
            SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szComputerName);


            pCD->m_bNoComputerData = FALSE;
            CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
            PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);

        }
        else {
            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
        }

        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }

            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);
                    delete [] 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;

            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (pCD->m_bOverride) {
                PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
            }
            else {
                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), PSWIZB_BACK | PSWIZB_NEXT);
                    else
                        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
                }
                else
                {
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
                }
            }
        }
        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_WIZNEXT:
            if (IsDlgButtonChecked (hDlg, IDC_RADIO2) == BST_CHECKED)
            {
                GetControlText(hDlg, IDC_EDIT1, pCD->m_szComputerName);

                if ( pCD->m_szComputerName )
                {
                    TCHAR* szNormalizedComputerName;
                    
                    // We need to handle the case where the user enters a name 
                    // prefixed by '\\'

                    szNormalizedComputerName = NormalizedComputerName( pCD->m_szComputerName );
                    
                    // If we detect the '\\' prefix, we must remove it since this syntax
                    // is not recognized by the RSoP provider
                    if ( szNormalizedComputerName != pCD->m_szComputerName )
                    {
                        TCHAR* szNewComputerName;

                        szNewComputerName = new TCHAR [ lstrlen( szNormalizedComputerName ) + 1 ];

                        if ( szNewComputerName )
                        {
                            lstrcpy( szNewComputerName, szNormalizedComputerName );
                        }

                        delete [] pCD->m_szComputerName;                            

                        pCD->m_szComputerName = szNewComputerName;
                    }
                }
            }
            else
            {
                if (pCD->m_szComputerName)
                {
                    delete [] pCD->m_szComputerName;
                }

                pCD->m_szComputerName =  new TCHAR[2];
                if (pCD->m_szComputerName)
                {
                    wcscpy (pCD->m_szComputerName, L".");
                }
            }

            if (pCD->TestAndValidateComputer (hDlg))
            {
                SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);

                if (pCD->m_szUserName)
                {
                    delete [] pCD->m_szUserName;
                    pCD->m_szUserName = NULL;
                }

                if (pCD->m_szUserDisplayName)
                {
                    delete [] pCD->m_szUserDisplayName;
                    pCD->m_szUserDisplayName = NULL;
                }
            }
            else
            {
                SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
            }

            if (IsDlgButtonChecked (hDlg, IDC_CHECK1) == BST_CHECKED)
            {
                pCD->m_bNoComputerData = TRUE;
            }
            else
            {
                pCD->m_bNoComputerData = FALSE;
            }

            return TRUE;

        case PSN_SETACTIVE:
            if (pCD->m_bOverride) {
                // This is the start page if rsop.msc is launched with
                // cmd line arg for logging mode
                PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_NEXT);
            }

            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            break;


        case PSN_RESET:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
        }
        break;

    }


    return FALSE;
}

HRESULT CRSOPComponentData::FillUserList (HWND hList, BOOL *bFoundCurrentUser)
{
    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   bFoundUserPref = FALSE;

    if (m_szUserNamePref) {
        // Just show the user alone
        *bFoundCurrentUser = FALSE;

        szUserSidPref = MyLookupAccountName(
                               (lstrcmpi(m_szComputerName, TEXT(".")) == 0) ? NULL : NameWithoutDomain(m_szComputerName),
                               m_szUserNamePref);

        if (!szUserSidPref) {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::FillUserList: MyLookupAccountName failed with %d"), GetLastError()));
            hr = HRESULT_FROM_WIN32(GetLastError());
        }
    }

    if (lstrcmpi(m_szComputerName, TEXT(".")))
    {
        lpSystemName = m_szComputerName;
    }


    *bFoundCurrentUser = 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"
    _stprintf(szBuffer, TEXT("\\\\%s\\root\\rsop"), NameWithoutDomain(m_szComputerName));
    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
    hr = CoSetProxyBlanket(pNamespace,
                           RPC_C_AUTHN_DEFAULT,
                           RPC_C_AUTHZ_DEFAULT,
                           COLE_DEFAULT_PRINCIPAL,
                           RPC_C_AUTHN_LEVEL_CALL,
                           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)))
                        {
                            lpData = new WCHAR[(lstrlen(bstrSid) + 1)];

                            if (lpData)
                            {
                                lstrcpy (lpData, bstrSid);

                                if (lpCurrentUserSid)
                                {
                                    if (!lstrcmpi(lpCurrentUserSid, lpData))
                                    {
                                        *bFoundCurrentUser = 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 = (!m_szUserNamePref || (lstrcmpi(szUserSidPref, lpData) == 0));
                                        
                                        if ((m_szUserNamePref) && (lstrcmpi(szUserSidPref, lpData) == 0))
                                            bFoundUserPref = TRUE;

                                        if  (bAddUser) {
                                            wsprintf (szFullName, TEXT("%s\\%s"), szDomain, szName);

                                            ZeroMemory (&item, sizeof(item));
                                            item.mask = LVIF_TEXT | LVIF_PARAM;
                                            item.pszText = szFullName;
                                            item.lParam = (LPARAM) lpData;
    
                                            iRet = (int) SendMessage (hList, LVM_INSERTITEM, 0, (LPARAM) &item);
    
                                            if (iRet == -1)
                                            {
                                                delete [] lpData;
                                            }
                                        }
                                    }
                                    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 ((m_szUserNamePref) && (!bFoundUserPref)) {
        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);
    }

    return hr;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPGetUserDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        {
        LVCOLUMN lvcol;
        RECT rect;
        HWND hLV = GetDlgItem(hDlg, IDC_LIST1);

        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_WIZNEXT:
            {
                LPTSTR lpData;
                HWND hList = GetDlgItem(hDlg, IDC_LIST1);
                INT iSel;


                if (pCD->m_szUserName)
                {
                    delete [] pCD->m_szUserName;
                    pCD->m_szUserName = NULL;
                }

                if (pCD->m_szUserDisplayName)
                {
                    delete [] pCD->m_szUserDisplayName;
                    pCD->m_szUserDisplayName = NULL;
                }

//                if (IsDlgButtonChecked (hDlg, IDC_CHECK1) == BST_CHECKED)
                if (IsDlgButtonChecked (hDlg, IDC_RADIO4) == BST_CHECKED)
                {
                    pCD->m_bNoUserData = TRUE;
                }
                else
                {
                    pCD->m_bNoUserData = FALSE;

                    if (IsDlgButtonChecked (hDlg, IDC_RADIO1))
                    {
                        LPTSTR lpTemp;

                        if (IsStandaloneComputer())
                        {
                            lpTemp = MyGetUserName (NameUnknown);
                        }
                        else
                        {
                            lpTemp = MyGetUserName (NameSamCompatible);
                        }

                        if (lpTemp)
                        {
                            pCD->m_szUserDisplayName = new TCHAR[lstrlen(lpTemp) + 1];

                            if (pCD->m_szUserDisplayName)
                            {
                                lstrcpy (pCD->m_szUserDisplayName, lpTemp);
                            }

                            LocalFree (lpTemp);
                        }

                        pCD->m_szUserName = new TCHAR[2];

                        if (pCD->m_szUserName)
                        {
                            lstrcpy (pCD->m_szUserName, TEXT("."));
                        }
                    }
                    else
                    {
                        iSel = (INT) SendMessage(hList, LVM_GETNEXTITEM, (WPARAM) -1, MAKELPARAM(LVNI_SELECTED, 0));

                        if (iSel != -1)
                        {
                            pCD->m_szUserDisplayName = new TCHAR[200];
                            if (pCD->m_szUserDisplayName)
                            {
                                LVITEM item;

                                ZeroMemory (&item, sizeof(item));

                                item.mask = LVIF_TEXT | LVIF_PARAM;
                                item.iItem =  iSel;
                                item.pszText = pCD->m_szUserDisplayName;
                                item.cchTextMax = 200;

                                if (SendMessage(hList, LVM_GETITEM, 0, (LPARAM) &item))
                                {

                                    lpData = (LPTSTR) item.lParam;

                                    if (lpData)
                                    {
                                        pCD->m_szUserName = new TCHAR[(lstrlen(lpData) + 1)];
                                        if (pCD->m_szUserName)
                                        {
                                            lstrcpy (pCD->m_szUserName, lpData);
                                        }
                                    }
                                }
                            }
                        }

                    }   // if (IsDlgButtonChecked (hDlg, IDC_RADIO1))

                }


                // skip to the last page in the wizard
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED);
            }
            return TRUE;

        case PSN_SETACTIVE:
            {
                HRESULT hr;
                BOOL bCurrentUserFound;
                HWND hList = GetDlgItem(hDlg, IDC_LIST1);
                SendMessage(hList, LVM_DELETEALLITEMS, 0 ,0);
                PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);

                CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);

                hr = pCD->FillUserList (hList, &bCurrentUserFound);

                if (SUCCEEDED(hr))
                {
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), TRUE);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), TRUE);

                    if (!ListView_GetItemCount (hList))
                    {
//                        CheckDlgButton (hDlg, IDC_CHECK1, BST_CHECKED);
                        CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
                    }
                }
                else
                {
                    ReportError (hDlg, hr, IDS_ENUMUSERSFAILED);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), FALSE);
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                    break;
                }


                if (!(pCD->m_szUserNamePref)) {
                    if ((!lstrcmpi(pCD->m_szComputerName, TEXT("."))) && bCurrentUserFound)
                    {
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), TRUE);
                    }
                    else
                    {
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
                    }

                    if (pCD->m_szUserName)
                    {
                        if (!lstrcmpi(pCD->m_szUserName, TEXT(".")))
                        {
                            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
                        }
                        else
                        {
                            LVFINDINFO FindInfo;
                            LVITEM item;
                            INT iRet;

                            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);

                            ZeroMemory (&FindInfo, sizeof(FindInfo));
                            FindInfo.flags = LVFI_STRING;
                            FindInfo.psz = pCD->m_szUserDisplayName;

                            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
                    {
                        if ((!lstrcmpi(pCD->m_szComputerName, TEXT("."))) && bCurrentUserFound)
                        {
                            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO1);
                        }
                        else
                        {
                            CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);
                        }
                    }

                    if (pCD->m_bNoComputerData)
                    {
                        pCD->m_bNoUserData = FALSE;
//                        CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
                        CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
//                        EnableWindow (GetDlgItem(hDlg, IDC_CHECK1), FALSE);
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);
                    }
                    else
                    {
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), TRUE);
                    }
                }
                else {
                    // disable current user radio button
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO1), FALSE);
                    CheckRadioButton (hDlg, IDC_RADIO1, IDC_RADIO2, IDC_RADIO2);
                    
                    // disable no user data chk box
                    pCD->m_bNoUserData = FALSE;
//                    CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
                    CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
//                    EnableWindow (GetDlgItem(hDlg, IDC_CHECK1), FALSE);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), 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:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }

            if (IsDlgButtonChecked (hDlg, IDC_RADIO4) == BST_CHECKED) {

                EnableWindow(GetDlgItem(hDlg, IDC_LIST1), FALSE);

            } else {


                if (IsWindowEnabled (GetDlgItem(hDlg, IDC_RADIO1)) ||
                    IsWindowEnabled (GetDlgItem(hDlg, IDC_RADIO2)))
                {
                    if (pCD->m_bNoComputerData)
                    {
                        pCD->m_bNoUserData = FALSE;
    //                    CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
                        CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
    //                    EnableWindow (GetDlgItem(hDlg, IDC_CHECK1), FALSE);
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), FALSE);

                    }
                    else
                    {
    //                    EnableWindow (GetDlgItem(hDlg, IDC_CHECK1), TRUE);
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO4), TRUE);
                    }

                    if (IsDlgButtonChecked (hDlg, IDC_RADIO2) == BST_CHECKED)
                    {
                        EnableWindow(GetDlgItem(hDlg, IDC_LIST1), TRUE);

                        if ((INT) SendMessage(GetDlgItem(hDlg, IDC_LIST1), LVM_GETITEMCOUNT, 0, 0))
                        {
                            PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
                            SetFocus (GetDlgItem(hDlg, IDC_LIST1));
                        }
                        else
                        {
    //                        if (IsDlgButtonChecked (hDlg, IDC_CHECK1) == BST_CHECKED)
                            if (IsDlgButtonChecked (hDlg, IDC_RADIO4) == BST_CHECKED)
                            {
                                PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
                            }
                            else
                            {
                                PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
                            }
                        }
                    }
                    else
                    {
                        EnableWindow(GetDlgItem(hDlg, IDC_LIST1), FALSE);
                        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
                    }
                }
                else
                {
                    if (pCD->m_bNoComputerData)
                    {
                        //
                        // if the user said no computer data but
                        // he has access to no users, enable on back button and
                        // disable the checkbox
                        //
                        pCD->m_bNoUserData = FALSE;

    //                    CheckDlgButton (hDlg, IDC_CHECK1, BST_UNCHECKED);
                        CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO3);
    //                    EnableWindow (GetDlgItem(hDlg, IDC_CHECK1), FALSE);
                        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);

    //                    CheckDlgButton (hDlg, IDC_CHECK1, BST_CHECKED);
                        CheckRadioButton(hDlg, IDC_RADIO3, IDC_RADIO4, IDC_RADIO4);
    //                    EnableWindow(GetDlgItem(hDlg, IDC_CHECK1), FALSE);
                        EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), FALSE);

                        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);

                        PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);

                    }
                }
            }
        }
        break;

    }

    return FALSE;
}

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;
}

LPTSTR CRSOPComponentData::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
    //

    hr = pADsPathname->Set (lpDNName, ADS_SETTYPE_DN);

    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
    //

    lpPath = new TCHAR [(lstrlen(bstrContainer)+ 1)];

    if (!lpPath)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildAltDirPath: Failed to allocate memory with %d"), GetLastError()));
        goto Exit;
    }


    //
    // Build the path
    //

    lstrcpy (lpPath, bstrContainer);

Exit:

    if (bstrContainer)
    {
        SysFreeString (bstrContainer);
    }

    if (pADsPathname)
    {
        pADsPathname->Release();
    }

    return lpPath;
}

LPTSTR CRSOPComponentData::GetDomainFromSOM (LPTSTR lpSOM)
{
    LPTSTR lpFullName, lpResult;
    LPOLESTR lpLdapDomain, lpDomainName;
    HRESULT hr;

    lpFullName = (LPTSTR) LocalAlloc (LPTR, (lstrlen(lpSOM) + 10) * sizeof(TCHAR));

    if (!lpFullName)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetDomainFromSOM: Failed to allocate memory with %d."), GetLastError()));
        return NULL;
    }

    lstrcpy (lpFullName, TEXT("LDAP://"));
    lstrcat (lpFullName, lpSOM);

    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;
    }

    lpResult = new TCHAR[lstrlen(lpDomainName) + 1];

    if (lpResult)
    {
        lstrcpy (lpResult, lpDomainName);
    }

    LocalFree (lpDomainName);

    return lpResult;
}

VOID CRSOPComponentData::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
    //

    hr = pADsPathnameSrc->Set (TEXT("LDAP"), ADS_SETTYPE_PROVIDER);

    if (FAILED(hr))
    {
        goto Exit;
    }

    hr = pADsPathnameSrc->Set (*lpString, ADS_SETTYPE_DN);

    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
    //

    lpTemp = new TCHAR [lstrlen(bstr) + 1];

    if (lpTemp)
    {
        lstrcpy (lpTemp, bstr);

        delete [] *lpString;
        *lpString = lpTemp;
    }



Exit:

    if (bstr)
    {
        SysFreeString (bstr);
    }

    if (pADsPathnameDest)
    {
        pADsPathnameDest->Release();
    }

    if (pADsPathnameSrc)
    {
        pADsPathnameSrc->Release();
    }
}

INT CALLBACK CRSOPComponentData::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) aBrowseForOUHelpIds);
    }
    else if (uMsg == DSBM_CONTEXTMENU)
    {
        WinHelp((HWND) lParam, HELP_FILE, HELP_CONTEXTMENU,
                (ULONG_PTR) (LPSTR) aBrowseForOUHelpIds);
    }

    return 0;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPGetTargetDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        {
            LPTSTR lpText, lpPath;
    
            pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
            SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
    
            if (pCD)
            {
                lpText = MyGetUserName(NameSamCompatible);
    
                if (lpText)
                {
                    SetDlgItemText (hDlg, IDC_EDIT6, lpText);
                    LocalFree (lpText);
                }
    
                lpText = MyGetUserName(NameFullyQualifiedDN);
    
                if (lpText)
                {
                    lpPath = pCD->GetDefaultSOM(lpText);
    
                    if (lpPath)
                    {
                        SetDlgItemText (hDlg, IDC_EDIT5, lpPath);
                        delete [] lpPath;
                    }
    
                    LocalFree (lpText);
                }
            }
    
            if (pCD->m_szUserNamePref) {
                CheckDlgButton (hDlg, IDC_RADIO2, BST_CHECKED);
                SetDlgItemText(hDlg, IDC_EDIT2, pCD->m_szUserNamePref);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_RADIO1), FALSE);
            }
            else if (pCD->m_szUserSOMPref) {
                CheckDlgButton (hDlg, IDC_RADIO1, BST_CHECKED);
                SetDlgItemText(hDlg, IDC_EDIT1, pCD->m_szUserSOMPref);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
            }
            else {
                CheckDlgButton (hDlg, IDC_RADIO1, BST_CHECKED);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT2), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE2), FALSE);
            }
    
    
            if (pCD->m_szComputerNamePref) {
                LPTSTR  szCompName;

                szCompName = new WCHAR[wcslen(pCD->m_szComputerNamePref)+1]; 

                if (szCompName)
                {
                    wcscpy (szCompName, pCD->m_szComputerNamePref);
                    if (wcslen(szCompName) >= 1) {
                        // this is being called from dsa. A terminating '$' will be passed in
                        szCompName[wcslen(szCompName)-1] = L'\0';
                    }
                    
                    CheckDlgButton (hDlg, IDC_RADIO4, BST_CHECKED);
                    SetDlgItemText(hDlg, IDC_EDIT4, szCompName);
                    EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
                    EnableWindow (GetDlgItem (hDlg, IDC_EDIT3), FALSE);
                    EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
                    EnableWindow (GetDlgItem (hDlg, IDC_RADIO3), FALSE);
                }
                                                   

            }
            else if (pCD->m_szComputerSOMPref) {
                CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
                SetDlgItemText(hDlg, IDC_EDIT3, pCD->m_szComputerSOMPref);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
            }
            else {
                CheckDlgButton (hDlg, IDC_RADIO3, BST_CHECKED);
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT4), FALSE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE4), FALSE);
            }
        }
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            switch (LOWORD(wParam))
            {
            case IDC_RADIO1:
                EnableWindow (GetDlgItem (hDlg, IDC_EDIT1), TRUE);
                EnableWindow (GetDlgItem (hDlg, IDC_BROWSE1), TRUE);

                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);

                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);

                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);

                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))
                    {
                        SetDlgItemText(hDlg, IDC_EDIT1, (szResult+7));
                    }
                    
                    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);
                    delete [] 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))
                    {
                        SetDlgItemText(hDlg, IDC_EDIT3, (szResult+7));
                    }

                    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);
                    delete [] sz;
                }
                }
                break;
            }
        }

        break;

    case WM_REFRESHDISPLAY:
        {
            UINT n;

            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            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);
            }
            if (pCD->m_bOverride) {
                // This is the start page if rsop.msc is launched with
                // cmd line arg for planning mode
                if (n > 0 )
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_NEXT);
                else
                    PropSheet_SetWizButtons(GetParent(hDlg), 0);
            }
            else {
                if (n > 0 )
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);
                else
                    PropSheet_SetWizButtons(GetParent(hDlg), PSWIZB_BACK);
            }
        }
        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_WIZBACK:
            SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_CHOOSEMODE);
            return TRUE;


        case PSN_SETACTIVE:
            if (pCD->m_bOverride) {
                // This is the start page if rsop.msc is launched with
                // cmd line arg for planning mode
                PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_NEXT);
            }

            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            break;

        case PSN_WIZNEXT:
            {
                HRESULT hr;
                IDirectoryObject * pUserObject = NULL;
                IDirectoryObject * pComputerObject = NULL;
                LPTSTR lpUserName = NULL, lpUserSOM = NULL;
                LPTSTR lpComputerName = NULL, lpComputerSOM = NULL;
                LPTSTR lpFullName;

                SetWaitCursor();


                //
                // Get the user and dn name
                //

                if (IsDlgButtonChecked(hDlg, IDC_RADIO1) == BST_CHECKED)
                {
                    GetControlText(hDlg, IDC_EDIT1, lpUserSOM);

                    if (lpUserSOM)
                    {
                        pCD->EscapeString (&lpUserSOM);

                        hr = pCD->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);
                    lpUserSOM = ConvertName(lpUserName);

                    if (lpUserName && !lpUserSOM)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::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;
                    }

                    pCD->EscapeString (&lpUserSOM);
                }

                if (lpUserSOM)
                {
                    lpFullName = (LPTSTR) LocalAlloc (LPTR, (lstrlen(lpUserSOM) + 10) * sizeof(TCHAR));

                    if (lpFullName)
                    {
                        lstrcpy (lpFullName, TEXT("LDAP://"));
                        lstrcat (lpFullName, lpUserSOM);

                        hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pUserObject);

                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::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);

                    if (lpComputerSOM)
                    {
                        pCD->EscapeString (&lpComputerSOM);

                        hr = pCD->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();
                            }

                            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
                            return TRUE;
                        }
                    }
                }
                else
                {
                    GetControlText(hDlg, IDC_EDIT4, lpComputerName);

                    if (lpComputerName)
                    {
                        lpFullName = new TCHAR [lstrlen(lpComputerName) + 2];

                        if (lpFullName)
                        {
                            lstrcpy (lpFullName, lpComputerName);
                            lstrcat (lpFullName, TEXT("$"));
                            lpComputerSOM = ConvertName(lpFullName);
                            delete [] lpComputerName;
                            lpComputerName = lpFullName;
                        }
                    }

                    if (lpComputerName && !lpComputerSOM)
                    {
                        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::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();
                        }

                        SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
                        return TRUE;
                    }

                    pCD->EscapeString (&lpComputerSOM);
                }

                if (lpComputerSOM)
                {
                    lpFullName = (LPTSTR) LocalAlloc (LPTR, (lstrlen(lpComputerSOM) + 10) * sizeof(TCHAR));

                    if (lpFullName)
                    {
                        lstrcpy (lpFullName, TEXT("LDAP://"));
                        lstrcat (lpFullName, lpComputerSOM);

                        hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pComputerObject);

                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::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();
                            }

                            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
                            return TRUE;
                        }

                        LocalFree (lpFullName);
                    }
                }


                //
                // Store the user information
                //

                if (pCD->m_szUserName && lpUserName && (!lstrcmpi(pCD->m_szUserName, lpUserName)))
                {
                    delete [] lpUserName;

                    if (lpUserSOM)
                    {
                        delete [] lpUserSOM;
                    }

                    if (pUserObject)
                    {
                        pUserObject->Release();
                    }
                }
                else if (!pCD->m_szUserName && !lpUserName && pCD->m_szUserSOM && lpUserSOM && (!lstrcmpi(pCD->m_szUserSOM, lpUserSOM)))
                {
                    delete [] lpUserSOM;
                    if (pUserObject)
                    {
                        pUserObject->Release();
                    }
                }
                else
                {
                    pCD->FreeUserData ();

                    if (lpUserName)
                    {
                        pCD->m_szUserName = lpUserName;
                        pCD->m_szUserDNName = lpUserSOM;
                        pCD->m_szDefaultUserSOM = pCD->GetDefaultSOM (lpUserSOM);
                    }
                    else
                    {
                        pCD->m_szUserSOM = lpUserSOM;
                    }

                    pCD->m_pUserObject = pUserObject;
                }


                //
                // Store the computer information
                //

                if (pCD->m_szComputerName && lpComputerName && (!lstrcmpi(pCD->m_szComputerName, lpComputerName)))
                {
                    delete [] lpComputerName;
                    if (lpComputerSOM)
                    {
                        delete [] lpComputerSOM;
                    }

                    if (pComputerObject)
                    {
                        pComputerObject->Release();
                    }
                }
                else if (!pCD->m_szComputerName && !lpComputerName && pCD->m_szComputerSOM && lpComputerSOM && (!lstrcmpi(pCD->m_szComputerSOM, lpComputerSOM)))
                {
                    delete [] lpComputerSOM;

                    if (pComputerObject)
                    {
                        pComputerObject->Release();
                    }
                }
                else
                {
                    pCD->FreeComputerData ();

                    if (lpComputerName)
                    {
                        pCD->m_szComputerName = lpComputerName;
                        pCD->m_szComputerDNName = lpComputerSOM;
                        pCD->m_szDefaultComputerSOM = pCD->GetDefaultSOM (lpComputerSOM);
                    }
                    else
                    {
                        pCD->m_szComputerSOM = lpComputerSOM;
                    }

                    pCD->m_pComputerObject = pComputerObject;
                }


                if (pCD->m_szDC)
                {
                    delete [] pCD->m_szDC;
                    pCD->m_szDC = NULL;
                }


                if (pCD->m_szSite)
                {
                    delete [] pCD->m_szSite;
                    pCD->m_szSite = NULL;
                }


                if ( (pCD->m_szSitePref) && (!pCD->m_szSite)) {
                    GetSiteFriendlyName(pCD->m_szSitePref, &(pCD->m_szSite));
                }


                // set m_szDC to the primary DC
                LPTSTR szDomain = NULL;

                // Determine the focused domain so we can focus on the correct
                // DC.

                if (pCD->m_szUserName)
                {
                    //
                    // try and get the user's domain
                    //

                    szDomain = ExtractDomain(pCD->m_szUserName);
                }

                if (!szDomain && pCD->m_szUserSOM)
                {
                    //
                    // try and get the user's domain from the SOM
                    //

                    szDomain = pCD->GetDomainFromSOM(pCD->m_szUserSOM);
                }

                if (!szDomain && pCD->m_szComputerName)
                {
                    //
                    // try and get the computer's domain
                    //

                    szDomain = ExtractDomain(pCD->m_szComputerName);
                }

                if (!szDomain && pCD->m_szComputerSOM)
                {
                    //
                    // try and get the computer's domain from the SOM
                    //

                    szDomain = pCD->GetDomainFromSOM(pCD->m_szComputerSOM);
                }

                if (!szDomain)
                {
                    //
                    // use the local domain
                    //
                    TCHAR szName[1024];
                    DWORD dwSize = sizeof(szName) / sizeof(szName[0]);
                    GetUserNameEx(NameSamCompatible, szName, &dwSize);
                    szDomain = ExtractDomain(szName);
                }

                LPTSTR lpDCName;

                lpDCName = GetDCName (szDomain, pCD->m_szDCPref, NULL, FALSE, 0, DS_RETURN_DNS_NAME);

                if (lpDCName)
                {
                    if (pCD->m_szDC)
                    {
                        delete [] pCD->m_szDC;
                        pCD->m_szDC = NULL;
                    }
                    pCD->m_szDC = new WCHAR [ wcslen(lpDCName) + 1];
                    if (pCD->m_szDC)
                    {
                        wcscpy(pCD->m_szDC, lpDCName);
                    }
                    LocalFree(lpDCName);
                }

                if (szDomain)
                {
                    delete [] szDomain;
                }

                ClearWaitCursor();
            }

            if (SendMessage(GetDlgItem(hDlg, IDC_BUTTON1), BM_GETCHECK, 0, 0))
            {
                if (!(pCD->IsComputerRSoPEnabled(pCD->m_szDC))) {
                    if (GetLastError() == WBEM_E_INVALID_NAMESPACE)
                    {
                        ReportError (hDlg, 0, IDS_DEFDC_DOWNLEVEL);
                    }
                    else
                    {
                        ReportError (hDlg, GetLastError(), IDS_DEFDC_CONNECTFAILED);
                    }
                    delete [] pCD->m_szDC;
                    pCD->m_szDC = NULL;
                }
                else {
                    pCD->m_dwSkippedFrom = IDD_RSOP_GETTARGET;
                    pCD->m_loopbackMode = LoopbackNone;
                    // skip to the diagnostic pages
                    SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                    return TRUE;
                }
            }

            pCD->m_dwSkippedFrom = 0;
            break;

        case PSN_WIZFINISH:
        case PSN_RESET:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

BOOL CRSOPComponentData::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;


                //
                // Test if the computer is alive
                //

                dwResult = PingComputer (inaddr, &ulSpeed);

                if (dwResult == ERROR_SUCCESS)
                {

                    //
                    // 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)
                        {
                            wsprintf (lpWMIPath, TEXT("\\\\%s\\root\\rsop"), lpName);

                            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);
                            }

                            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: PingComputer failed with %d."), dwResult));
                    SetLastError(dwResult);
                }
            }
            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;
}

INT_PTR CALLBACK CRSOPComponentData::BrowseDCDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;

    switch (message)
    {
        case WM_INITDIALOG:
        {
            pCD = (CRSOPComponentData *) lParam;
            SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
            pCD->InitializeDCInfo(hDlg);
            return TRUE;
        }

        case WM_COMMAND:

            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }

            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;
                }

                delete [] pCD->m_szDC;

                pCD->m_szDC = new TCHAR[iStrLen+1];

                if (!pCD->m_szDC)
                {
                    break;
                }

                SendDlgItemMessage (hDlg, IDC_LIST1, LB_GETTEXT, (WPARAM) iSel, (LPARAM) pCD->m_szDC);

                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) aBrowseDCHelpIds);
            break;

        case WM_CONTEXTMENU:      // right mouse click
            WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
            (ULONG_PTR) (LPSTR) aBrowseDCHelpIds);
            return (TRUE);
    }

    return FALSE;
}


VOID CRSOPComponentData::InitializeDCInfo (HWND hDlg)
{
    LPTSTR szDomain = NULL;
    TCHAR szName[1024];
    DWORD dwSize, dwError;
    INT iDefault = LB_ERR, nPDC = LB_ERR, nCount = 0;


    //
    // Determine the focused domain so we can focus on the correct
    // DC.

    if (m_szUserName)
    {
        //
        // Try and get the user's domain
        //

        szDomain = ExtractDomain(m_szUserName);
    }

    if (!szDomain && m_szComputerName)
    {
        //
        // Try and get the computer's domain
        //

        szDomain = ExtractDomain(m_szComputerName);
    }

    if (!szDomain)
    {
        //
        // Use the local domain
        //

        dwSize = ARRAYSIZE(szName);

        if (GetUserNameEx(NameSamCompatible, szName, &dwSize))
        {
            szDomain = ExtractDomain(szName);
        }
    }

    if (szDomain)
    {
        DWORD cInfo;
        INT n;
        PDS_DOMAIN_CONTROLLER_INFO_1 pInfo = NULL;
        HANDLE hDs;
        DWORD result;

        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 (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_szDC)
                    {
                        iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_LIST1), LB_FINDSTRING,
                                                (WPARAM) -1, (LPARAM) m_szDC);
                    }
                    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));
            }

            DsUnBind(&hDs);
        }
        else
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::InitializeDCInfo: DsBind to %s failed with %d."), szDomain, result));
            ReportError(hDlg, result, IDS_DSBINDFAILED);
        }

        delete [] szDomain;
    }

}


VOID CRSOPComponentData::InitializeSitesInfo (HWND hDlg)
{
    LPTSTR szDomain = NULL;
    TCHAR szName[1024];
    DWORD dwSize;
    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 which domain to use for the bind
    //

    if (m_szUserName)
    {
        //
        // Try and get the user's domain
        //

        szDomain = ExtractDomain(m_szUserName);
    }

    if (!szDomain && m_szComputerName)
    {
        //
        // Try and get the computer's domain
        //

        szDomain = ExtractDomain(m_szComputerName);
    }

    if (!szDomain)
    {
        //
        // use the local domain
        //

        dwSize = ARRAYSIZE(szName);

        if (GetUserNameEx(NameSamCompatible, szName, &dwSize))
        {
            szDomain = ExtractDomain(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_szSitePref) {

            LPWSTR szSiteFriendlyName=NULL;

            //
            // Get the friendly name
            //

            if (GetSiteFriendlyName(m_szSitePref, &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_szSitePref) {
        LoadString (g_hInstance, IDS_NONE, szName, ARRAYSIZE(szName));
    
        iIndex = (int) SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_ADDSTRING,
                                   (WPARAM) 0, (LPARAM) (LPCTSTR) szName);
    }

    //
    // Set the initial selection
    //


    if (m_szSitePref) {
        iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_COMBO1), CB_FINDSTRINGEXACT,
                                (WPARAM) -1, (LPARAM) m_szSitePref);
    }

    if (m_szSite)
    {
        iDefault = (INT) SendMessage (GetDlgItem(hDlg, IDC_COMBO1), CB_FINDSTRINGEXACT,
                                (WPARAM) -1, (LPARAM) m_szSite);
    }


    SendMessage(GetDlgItem(hDlg, IDC_COMBO1), CB_SETCURSEL,
                (WPARAM) (iDefault == CB_ERR) ? iIndex : iDefault, NULL);


    if (szDomain)
    {
        delete [] szDomain;
    }


}

INT_PTR CALLBACK CRSOPComponentData::RSOPGetDCDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData *    pCD;
    BOOL                    bEnable;

    switch (message)
    {
    case WM_INITDIALOG:
        {
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        }
        break;

    case WM_COMMAND:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (LOWORD(wParam))
        {
            case IDC_CHECK2:
                if (SendMessage (GetDlgItem(hDlg, IDC_CHECK2), BM_GETCHECK, 0, 0))
                {
                    pCD->m_loopbackMode = LoopbackReplace;
                    SendMessage (GetDlgItem(hDlg, IDC_RADIO2), BM_SETCHECK, BST_CHECKED, 0);            
                    SendMessage (GetDlgItem(hDlg, IDC_RADIO3), BM_SETCHECK, BST_UNCHECKED, 0);
                    bEnable = TRUE;
                    if (NULL == pCD->m_szUserName && NULL == pCD->m_szUserSOM)
                        bEnable = FALSE;
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), bEnable);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), bEnable);
                }
                else
                {
                    pCD->m_loopbackMode = LoopbackNone;
                    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:
                pCD->m_loopbackMode = LoopbackReplace;
                break;
            case IDC_RADIO3:
                pCD->m_loopbackMode = LoopbackMerge;
                break;
        }
        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            {
                SetWaitCursor();
                pCD->InitializeSitesInfo (hDlg);

                if ((LoopbackNone == pCD->m_loopbackMode) ||
                    (LoopbackMerge == pCD->m_loopbackMode && ((NULL == pCD->m_szUserName && NULL == pCD->m_szUserSOM) || 
                                                              (NULL == pCD->m_szComputerName && NULL == pCD->m_szComputerSOM))
                     ) ||
                    (LoopbackReplace == pCD->m_loopbackMode && NULL == pCD->m_szComputerName && NULL == pCD->m_szComputerSOM)
                    )
                {
                    pCD->m_loopbackMode = LoopbackNone;
                    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 == pCD->m_szComputerName && NULL == pCD->m_szComputerSOM)
                        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 if (LoopbackReplace == pCD->m_loopbackMode)
                {
                    bEnable = TRUE;
                    if (NULL == pCD->m_szUserName && NULL == pCD->m_szUserSOM)
                        bEnable = FALSE;
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO2), bEnable);
                    EnableWindow (GetDlgItem(hDlg, IDC_RADIO3), bEnable);
                }
                PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                ClearWaitCursor();
            }
            break;

        case PSN_WIZNEXT:

            SetWaitCursor();

            GetControlText(hDlg, IDC_COMBO1, pCD->m_szSite);

            if (pCD->m_szSite)
            {
                TCHAR szName[30];

                LoadString (g_hInstance, IDS_NONE, szName, ARRAYSIZE(szName));

                if (!lstrcmpi(pCD->m_szSite, szName))
                {
                    delete [] pCD->m_szSite;
                    pCD->m_szSite = NULL;
                }
            }

            if (SendMessage(GetDlgItem(hDlg, IDC_CHECK1), BM_GETCHECK, 0, 0))
            {
                pCD->m_bSlowLink = TRUE;
            }
            else
            {
                pCD->m_bSlowLink = FALSE;
            }

            ClearWaitCursor();

            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_GETDC;
                // skip to the diagnostic pages
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }


            if ((NULL == pCD->m_szUserName) && (NULL == pCD->m_szComputerName))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_GETDC;

                if (pCD->m_szUserSOM || LoopbackNone != pCD->m_loopbackMode)
                {
                    SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTUSERSEC);
                }
                else if (pCD->m_szComputerSOM)
                {
                    SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_ALTCOMPSEC);
                }
                else
                {
                    SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                }
                return TRUE;
            }

            pCD->m_dwSkippedFrom = 0;

            break;

        case PSN_WIZFINISH:
            // fall through

        case PSN_RESET:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

HRESULT CRSOPComponentData::TestSOM (LPTSTR lpSOM, HWND hDlg)
{
    HRESULT hr = E_OUTOFMEMORY;
    LPTSTR lpFullName;
    IDirectoryObject * pObject;
    ADS_OBJECT_INFO *pInfo;


    if (!lpSOM)
    {
        return E_INVALIDARG;
    }


    lpFullName = (LPTSTR) LocalAlloc (LPTR, (lstrlen(lpSOM) + 10) * sizeof(TCHAR));

    if (lpFullName)
    {
        lstrcpy (lpFullName, TEXT("LDAP://"));
        lstrcat (lpFullName, lpSOM);

        hr = OpenDSObject(lpFullName, IID_IDirectoryObject, (void**)&pObject);

        if (SUCCEEDED(hr))
        {
            hr = pObject->GetObjectInformation (&pInfo);

            if (SUCCEEDED(hr))
            {
                if (!lstrcmpi (pInfo->pszClassName, TEXT("user")))
                {
                    hr = E_INVALIDARG;
                    ReportError (hDlg, hr, IDS_BADUSERSOM);
                }
                else if (!lstrcmpi (pInfo->pszClassName, TEXT("computer")))
                {
                    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;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPAltDirsDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        break;

    case WM_COMMAND:
        {
            DSBROWSEINFO dsbi = {0};
            TCHAR szResult[MAX_PATH];
            TCHAR szTitle[256];
            TCHAR szCaption[256];
            dsbi.hwndOwner = hDlg;
            dsbi.pszCaption = szTitle;
            dsbi.pszTitle = szCaption;
            dsbi.cbStruct = sizeof(dsbi);
            dsbi.pszPath = szResult;
            dsbi.cchPath = ARRAYSIZE(szResult);
            dsbi.dwFlags = DSBI_ENTIREDIRECTORY;
            dsbi.pfnCallback = DsBrowseCallback;

            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            switch (LOWORD(wParam))
            {
            case IDC_BUTTON1:
                // browse for user's OU
                {
                    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))
                    {
                        SetDlgItemText(hDlg, IDC_EDIT1, (szResult+7));
                    }
                }
                break;
            case IDC_BUTTON2:
                // browse for computer's OU
                {
                    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))
                    {
                        SetDlgItemText(hDlg, IDC_EDIT2, (szResult+7));
                    }
                }
                break;

            case IDC_BUTTON3:
                if (IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT1)))
                {
                    if (pCD->m_szDefaultUserSOM)
                    {
                        SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szDefaultUserSOM);
                    }
                }

                if (IsWindowEnabled (GetDlgItem(hDlg, IDC_EDIT2)))
                {
                    if (pCD->m_szDefaultComputerSOM)
                    {
                        SetDlgItemText (hDlg, IDC_EDIT2, pCD->m_szDefaultComputerSOM);
                    }
                }
                break;
            }
        }

        break;
    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        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 (pCD->m_szUserSOM)
            {
                SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szUserSOM);
                if (!pCD->m_szUserName)
                {
                    EnableWindow(GetDlgItem(hDlg, IDC_EDIT1), FALSE);
                    EnableWindow(GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
                }
            }
            else if (pCD->m_szDefaultUserSOM)
            {
                SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szDefaultUserSOM);
            }
            else if (!pCD->m_szUserName)
            {
                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 (pCD->m_szComputerSOM)
            {
                SetDlgItemText (hDlg, IDC_EDIT2, pCD->m_szComputerSOM);
                if (!pCD->m_szComputerName)
                {
                    EnableWindow(GetDlgItem(hDlg, IDC_EDIT2), FALSE);
                    EnableWindow(GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
                }
            }
            else if (pCD->m_szDefaultComputerSOM)
            {
                SetDlgItemText (hDlg, IDC_EDIT2, pCD->m_szDefaultComputerSOM);
            }
            else if (!pCD->m_szComputerName)
            {
                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_WIZNEXT:
            {
            LPTSTR lpUserSOM = NULL, lpComputerSOM = NULL;
            HRESULT hr;


            GetControlText(hDlg, IDC_EDIT1, lpUserSOM);
            GetControlText(hDlg, IDC_EDIT2, lpComputerSOM);

            if (lpUserSOM)
            {
                hr = pCD->TestSOM (lpUserSOM, hDlg);

                if (FAILED(hr))
                {
                    if (hr != E_INVALIDARG)
                    {
                        ReportError (hDlg, hr, IDS_NOUSERCONTAINER);
                    }

                    if (lpUserSOM)
                    {
                        delete [] lpUserSOM;
                    }

                    if (lpComputerSOM)
                    {
                        delete [] lpComputerSOM;
                    }

                    SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
                    return TRUE;
                }
            }

            if (lpComputerSOM)
            {
                hr = pCD->TestSOM (lpComputerSOM, hDlg);

                if (FAILED(hr))
                {
                    if (hr != E_INVALIDARG)
                    {
                        ReportError (hDlg, hr, IDS_NOCOMPUTERCONTAINER);
                    }

                    if (lpUserSOM)
                    {
                        delete [] lpUserSOM;
                    }

                    if (lpComputerSOM)
                    {
                        delete [] lpComputerSOM;
                    }

                    SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID_NOCHANGEPAGE);
                    return TRUE;
                }
            }

            pCD->m_szUserSOM = lpUserSOM;
            pCD->m_szComputerSOM = lpComputerSOM;


            if (pCD->m_szDefaultUserSOM && pCD->m_szUserSOM)
            {
                if (!lstrcmpi(pCD->m_szDefaultUserSOM, pCD->m_szUserSOM))
                {
                    delete [] pCD->m_szUserSOM;
                    pCD->m_szUserSOM = NULL;
                }
            }

            if (pCD->m_szDefaultComputerSOM && pCD->m_szComputerSOM)
            {
                if (!lstrcmpi(pCD->m_szDefaultComputerSOM, pCD->m_szComputerSOM))
                {
                    delete [] pCD->m_szComputerSOM;
                    pCD->m_szComputerSOM = NULL;
                }
            }

            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTDIRS;
                // skip to the diagnostic pages
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }

            if ((NULL == pCD->m_szUserName) && (NULL == pCD->m_szUserSOM))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTDIRS;

                if (pCD->m_szComputerName || pCD->m_szComputerSOM)
                {
                    if (LoopbackNone == pCD->m_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, IDD_RSOP_FINISHED3);
                }
                return TRUE;
            }

            pCD->m_dwSkippedFrom = 0;
            }
            break;

        case PSN_WIZFINISH:
            // fall through

        case PSN_RESET:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

VOID CRSOPComponentData::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[50];
    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);
    }

}

VOID CRSOPComponentData::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;
    LPBYTE pObjSID = NULL;
    UCHAR * psaCount, iIndex;
    PSID pSID = NULL;
    PSID_IDENTIFIER_AUTHORITY psia;
    DWORD rgRid[8];
    TCHAR szName[200];
    TCHAR szDomain[300];
    TCHAR szFullName[501];
    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))
    {
        wsprintf (szFullName, TEXT("%s\\%s"), szDomain, szName);
        SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) szFullName);
    }
    else
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetPrimaryGroup: LookupAccountSid failed with %d"), GetLastError()));
    }

    FreeSid (pSID);

Exit:
    FreeADsMem (spAttrs);

    if (pObjSID)
    {
        delete [] pObjSID;
    }

}

HRESULT CRSOPComponentData::BuildMembershipList (HWND hLB, IDirectoryObject * pDSObj, SAFEARRAY **psaSecGrp, DWORD ** pdwSecGrpAttr)
{
    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;

    SetWaitCursor();
    SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
    SendMessage (hLB, LB_RESETCONTENT, 0, 0);


    AddDefaultGroups (hLB);
    if (!pDSObj)
        goto BuildMembershipListEnd;

    GetPrimaryGroup (hLB, pDSObj);

    //
    // 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)
                    {
                        lstrcpy (lpFullName, TEXT("LDAP://"));
                        lstrcat (lpFullName, spAttrs->pADsValues[i].CaseIgnoreString);

                        hr = OpenDSObject(lpFullName, IID_IADs, (void**)&pGroup);

                        if (SUCCEEDED(hr))
                        {
                            if (SUCCEEDED(pGroup->Get(TEXT("groupType"), &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.
                        wsprintfW(wzMembershipAttr, wzFormat, lEnd);
                        DebugMsg((DM_VERBOSE, TEXT("Range returned is %s, now asking for %s"),
                                 spAttrs->pszAttrName, wzMembershipAttr));
                    }
                }
            }

            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, psaSecGrp, pdwSecGrpAttr);

    ClearWaitCursor();

    return S_OK;
}

HRESULT CRSOPComponentData::SaveSecurityGroups (HWND hLB, SAFEARRAY **psaSecGrp, DWORD **pdwSecGrpAttr)
{
    SAFEARRAY * psa;
    SAFEARRAYBOUND rgsabound[1];
    LONG i, lCount = (LONG) SendMessage (hLB, LB_GETCOUNT, 0, 0);
    DWORD dwLen;
    LPTSTR lpText;
    BSTR bstrText;
    HRESULT hr;


    rgsabound[0].lLbound = 0;
    rgsabound[0].cElements = lCount;

    *pdwSecGrpAttr = (DWORD *)LocalAlloc(LPTR, sizeof(DWORD)*lCount);


    psa = SafeArrayCreate (VT_BSTR, 1, rgsabound);

    if ((!psa) || (!(*pdwSecGrpAttr)))
    {
        return E_OUTOFMEMORY;
    }

    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));

            if (lpText)
            {
                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
                        (*pdwSecGrpAttr)[i] = 1;
                    }

                    bstrText = SysAllocString (lpText);
                    if (bstrText)
                    {
                        hr = SafeArrayPutElement(psa, &i, bstrText);

                        if (FAILED(hr))
                        {
                            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::SaveSecurityGroups: SafeArrayPutElement failed with 0x%x."), hr));
                        }
                    }
                }
                LocalFree (lpText);
            }
        }
    }

    *psaSecGrp = psa;

    return S_OK;
}

VOID CRSOPComponentData::FillListFromSafeArraySecurityGroup (HWND hLB, SAFEARRAY * psa, DWORD * pdwSecGrpAttr)
{
    LONG lIndex, lMax;
    LPTSTR lpText;

    SetWaitCursor();
    SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
    SendMessage (hLB, LB_RESETCONTENT, 0, 0);

    if (psa)
    {
        if (SUCCEEDED(SafeArrayGetUBound (psa, 1, &lMax)))
        {
            for (lIndex = 0; lIndex <= lMax; lIndex++)
            {
                if (SUCCEEDED(SafeArrayGetElement(psa, &lIndex, &lpText)))
                {
                    BOOL bDollarRemoved = FALSE;

                    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 (pdwSecGrpAttr[lIndex] & 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();
}

BOOL CRSOPComponentData::CompareSafeArrays(SAFEARRAY *psa1, SAFEARRAY *psa2)
{
    LONG lIndex1, lMax1;
    LONG lIndex2, lMax2;
    LPTSTR lpText1;
    LPTSTR lpText2;
    BOOL bFound;


    //
    // Null ptr checks
    //

    if (!psa1 && !psa2)
    {
        return TRUE;
    }

    if (!psa1 && psa2)
    {
        return FALSE;
    }

    if (psa1 && !psa2)
    {
        return FALSE;
    }


    //
    // Get the array sizes
    //

    if (FAILED(SafeArrayGetUBound (psa1, 1, &lMax1)))
    {
        return FALSE;
    }

    if (FAILED(SafeArrayGetUBound (psa2, 1, &lMax2)))
    {
        return FALSE;
    }


    //
    // Check if the same number of entries are in the arrays
    //

    if (lMax1 != lMax2)
    {
        return FALSE;
    }


    //
    // Loop through comparing item by item
    //

    for (lIndex1 = 0; lIndex1 <= lMax1; lIndex1++)
    {
        if (FAILED(SafeArrayGetElement(psa1, &lIndex1, &lpText1)))
        {
            return FALSE;
        }

        bFound = FALSE;

        for (lIndex2 = 0; lIndex2 <= lMax2; lIndex2++)
        {
            if (FAILED(SafeArrayGetElement(psa2, &lIndex2, &lpText2)))
            {
                return FALSE;
            }

            if (!lstrcmpi(lpText1, lpText2))
            {
                bFound = TRUE;
            }
        }

        if (!bFound)
        {
            return FALSE;
        }
    }

    return TRUE;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPAltUserSecDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            switch (LOWORD(wParam))
            {
            case IDC_BUTTON1:
                {
                TCHAR * sz;

                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);

                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 (pCD->m_saUserSecurityGroups)
                {
                    SafeArrayDestroy (pCD->m_saUserSecurityGroups);
                    pCD->m_saUserSecurityGroups = NULL;
                }

                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultUserSecurityGroups, pCD->m_saDefaultUserSecurityGroupsAttr);

                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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);

            if (pCD->m_saUserSecurityGroups)
            {
                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saUserSecurityGroups, pCD->m_saUserSecurityGroupsAttr);
            }
            else if (pCD->m_saDefaultUserSecurityGroups)
            {
                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultUserSecurityGroups, pCD->m_saDefaultUserSecurityGroupsAttr);
            }
            else
            {
                pCD->BuildMembershipList (GetDlgItem(hDlg, IDC_LIST1), pCD->m_pUserObject, &(pCD->m_saDefaultUserSecurityGroups), &(pCD->m_saDefaultUserSecurityGroupsAttr));
            }

            EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);

            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            break;

        case PSN_WIZNEXT:

            //
            // Free the previous list of security groups
            //
            if (pCD->m_saUserSecurityGroups)
            {
                SafeArrayDestroy (pCD->m_saUserSecurityGroups);
            }


            if (pCD->m_saUserSecurityGroupsAttr) {
                LocalFree(pCD->m_saUserSecurityGroupsAttr);
            }

            //
            // Save the current list
            //

            pCD->SaveSecurityGroups (GetDlgItem(hDlg, IDC_LIST1), &(pCD->m_saUserSecurityGroups), &(pCD->m_saUserSecurityGroupsAttr));


            //
            // 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 (pCD->CompareSafeArrays(pCD->m_saUserSecurityGroups, pCD->m_saDefaultUserSecurityGroups))
            {
                if (pCD->m_saUserSecurityGroups)
                {
                    SafeArrayDestroy (pCD->m_saUserSecurityGroups);
                    pCD->m_saUserSecurityGroups = NULL;
                }
            }

            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTUSERSEC;
                // skip to the diagnostic pages
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }

            if ((NULL == pCD->m_szComputerName) && (NULL == pCD->m_szComputerSOM))
            {
                // skip to the finish page
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTUSERSEC;
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLUSER);
                return TRUE;
            }

            pCD->m_dwSkippedFrom = 0;

            break;

        case PSN_WIZBACK:
            
            //
            // Free the previous list of security groups
            //
            if (pCD->m_saUserSecurityGroups)
            {
                SafeArrayDestroy (pCD->m_saUserSecurityGroups);
            }

            if (pCD->m_saUserSecurityGroupsAttr) {
                LocalFree(pCD->m_saUserSecurityGroupsAttr);
            }

            //
            // Save the current list
            //

            pCD->SaveSecurityGroups (GetDlgItem(hDlg, IDC_LIST1), &(pCD->m_saUserSecurityGroups), &(pCD->m_saUserSecurityGroupsAttr));


            if (!pCD->m_szUserName && !pCD->m_szComputerName)
            {
                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 CRSOPComponentData::RSOPAltCompSecDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            switch (LOWORD(wParam))
            {
            case IDC_BUTTON1:
                {
                TCHAR * sz;

                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);

                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 (pCD->m_saComputerSecurityGroups)
                {
                    SafeArrayDestroy (pCD->m_saComputerSecurityGroups);
                    pCD->m_saComputerSecurityGroups = NULL;
                }

                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultComputerSecurityGroups, pCD->m_saDefaultComputerSecurityGroupsAttr);

                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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);

            if (pCD->m_saComputerSecurityGroups)
            {
                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saComputerSecurityGroups, pCD->m_saComputerSecurityGroupsAttr);
            }
            else if (pCD->m_saDefaultComputerSecurityGroups)
            {
                pCD->FillListFromSafeArraySecurityGroup(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultComputerSecurityGroups, pCD->m_saDefaultComputerSecurityGroupsAttr);
            }
            else
            {
                pCD->BuildMembershipList (GetDlgItem(hDlg, IDC_LIST1), pCD->m_pComputerObject, &(pCD->m_saDefaultComputerSecurityGroups), &(pCD->m_saDefaultComputerSecurityGroupsAttr));
            }

            EnableWindow (GetDlgItem(hDlg, IDC_BUTTON3), FALSE);


            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            break;

        case PSN_WIZNEXT:

            //
            // Free the previous list of security groups
            //
            if (pCD->m_saComputerSecurityGroups)
            {
                SafeArrayDestroy (pCD->m_saComputerSecurityGroups);
            }

            if (pCD->m_saComputerSecurityGroupsAttr)
            {
                LocalFree (pCD->m_saComputerSecurityGroupsAttr);
            }

            //
            // Save the current list
            //

            pCD->SaveSecurityGroups (GetDlgItem(hDlg, IDC_LIST1), &(pCD->m_saComputerSecurityGroups), &(pCD->m_saComputerSecurityGroupsAttr));


            //
            // 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 (pCD->CompareSafeArrays(pCD->m_saComputerSecurityGroups, pCD->m_saDefaultComputerSecurityGroups))
            {
                if (pCD->m_saComputerSecurityGroups)
                {
                    SafeArrayDestroy (pCD->m_saComputerSecurityGroups);
                    pCD->m_saComputerSecurityGroups = NULL;
                }
            }


            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTCOMPSEC;
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }

            if ((NULL == pCD->m_szUserName) && (NULL == pCD->m_szUserSOM) && (LoopbackNone == pCD->m_loopbackMode))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_ALTCOMPSEC;
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLCOMP);
                return TRUE;
            }

            pCD->m_dwSkippedFrom = 0;

            break;

        case PSN_WIZBACK:
            
            //
            // Free the previous list of security groups
            //
            if (pCD->m_saComputerSecurityGroups)
            {
                SafeArrayDestroy (pCD->m_saComputerSecurityGroups);
            }


            if (pCD->m_saComputerSecurityGroupsAttr)
            {
                LocalFree (pCD->m_saComputerSecurityGroupsAttr);
            }

            //
            // Save the current list
            //

            pCD->SaveSecurityGroups (GetDlgItem(hDlg, IDC_LIST1), &(pCD->m_saComputerSecurityGroups), &(pCD->m_saComputerSecurityGroupsAttr));

            if (!pCD->m_szUserName && !pCD->m_szUserSOM)
            {
                if (pCD->m_szComputerName)
                {
                    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;
}

HRESULT CRSOPComponentData::ExtractWQLFilters (LPTSTR lpNameSpace, SAFEARRAY **psaNamesArg, SAFEARRAY **psaDataArg)
{
    HRESULT hr;
    ULONG n;
    IWbemClassObject * pObjGPO = NULL;
    IEnumWbemClassObject * pEnum = NULL;
    BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
    BSTR strQuery = SysAllocString(TEXT("SELECT * FROM RSOP_GPO"));
    BSTR bstrFilterId = NULL;
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    LPTSTR lpDisplayName;
    INT iIndex;
    SAFEARRAY * psaNames, *psaData;
    SAFEARRAYBOUND rgsabound[1];
    BSTR    *pWQLFilterIds, bstrText;
    LONG   lCount=0, lCountAllocated = 0, l=0;

    psaNames = psaData = NULL;
    pWQLFilterIds = NULL;

    //
    // Get a locator instance
    //

    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *)&pLocator);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: CoCreateInstance failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Connect to the namespace
    //

    hr = pLocator->ConnectServer(lpNameSpace,
                                 NULL,
                                 NULL,
                                 NULL,
                                 0,
                                 NULL,
                                 NULL,
                                 &pNamespace);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: ConnectServer failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Query for the RSOP_GPO instances
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
                               NULL,
                               &pEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: ExecQuery failed with 0x%x"), hr));
        goto cleanup;
    }


    // allocate mem. 10 should be enough for most cases

    pWQLFilterIds = (BSTR *)LocalAlloc(LPTR, sizeof(BSTR)*(lCountAllocated+10));

    if (!pWQLFilterIds) {
        hr = HRESULT_FROM_WIN32(GetLastError());
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: LocalAlloc failed with 0x%x"), hr));
        goto cleanup;
    }
    

    lCountAllocated += 10;


    //
    // Loop through the results
    //

    while (TRUE)
    {

        //
        // Get one instance of RSOP_GPO
        //

        hr = pEnum->Next(WBEM_INFINITE, 1, &pObjGPO, &n);

        if (FAILED(hr) || (n == 0))
        {
            hr = S_OK;
            break;
        }


        //
        // Allocate more memory if necessary
        //

        if (lCount == lCountAllocated) {
            BSTR *pNewWQLFilterIds = (BSTR *)LocalAlloc(LPTR, sizeof(BSTR)*(lCountAllocated+10));

            if (!pNewWQLFilterIds) {
                hr = HRESULT_FROM_WIN32(GetLastError());
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: LocalAlloc failed with 0x%x"), hr));
                goto cleanup;
            }


            lCountAllocated += 10;

            for (l=0; l < lCount; l++) {
                pNewWQLFilterIds[l] = pWQLFilterIds[l];    
            }

            LocalFree(pWQLFilterIds);
            pWQLFilterIds = pNewWQLFilterIds;

        }

        //
        // Get the filter id
        //

        pWQLFilterIds[lCount] = NULL;
        hr = GetParameterBSTR(pObjGPO, TEXT("filterId"), pWQLFilterIds[lCount]);

        if (FAILED(hr))
        {
            goto LoopAgain;
        }

        if (!pWQLFilterIds[lCount] || !(*pWQLFilterIds[lCount]) || (*pWQLFilterIds[lCount] == TEXT(' ')))
        {
            if (pWQLFilterIds[lCount]) {
                SysFreeString(pWQLFilterIds[lCount]);
            }
            goto LoopAgain;
        }


#ifdef DBG
        BSTR bstrGPOName;

        bstrGPOName = NULL;
        hr = GetParameterBSTR(pObjGPO, TEXT("name"), bstrGPOName);

        if ( (SUCCEEDED(hr)) && (bstrGPOName) )
        {
            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::ExtractWQLFilters: Found filter on GPO <%s>"), bstrGPOName));
            SysFreeString (bstrGPOName);
            bstrGPOName = NULL;
        }

        hr = S_OK;
#endif

        //
        // eliminate duplicates
        //

        for (l=0; l < lCount; l++) {
            if (lstrcmpi(pWQLFilterIds[lCount], pWQLFilterIds[l]) == 0) {
                break;
            }
        }

        if ((lCount != 0) && (l != lCount)) {
            DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::ExtractWQLFilters: filter = <%s> is a duplicate"), pWQLFilterIds[lCount]));
            SysFreeString(pWQLFilterIds[lCount]);
            goto LoopAgain;
        }

        DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::ExtractWQLFilters: filter = <%s>"), pWQLFilterIds[lCount]));


        lCount++;

LoopAgain:

        pObjGPO->Release();
        pObjGPO = NULL;

    }

    //
    // Now allocate safe arrays. 
    // Notice that safe array is always allocated even if there are zero filters
    //

    rgsabound[0].lLbound = 0;
    rgsabound[0].cElements = lCount;

    psaNames = SafeArrayCreate (VT_BSTR, 1, rgsabound);

    if (!psaNames)
    {
        hr = E_FAIL;
        goto cleanup;
    }

    psaData = SafeArrayCreate (VT_BSTR, 1, rgsabound);

    if (!psaData)
    {
        SafeArrayDestroy (psaNames);
        hr = E_FAIL;
        goto cleanup;
    }
    for (l = 0; l < lCount; l++) {
        hr = SafeArrayPutElement(psaData, &l, pWQLFilterIds[l]);

        if (SUCCEEDED(hr))
        {
            //
            // Get the filter's friendly display name
            //

            lpDisplayName = GetWMIFilterDisplayName (NULL, pWQLFilterIds[l], FALSE, TRUE);

            if (!lpDisplayName)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: Failed to get display name for filter id:  %s"), pWQLFilterIds[l]));
                bstrText = SysAllocString(pWQLFilterIds[l]);
            }
            else {
                bstrText = SysAllocString(lpDisplayName);
                delete lpDisplayName;
            }

            if (!bstrText) {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: Failed to Allocate memory for displayname")));
                hr = E_FAIL;
                goto cleanup;
            }

            hr = SafeArrayPutElement(psaNames, &l, bstrText);

            SysFreeString(bstrText);

            if (FAILED(hr)) {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::ExtractWQLFilters: Failed to get display name for filter id:  %s"), pWQLFilterIds[l]));
                goto cleanup;
            }
        }
    }

    *psaNamesArg = psaNames;
    *psaDataArg = psaData;

    psaNames = NULL;
    psaData = NULL;

cleanup:

    if (bstrFilterId)
    {
        SysFreeString (bstrFilterId);
    }

    if (pObjGPO)
    {
        pObjGPO->Release();
    }

    if (pEnum)
    {
        pEnum->Release();
    }

    if (pNamespace)
    {
        pNamespace->Release();
    }

    if (pLocator)
    {
        pLocator->Release();
    }

    if (pWQLFilterIds) {
        for (l=0; l < lCount; l++) {
            if (pWQLFilterIds[l])
                SysFreeString(pWQLFilterIds[l]);
        }

        LocalFree(pWQLFilterIds);
    }

    if (psaNames) {
        SafeArrayDestroy(psaNames);
    }

    if (psaData) {
        SafeArrayDestroy(psaData);
    }

    SysFreeString(strQueryLanguage);
    SysFreeString(strQuery);

    return hr;
}

VOID CRSOPComponentData::BuildWQLFilterList (HWND hDlg, BOOL bUser, SAFEARRAY **psaNames, SAFEARRAY **psaData)
{
    HRESULT hr;
    LPTSTR lpNameSpace, 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 = GenerateRSOPData (NULL, &lpNameSpace, TRUE, TRUE, bUser, FALSE, &ulErrorInfo);

    SendMessage (hLB, LB_RESETCONTENT, 0, 0);

    if (FAILED (hr))
    {
        ReportError (hDlg, hr, IDS_EXECFAILED);
        goto Exit;
    }


    lpFullNameSpace = (LPTSTR) LocalAlloc (LPTR, (lstrlen(lpNameSpace) + 20) * sizeof(TCHAR));

    if (lpFullNameSpace)
    {
        lstrcpy (lpFullNameSpace, lpNameSpace);
        lpEnd = CheckSlash(lpFullNameSpace);

        if (bUser)
        {
            lstrcpy (lpEnd, TEXT("User"));
        }
        else
        {
            lstrcpy (lpEnd, TEXT("Computer"));
        }


        if (SUCCEEDED(ExtractWQLFilters (lpFullNameSpace, psaNames, psaData)))
        {
            FillListFromSafeArrays (hLB, *psaNames, *psaData);
        }

        LocalFree (lpFullNameSpace);
    }


    DeleteRSOPData (lpNameSpace);

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();
}

VOID CRSOPComponentData::FillListFromSafeArrays (HWND hLB, SAFEARRAY * psaNames, SAFEARRAY * psaData)
{
    LONG lIndex, lMax;
    INT iIndex;
    LPTSTR lpText;

    SetWaitCursor();
    SendMessage (hLB, WM_SETREDRAW, FALSE, 0);
    SendMessage (hLB, LB_RESETCONTENT, 0, 0);

    if (psaData)
    {
        if (SUCCEEDED(SafeArrayGetUBound (psaData, 1, &lMax)))
        {
            for (lIndex = 0; lIndex <= lMax; lIndex++)
            {
                if (SUCCEEDED(SafeArrayGetElement(psaNames, &lIndex, &lpText)))
                {
                    iIndex = (INT) SendMessage (hLB, LB_ADDSTRING, 0, (LPARAM) lpText);
                    DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::FillListFromSafeArrays: Added WQL filter %s"), lpText));

                    if (iIndex != LB_ERR)
                    {
                        if (SUCCEEDED(SafeArrayGetElement(psaData, &lIndex, &lpText)))
                        {
                            SendMessage (hLB, LB_SETITEMDATA, (WPARAM) iIndex, (LPARAM) lpText);
                        }
                    }
                }
            }
        }
    }

    SendMessage (hLB, LB_SETCURSEL, 0, 0);
    SendMessage (hLB, WM_SETREDRAW, TRUE, 0);
    UpdateWindow (hLB);
    ClearWaitCursor();
}


VOID CRSOPComponentData::SaveWQLFilters (HWND hLB, SAFEARRAY **psaNamesArg, SAFEARRAY **psaDataArg)
{
    SAFEARRAY * psaNames, *psaData;
    SAFEARRAYBOUND rgsabound[1];
    LONG i, lLength, lCount = (LONG) SendMessage (hLB, LB_GETCOUNT, 0, 0);
    LPTSTR lpText, lpName;
    BSTR bstrText;
    HRESULT hr;


    rgsabound[0].lLbound = 0;
    rgsabound[0].cElements = lCount;

    psaNames = SafeArrayCreate (VT_BSTR, 1, rgsabound);

    if (!psaNames)
    {
        return;
    }

    psaData = SafeArrayCreate (VT_BSTR, 1, rgsabound);

    if (!psaData)
    {
        SafeArrayDestroy (psaNames);
        return;
    }

    for (i = 0; i < lCount; i++)
    {
        lLength = (LONG) SendMessage (hLB, LB_GETTEXTLEN, (WPARAM) i, 0);

        lpName = new TCHAR [lLength + 1];

        if (lpName)
        {
            if (SendMessage (hLB, LB_GETTEXT, (WPARAM) i, (LPARAM) lpName) != LB_ERR)
            {
                bstrText = SysAllocString (lpName);

                if (bstrText)
                {
                    hr = SafeArrayPutElement(psaNames, &i, bstrText);

                    if (SUCCEEDED(hr))
                    {
                        lpText = (LPTSTR) SendMessage (hLB, LB_GETITEMDATA, (WPARAM) i, 0);

                        if (lpText)
                        {
                            bstrText = SysAllocString (lpText);
                            if (bstrText)
                            {
                                hr = SafeArrayPutElement(psaData, &i, bstrText);

                                if (FAILED(hr))
                                {
                                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::SaveWQLFilters: SafeArrayPutElement failed with 0x%x."), hr));
                                }
                            }
                        }
                    }
                }
            }

            delete [] lpName;
        }
    }

    *psaNamesArg = psaNames;
    *psaDataArg = psaData;
}


INT_PTR CALLBACK CRSOPComponentData::RSOPWQLUserDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;
    
    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            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 (pCD->m_saUserWQLFilters)
                {
                    SafeArrayDestroy (pCD->m_saUserWQLFilters);
                    pCD->m_saUserWQLFilters = NULL;
                }

                if (pCD->m_saUserWQLFilterNames)
                {
                    SafeArrayDestroy (pCD->m_saUserWQLFilterNames);
                    pCD->m_saUserWQLFilterNames = NULL;
                }

                pCD->m_bSkipUserWQLFilter = FALSE;

                if (pCD->m_saDefaultUserWQLFilters) {
                    pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultUserWQLFilterNames, pCD->m_saDefaultUserWQLFilters);
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                else {
                    PostMessage (hDlg, WM_BUILDWQLLIST, 0, 0);
                }
                
                }
                break;
            
            case IDC_RADIO2:
                {
                    if (pCD->m_saUserWQLFilters)
                    {
                        SafeArrayDestroy (pCD->m_saUserWQLFilters);
                        pCD->m_saUserWQLFilters = NULL;
                    }

                    if (pCD->m_saUserWQLFilterNames)
                    {
                        SafeArrayDestroy (pCD->m_saUserWQLFilterNames);
                        pCD->m_saUserWQLFilterNames = NULL;
                    }

                    pCD->m_bSkipUserWQLFilter = TRUE;
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                break;
            
            case IDC_RADIO3:
                {
                    pCD->m_bSkipUserWQLFilter = FALSE;
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                break;
            }
        }

        break;

    case WM_BUILDWQLLIST:
        {

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        pCD->BuildWQLFilterList (hDlg, TRUE, &pCD->m_saDefaultUserWQLFilterNames, &pCD->m_saDefaultUserWQLFilters);
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        }
        break;

    case WM_REFRESHDISPLAY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD->m_bSkipUserWQLFilter) {
            // set the listbox to null
            pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), 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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);

            if (!(pCD->m_bSkipUserWQLFilter)) {
                pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saUserWQLFilterNames, pCD->m_saUserWQLFilters);
            }

            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);

            break;

        case PSN_WIZNEXT:

            //
            // Free the previous list of WQL Filters
            //

            if (pCD->m_saUserWQLFilters)
            {
                SafeArrayDestroy (pCD->m_saUserWQLFilters);
                pCD->m_saUserWQLFilters = NULL;
            }

            if (pCD->m_saUserWQLFilterNames)
            {
                SafeArrayDestroy (pCD->m_saUserWQLFilterNames);
                pCD->m_saUserWQLFilterNames = NULL;
            }


            //
            // Save the current list
            //

            if (!pCD->m_bSkipUserWQLFilter) {
                pCD->SaveWQLFilters (GetDlgItem(hDlg, IDC_LIST1), &pCD->m_saUserWQLFilterNames,
                                     &pCD->m_saUserWQLFilters);
            }


            //
            // Move to the next page
            //

            if (SendMessage(GetDlgItem(hDlg, IDC_RADIO1), BM_GETCHECK, 0, 0))
            {
                pCD->m_dwSkippedFrom = IDD_RSOP_WQLUSER;
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }

            if ((NULL == pCD->m_szComputerName) && (NULL == pCD->m_szComputerSOM))
            {
                // skip to the finish page
                pCD->m_dwSkippedFrom = IDD_RSOP_WQLUSER;
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
                return TRUE;
            }

            pCD->m_dwSkippedFrom = 0;

            break;

        case PSN_WIZBACK:
            if (!pCD->m_szComputerName && !pCD->m_szComputerSOM)
            {
                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 CRSOPComponentData::RSOPWQLCompDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (!pCD)
            {
                break;
            }
            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 (pCD->m_saComputerWQLFilters)
                {
                    SafeArrayDestroy (pCD->m_saComputerWQLFilters);
                    pCD->m_saComputerWQLFilters = NULL;
                }

                if (pCD->m_saComputerWQLFilterNames)
                {
                    SafeArrayDestroy (pCD->m_saComputerWQLFilterNames);
                    pCD->m_saComputerWQLFilterNames = NULL;
                }

                pCD->m_bSkipComputerWQLFilter = FALSE;

                if (pCD->m_saDefaultComputerWQLFilters) {
                    pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saDefaultComputerWQLFilterNames, pCD->m_saDefaultComputerWQLFilters);
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                else {
                    PostMessage (hDlg, WM_BUILDWQLLIST, 0, 0);
                }
                
                }
                break;

            case IDC_RADIO2:
                {
                    if (pCD->m_saComputerWQLFilters)
                    {
                        SafeArrayDestroy (pCD->m_saComputerWQLFilters);
                        pCD->m_saComputerWQLFilters = NULL;
                    }

                    if (pCD->m_saComputerWQLFilterNames)
                    {
                        SafeArrayDestroy (pCD->m_saComputerWQLFilterNames);
                        pCD->m_saComputerWQLFilterNames = NULL;
                    }

                    pCD->m_bSkipComputerWQLFilter = TRUE;
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                break;
            
            case IDC_RADIO3:
                {
                    pCD->m_bSkipComputerWQLFilter = FALSE;
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }
                break;
            }
        }

        break;

    case WM_BUILDWQLLIST:
        {

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        pCD->BuildWQLFilterList (hDlg, FALSE, &pCD->m_saDefaultComputerWQLFilterNames, &pCD->m_saDefaultComputerWQLFilters);
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        }
        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD->m_bSkipComputerWQLFilter) {
            // set the listbox to null
            CheckDlgButton (hDlg, IDC_RADIO2, BST_CHECKED);
            CheckDlgButton (hDlg, IDC_RADIO3, BST_UNCHECKED);
            pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), 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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK | PSWIZB_NEXT);
            if (!(pCD->m_bSkipComputerWQLFilter)) {
                pCD->FillListFromSafeArrays(GetDlgItem(hDlg, IDC_LIST1), pCD->m_saComputerWQLFilterNames, pCD->m_saComputerWQLFilters);
            }

            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            break;

        case PSN_WIZNEXT:

            //
            // Free the previous list of WQL Filters
            //

            if (pCD->m_saComputerWQLFilters)
            {
                SafeArrayDestroy (pCD->m_saComputerWQLFilters);
                pCD->m_saComputerWQLFilters = NULL;
            }

            if (pCD->m_saComputerWQLFilterNames)
            {
                SafeArrayDestroy (pCD->m_saComputerWQLFilterNames);
                pCD->m_saComputerWQLFilterNames = NULL;
            }


            //
            // Save the current list
            //

            if (!pCD->m_bSkipComputerWQLFilter) {
                pCD->SaveWQLFilters (GetDlgItem(hDlg, IDC_LIST1), &pCD->m_saComputerWQLFilterNames, &pCD->m_saComputerWQLFilters);
            }


            pCD->m_dwSkippedFrom = 0;

            // skip to the last page in the wizard
            SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED3);
            return TRUE;


        case PSN_WIZBACK:
            if (!pCD->m_szUserName && !pCD->m_szUserSOM)
            {
                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 CRSOPComponentData::RSOPFinishedDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:

        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        if (pCD)
        {
            pCD->InitializeResultsList (GetDlgItem (hDlg, IDC_LIST1));
        }

        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (!pCD)
        {
            break;
        }
        if (pCD->m_bDiagnostic == FALSE) 
        {
            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:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        if (pCD->m_bDiagnostic == FALSE) 
        {
            switch (LOWORD(wParam))
            {

            case IDC_BUTTON1:
                if (DialogBoxParam (g_hInstance, MAKEINTRESOURCE(IDD_RSOP_BROWSEDC), hDlg,
                                    BrowseDCDlgProc, (LPARAM) pCD))
                {
                    SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szDC);
                }
                break;

            case IDC_EDIT1:
                if (HIWORD(wParam) == EN_CHANGE)
                {
                    PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
                }

                break;
            }
    	}

        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            break;
        }

        switch (((NMHDR FAR*)lParam)->code)
        {
        case PSN_WIZBACK:
            if (pCD->m_bDiagnostic)
            {
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_GETUSER);
                return TRUE;
            }
            if (pCD->m_dwSkippedFrom)
            {
                SetWindowLong(hDlg, DWLP_MSGRESULT, pCD->m_dwSkippedFrom);
                return TRUE;
            }
            if (!pCD->m_szComputerName && !pCD->m_szComputerSOM)
            {
                SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_WQLUSER);
                return TRUE;
            }
            break;

        case PSN_SETACTIVE:
            PropSheet_SetWizButtons (GetParent(hDlg), PSWIZB_BACK | PSWIZB_NEXT);

            if (pCD->m_bDiagnostic == FALSE) 
            {
                if (pCD->m_szDC && pCD->IsComputerRSoPEnabled(pCD->m_szDC))
                {
                    SetDlgItemText (hDlg, IDC_EDIT1, pCD->m_szDC);
                }
                else
                {
                    SetDlgItemText (hDlg, IDC_EDIT1, TEXT(""));
                }
            }

            pCD->FillResultsList (GetDlgItem (hDlg, IDC_LIST1));

            break;

        case PSN_WIZNEXT:

            if (pCD->m_bDiagnostic == FALSE) 
            {
                SetWaitCursor();
                GetControlText(hDlg, IDC_EDIT1, pCD->m_szDC);

                if (!pCD->IsComputerRSoPEnabled(pCD->m_szDC))
                {
                    ClearWaitCursor();
                    ReportError(hDlg, GetLastError(), IDS_DCMISSINGRSOP);
                    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 (FAILED(pCD->InitializeRSOP(hDlg)))
            {
                PropSheet_SetWizButtons (GetParent(hDlg),PSWIZB_BACK);
                EnableWindow (GetDlgItem(GetParent(hDlg), IDCANCEL), TRUE);
                SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_INVALID);
                return TRUE;
            }

            // skip to the VERY last page in the wizard
            SetWindowLong(hDlg, DWLP_MSGRESULT, IDD_RSOP_FINISHED2);
            return TRUE;


        case PSN_RESET:
            SetWindowLongPtr (hDlg, DWLP_MSGRESULT, PSNRET_NOERROR);
            return TRUE;
        }
        break;
    }

    return FALSE;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPFinished2DlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;


    switch (message)
    {
    case WM_INITDIALOG:

        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        SendMessage(GetDlgItem(hDlg, IDC_RSOP_BIG_BOLD1),
                    WM_SETFONT, (WPARAM)pCD->m_BigBoldFont, (LPARAM)TRUE);

/*
        if (!pCD->m_hChooseBitmap)
        {
            pCD->m_hChooseBitmap = (HBITMAP) LoadImage (g_hInstance,
                                                        MAKEINTRESOURCE(IDB_WIZARD),
                                                        IMAGE_BITMAP, 0, 0,
                                                        LR_DEFAULTCOLOR);
        }

        if (pCD->m_hChooseBitmap)
        {
            SendDlgItemMessage (hDlg, IDC_BITMAP, STM_SETIMAGE,
                                IMAGE_BITMAP, (LPARAM) pCD->m_hChooseBitmap);
        }
*/
        break;

    case WM_NOTIFY:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (!pCD)
        {
            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;
        }
        break;
    }

    return FALSE;
}

void CRSOPComponentData::InitializeResultsList (HWND hLV)
{
    LV_COLUMN lvcol;
    RECT rect;
    TCHAR szTitle[50];


    SendMessage(hLV, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
                LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);

    //
    // Add the columns to the listview
    //

    GetClientRect(hLV, &rect);

    ZeroMemory(&lvcol, sizeof(lvcol));

    LoadString(g_hInstance, IDS_RSOP_DETAILS, szTitle, ARRAYSIZE(szTitle));
    lvcol.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT;
    lvcol.pszText = szTitle;
    lvcol.fmt = LVCFMT_LEFT;
    lvcol.cx = (int)(rect.right * .40);
    ListView_InsertColumn(hLV, 0, &lvcol);

    LoadString(g_hInstance, IDS_RSOP_SETTINGS, szTitle, ARRAYSIZE(szTitle));
    lvcol.cx = ((rect.right - lvcol.cx) - GetSystemMetrics(SM_CYHSCROLL));
    lvcol.pszText = szTitle;
    ListView_InsertColumn(hLV, 1, &lvcol);

}

void CRSOPComponentData::FillResultsList (HWND hLV)
{
    TCHAR szTitle[200];
    TCHAR szAccessDenied[75];
    LPTSTR lpEnd;
    LVITEM item;
    INT iIndex = 0;
    ULONG ulSize;

    ListView_DeleteAllItems (hLV);

    //
    // Mode
    //

    ZeroMemory (&item, sizeof(item));

    LoadString(g_hInstance, IDS_RSOP_FINISH_P0, szTitle, ARRAYSIZE(szTitle));

    item.mask = LVIF_TEXT;
    item.iItem = iIndex;
    item.pszText = szTitle;
    iIndex = ListView_InsertItem (hLV, &item);

    if (iIndex != -1)
    {
        if (m_bDiagnostic)
        {
            LoadString(g_hInstance, IDS_DIAGNOSTIC, szTitle, ARRAYSIZE(szTitle));
        }
        else
        {
            LoadString(g_hInstance, IDS_PLANNING, szTitle, ARRAYSIZE(szTitle));
        }

        item.mask = LVIF_TEXT;
        item.pszText = szTitle;
        item.iItem = iIndex;
        item.iSubItem = 1;
        ListView_SetItem(hLV, &item);
    }

    if (m_bDiagnostic)
    {
        //
        // User Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P1, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            item.mask = LVIF_TEXT;

            if (m_szUserDisplayName)
            {
                lstrcpyn (szTitle, m_szUserDisplayName, ARRAYSIZE(szTitle));
            }
            else
            {
                LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));
            }

            if (m_bUserDeniedAccess)
            {
                LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT) lstrlen(szAccessDenied))
                {
                    lstrcat (szTitle, szAccessDenied);
                }
            }

            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }


        //
        // Do not display user data
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P15, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            if (!m_bNoUserData)
            {
                LoadString(g_hInstance, IDS_YES, szTitle, ARRAYSIZE(szTitle));
            }
            else
            {
                LoadString(g_hInstance, IDS_NO, szTitle, ARRAYSIZE(szTitle));
            }

            item.mask = LVIF_TEXT;
            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }


        //
        // Computer Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P2, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            szTitle[0] = TEXT('\0');

            if (!lstrcmpi(m_szComputerName, TEXT(".")))
            {
                ulSize = ARRAYSIZE(szTitle);
                if (!GetComputerObjectName (NameSamCompatible, szTitle, &ulSize))
                {
                    GetComputerNameEx (ComputerNameNetBIOS, szTitle, &ulSize);
                }
            }
            else
            {
                lstrcpyn (szTitle, m_szComputerName, ARRAYSIZE(szTitle));
            }


            //
            // Remove the trailing $
            //

            lpEnd = szTitle + lstrlen(szTitle) - 1;

            if (*lpEnd == TEXT('$'))
            {
                *lpEnd =  TEXT('\0');
            }

            if (m_bComputerDeniedAccess)
            {
                LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT)lstrlen(szAccessDenied))
                {
                    lstrcat (szTitle, szAccessDenied);
                }
            }


            item.mask = LVIF_TEXT;
            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }


        //
        // Do not display computer data
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P14, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            if (!m_bNoComputerData)
            {
                LoadString(g_hInstance, IDS_YES, szTitle, ARRAYSIZE(szTitle));
            }
            else
            {
                LoadString(g_hInstance, IDS_NO, szTitle, ARRAYSIZE(szTitle));
            }

            item.mask = LVIF_TEXT;
            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }

    }
    else
    {
        //
        // User Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        if (!m_szUserName && m_szUserSOM)
        {
            LoadString(g_hInstance, IDS_RSOP_FINISH_P9, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                lstrcpyn (szTitle, m_szUserSOM, ARRAYSIZE(szTitle));

                if (m_bUserDeniedAccess)
                {
                    LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                    if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT)lstrlen(szAccessDenied))
                    {
                        lstrcat (szTitle, szAccessDenied);
                    }
                }

                item.pszText = szTitle;
                item.iItem = iIndex;
                item.iSubItem = 1;
                ListView_SetItem(hLV, &item);
            }
        }
        else
        {
            LoadString(g_hInstance, IDS_RSOP_FINISH_P1, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                if (m_szUserName)
                {
                    lstrcpyn (szTitle, m_szUserName, ARRAYSIZE(szTitle));
                }
                else
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));
                }

                if (m_bUserDeniedAccess)
                {
                    LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                    if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT)lstrlen(szAccessDenied))
                    {
                        lstrcat (szTitle, szAccessDenied);
                    }
                }

                item.pszText = szTitle;
                item.iItem = iIndex;
                item.iSubItem = 1;
                ListView_SetItem(hLV, &item);
            }
        }


        //
        // Computer Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        if (!m_szComputerName && m_szComputerSOM)
        {
            LoadString(g_hInstance, IDS_RSOP_FINISH_P10, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                lstrcpyn (szTitle, m_szComputerSOM, ARRAYSIZE(szTitle));

                if (m_bComputerDeniedAccess)
                {
                    LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                    if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT)lstrlen(szAccessDenied))
                    {
                        lstrcat (szTitle, szAccessDenied);
                    }
                }

                item.pszText = szTitle;
                item.iItem = iIndex;
                item.iSubItem = 1;
                ListView_SetItem(hLV, &item);
            }
        }
        else
        {
            LoadString(g_hInstance, IDS_RSOP_FINISH_P2, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                if (m_szComputerName)
                {
                    lstrcpyn (szTitle, m_szComputerName, ARRAYSIZE(szTitle));

                    lpEnd = szTitle + lstrlen(szTitle) - 1;

                    if (*lpEnd == TEXT('$'))
                    {
                        *lpEnd = TEXT('\0');
                    }
                }
                else
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));
                }

                if (m_bComputerDeniedAccess)
                {
                    LoadString(g_hInstance, IDS_ACCESSDENIED2, szAccessDenied, ARRAYSIZE(szAccessDenied));

                    if ((UINT)(ARRAYSIZE(szTitle) - lstrlen(szTitle)) > (UINT)lstrlen(szAccessDenied))
                    {
                        lstrcat (szTitle, szAccessDenied);
                    }
                }

                item.iItem = iIndex;
                item.iSubItem = 1;
                item.pszText = szTitle;
                ListView_SetItem(hLV, &item);
            }
        }


        //
        // Show all GPOs
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P13, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            if (m_bSlowLink)
            {
                LoadString(g_hInstance, IDS_YES, szTitle, ARRAYSIZE(szTitle));
            }
            else
            {
                LoadString(g_hInstance, IDS_NO, szTitle, ARRAYSIZE(szTitle));
            }

            item.mask = LVIF_TEXT;
            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }

        //
        // Indicate the loopback mode
        //
        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P16, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            switch (m_loopbackMode)
            {
            case LoopbackNone:
                LoadString(g_hInstance, IDS_NONE, szTitle, ARRAYSIZE(szTitle));
                break;
            case LoopbackReplace:
                LoadString(g_hInstance, IDS_LOOPBACK_REPLACE, szTitle, ARRAYSIZE(szTitle));
                break;
            case LoopbackMerge:
                LoadString(g_hInstance, IDS_LOOPBACK_MERGE, szTitle, ARRAYSIZE(szTitle));
                break;
            }

            item.mask = LVIF_TEXT;
            item.pszText = szTitle;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }

        //
        // Site Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P3, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            item.mask = LVIF_TEXT;

            if (m_szSite)
            {
                item.pszText = m_szSite;
            }
            else
            {
                LoadString(g_hInstance, IDS_NONE, szTitle, ARRAYSIZE(szTitle));
                item.pszText = szTitle;
            }

            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }


/*
        //
        // DC Name
        //

        ZeroMemory (&item, sizeof(item));
        iIndex++;

        LoadString(g_hInstance, IDS_RSOP_FINISH_P4, szTitle, ARRAYSIZE(szTitle));

        item.mask = LVIF_TEXT;
        item.iItem = iIndex;
        item.pszText = szTitle;
        iIndex = ListView_InsertItem (hLV, &item);

        if (iIndex != -1)
        {
            item.mask = LVIF_TEXT;
            item.pszText = m_szDC;
            item.iItem = iIndex;
            item.iSubItem = 1;
            ListView_SetItem(hLV, &item);
        }
*/

        //
        // Alternate User Location
        //

        if (m_szUserName)
        {
            ZeroMemory (&item, sizeof(item));
            iIndex++;

            LoadString(g_hInstance, IDS_RSOP_FINISH_P5, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                if (m_szUserSOM)
                {
                    item.pszText = m_szUserSOM;
                }
                else
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));
                    item.pszText = szTitle;
                }

                item.iItem = iIndex;
                item.iSubItem = 1;
                ListView_SetItem(hLV, &item);
            }
        }


        //
        // Alternate Computer Location
        //

        if (m_szComputerName)
        {

            ZeroMemory (&item, sizeof(item));
            iIndex++;

            LoadString(g_hInstance, IDS_RSOP_FINISH_P6, szTitle, ARRAYSIZE(szTitle));

            item.mask = LVIF_TEXT;
            item.iItem = iIndex;
            item.pszText = szTitle;
            iIndex = ListView_InsertItem (hLV, &item);

            if (iIndex != -1)
            {
                item.mask = LVIF_TEXT;

                if (m_szComputerSOM)
                {
                    item.pszText = m_szComputerSOM;
                }
                else
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));
                    item.pszText = szTitle;
                }

                item.iItem = iIndex;
                item.iSubItem = 1;
                ListView_SetItem(hLV, &item);
            }
        }


        //
        // Alternate User security groups
        //

        if (m_szUserName || m_szUserSOM || LoopbackNone != m_loopbackMode)
        {

            if (m_saUserSecurityGroups)
            {
                LONG lIndex = 0, lMax;
                LPTSTR lpText;

                if (SUCCEEDED(SafeArrayGetUBound (m_saUserSecurityGroups, 1, &lMax)))
                {

                    do {
                        if (SUCCEEDED(SafeArrayGetElement(m_saUserSecurityGroups, &lIndex, &lpText)))
                        {
                            ZeroMemory (&item, sizeof(item));
                            iIndex++;

                            item.mask = LVIF_TEXT;
                            item.iItem = iIndex;

                            if (lIndex == 0)
                            {
                                LoadString(g_hInstance, IDS_RSOP_FINISH_P7, szTitle, ARRAYSIZE(szTitle));
                                item.pszText = szTitle;
                            }
                            else
                            {
                                item.pszText = TEXT("");
                            }

                            iIndex = ListView_InsertItem (hLV, &item);

                            if (iIndex != -1)
                            {
                                LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                                item.mask = LVIF_TEXT;
                                item.pszText = lpText;
                                item.iItem = iIndex;
                                item.iSubItem = 1;
                                ListView_SetItem(hLV, &item);
                            }
                        }

                        lIndex++;

                    } while (lIndex <= (lMax + 1));
                }
            }
            else
            {
                ZeroMemory (&item, sizeof(item));
                iIndex++;

                LoadString(g_hInstance, IDS_RSOP_FINISH_P7, szTitle, ARRAYSIZE(szTitle));

                item.mask = LVIF_TEXT;
                item.iItem = iIndex;
                item.pszText = szTitle;
                iIndex = ListView_InsertItem (hLV, &item);

                if (iIndex != -1)
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                    item.mask = LVIF_TEXT;
                    item.pszText = szTitle;
                    item.iItem = iIndex;
                    item.iSubItem = 1;
                    ListView_SetItem(hLV, &item);
                }
            }
        }


        //
        // Alternate Computer security groups
        //

        if (m_szComputerName || m_szComputerSOM)
        {

            if (m_saComputerSecurityGroups)
            {
                LONG lIndex = 0, lMax;
                LPTSTR lpText;

                if (SUCCEEDED(SafeArrayGetUBound (m_saComputerSecurityGroups, 1, &lMax)))
                {

                    do {
                        if (SUCCEEDED(SafeArrayGetElement(m_saComputerSecurityGroups, &lIndex, &lpText)))
                        {
                            ZeroMemory (&item, sizeof(item));
                            iIndex++;

                            item.mask = LVIF_TEXT;
                            item.iItem = iIndex;

                            if (lIndex == 0)
                            {
                                LoadString(g_hInstance, IDS_RSOP_FINISH_P8, szTitle, ARRAYSIZE(szTitle));
                                item.pszText = szTitle;
                            }
                            else
                            {
                                item.pszText = TEXT("");
                            }

                            iIndex = ListView_InsertItem (hLV, &item);

                            if (iIndex != -1)
                            {
                                LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                                item.mask = LVIF_TEXT;

                                BOOL bDollarRemoved = FALSE;

                                if (lpText[wcslen(lpText)-1] == L'$')
                                {
                                    bDollarRemoved = TRUE;
                                    lpText[wcslen(lpText)-1] = 0;
                                }

                                item.pszText = lpText;
                                item.iItem = iIndex;
                                item.iSubItem = 1;
                                ListView_SetItem(hLV, &item);

                                if (bDollarRemoved) {
                                    lpText[wcslen(lpText)] = L'$';
                                }
                            }
                        }

                        lIndex++;

                    } while (lIndex <= (lMax + 1));
                }
            }
            else
            {
                ZeroMemory (&item, sizeof(item));
                iIndex++;

                LoadString(g_hInstance, IDS_RSOP_FINISH_P8, szTitle, ARRAYSIZE(szTitle));

                item.mask = LVIF_TEXT;
                item.iItem = iIndex;
                item.pszText = szTitle;
                iIndex = ListView_InsertItem (hLV, &item);

                if (iIndex != -1)
                {
                    LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                    item.mask = LVIF_TEXT;
                    item.pszText = szTitle;
                    item.iItem = iIndex;
                    item.iSubItem = 1;
                    ListView_SetItem(hLV, &item);
                }
            }
        }


        //
        // User WQL filters
        //

        if (m_szUserName || m_szUserSOM || LoopbackNone != m_loopbackMode)
        {
            LONG lFilterCount = 0;
            if (m_saUserWQLFilterNames)
            {
                LONG lIndex = 0, lMax = 0;
                LPTSTR lpText;

                if (SUCCEEDED(SafeArrayGetUBound (m_saUserWQLFilterNames, 1, &lMax)))
                {

                    do {
                        if (SUCCEEDED(SafeArrayGetElement(m_saUserWQLFilterNames, &lIndex, &lpText)))
                        {
                            lFilterCount++;
                            ZeroMemory (&item, sizeof(item));
                            iIndex++;

                            item.mask = LVIF_TEXT;
                            item.iItem = iIndex;

                            if (lIndex == 0)
                            {
                                LoadString(g_hInstance, IDS_RSOP_FINISH_P11, szTitle, ARRAYSIZE(szTitle));
                                item.pszText = szTitle;
                            }
                            else
                            {
                                item.pszText = TEXT("");
                            }

                            iIndex = ListView_InsertItem (hLV, &item);

                            if (iIndex != -1)
                            {
                                LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                                item.mask = LVIF_TEXT;
                                item.pszText = lpText;
                                item.iItem = iIndex;
                                item.iSubItem = 1;
                                ListView_SetItem(hLV, &item);
                            }
                        }

                        lIndex++;

                    } while (lIndex <= (lMax + 1));
                }
            }

            if ((!m_saUserWQLFilterNames) || (lFilterCount == 0))  {
                
                ZeroMemory (&item, sizeof(item));
                iIndex++;

                LoadString(g_hInstance, IDS_RSOP_FINISH_P11, szTitle, ARRAYSIZE(szTitle));

                item.mask = LVIF_TEXT;
                item.iItem = iIndex;
                item.pszText = szTitle;
                iIndex = ListView_InsertItem (hLV, &item);

                if (iIndex != -1)
                {
                    if (m_bSkipUserWQLFilter) {
                        LoadString(g_hInstance, IDS_SKIPWQLFILTER, szTitle, ARRAYSIZE(szTitle));
                    }
                    else {
                        LoadString(g_hInstance, IDS_NONESELECTED, szTitle, ARRAYSIZE(szTitle));
                    }

                    item.mask = LVIF_TEXT;
                    item.pszText = szTitle;
                    item.iItem = iIndex;
                    item.iSubItem = 1;
                    ListView_SetItem(hLV, &item);
                }
            }
        }


        //
        // Computer WQL filters
        //

        if (m_szComputerName || m_szComputerSOM)
        {
            LONG lFilterCount = 0;
            if (m_saComputerWQLFilterNames)
            {
                LONG lIndex = 0, lMax = 0;
                LPTSTR lpText;

                if (SUCCEEDED(SafeArrayGetUBound (m_saComputerWQLFilterNames, 1, &lMax)))
                {

                    do {
                        if (SUCCEEDED(SafeArrayGetElement(m_saComputerWQLFilterNames, &lIndex, &lpText)))
                        {
                            lFilterCount++;
                            ZeroMemory (&item, sizeof(item));
                            iIndex++;

                            item.mask = LVIF_TEXT;
                            item.iItem = iIndex;

                            if (lIndex == 0)
                            {
                                LoadString(g_hInstance, IDS_RSOP_FINISH_P12, szTitle, ARRAYSIZE(szTitle));
                                item.pszText = szTitle;
                            }
                            else
                            {
                                item.pszText = TEXT("");
                            }

                            iIndex = ListView_InsertItem (hLV, &item);

                            if (iIndex != -1)
                            {
                                LoadString(g_hInstance, IDS_NOTSPECIFIED, szTitle, ARRAYSIZE(szTitle));

                                item.mask = LVIF_TEXT;
                                item.pszText = lpText;
                                item.iItem = iIndex;
                                item.iSubItem = 1;
                                ListView_SetItem(hLV, &item);
                            }
                        }

                        lIndex++;

                    } while (lIndex <= (lMax + 1));
                }
            }
            

            if ((!m_saComputerWQLFilterNames) || (lFilterCount == 0))  {
                ZeroMemory (&item, sizeof(item));
                iIndex++;

                LoadString(g_hInstance, IDS_RSOP_FINISH_P12, szTitle, ARRAYSIZE(szTitle));

                item.mask = LVIF_TEXT;
                item.iItem = iIndex;
                item.pszText = szTitle;
                iIndex = ListView_InsertItem (hLV, &item);

                if (iIndex != -1)
                {
                    if (m_bSkipComputerWQLFilter) {
                        LoadString(g_hInstance, IDS_SKIPWQLFILTER, szTitle, ARRAYSIZE(szTitle));
                    }
                    else {
                        LoadString(g_hInstance, IDS_NONESELECTED, szTitle, ARRAYSIZE(szTitle));
                    }

                    item.mask = LVIF_TEXT;
                    item.pszText = szTitle;
                    item.iItem = iIndex;
                    item.iSubItem = 1;
                    ListView_SetItem(hLV, &item);
                }
            }
        }
    }
}

//
// CopyUnescapedSOM
//
// Purpose: to remove all escape sequence literals
// of the form \" from a SOM stored in WMI -- WMI
// cannot store the " character in a key field, so the 
// only way to store the " is to escape it -- this is done
// so by preceding it with the \ char.  To give back
// a friendly display to the user, we undo the escape process
//
void
CopyUnescapedSOM(
    LPTSTR lpUnescapedSOM,
    LPTSTR lpSOM )
{
    while ( *lpSOM )
    {
        //
        // If we have the escape character
        //
        if ( TEXT('\\') == *lpSOM )
        {
            //
            // Check for the " character
            //
            if ( TEXT('"') == *(lpSOM + 1) ) 
            {
                //
                // Skip the escape character if this is the " char
                //
                lpSOM++;
                
                continue;
            }
        }

        *lpUnescapedSOM++ = *lpSOM++;
    } 

    *lpUnescapedSOM = TEXT('\0');
}

BOOL CRSOPComponentData::AddGPOListNode(LPTSTR lpGPOName, LPTSTR lpDSPath, LPTSTR lpSOM,
                                        LPTSTR lpFiltering, DWORD dwVersion, BOOL bApplied,
                                        LPBYTE pSD, DWORD dwSDSize, LPGPOLISTITEM *lpList)
{
    DWORD dwSize;
    LPGPOLISTITEM lpItem, lpTemp;


    //
    // Calculate the size of the new item
    //

    dwSize = sizeof (GPOLISTITEM);

    dwSize += ((lstrlen(lpGPOName) + 1) * sizeof(TCHAR));

    if (lpDSPath)
    {
        dwSize += ((lstrlen(lpDSPath) + 1) * sizeof(TCHAR));
    }

    dwSize += ((lstrlen(lpSOM) + 1) * sizeof(TCHAR));
    dwSize += ((lstrlen(lpSOM) + 1) * sizeof(TCHAR)); // The unescaped SOM length -- it is always smaller than the actual SOM
    dwSize += ((lstrlen(lpFiltering) + 1) * sizeof(TCHAR));
    dwSize += dwSDSize + MAX_ALIGNMENT_SIZE;


    //
    // Allocate space for it
    //

    lpItem = (LPGPOLISTITEM) LocalAlloc (LPTR, dwSize);

    if (!lpItem) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::AddGPOListNode: Failed to allocate memory with %d"),
                 GetLastError()));
        return FALSE;
    }


    //
    // Fill in item
    //

    lpItem->lpGPOName = (LPTSTR)(((LPBYTE)lpItem) + sizeof(GPOLISTITEM));
    lstrcpy (lpItem->lpGPOName, lpGPOName);

    if (lpDSPath)
    {
        lpItem->lpDSPath = lpItem->lpGPOName + lstrlen (lpItem->lpGPOName) + 1;
        lstrcpy (lpItem->lpDSPath, lpDSPath);

        lpItem->lpSOM = lpItem->lpDSPath + lstrlen (lpItem->lpDSPath) + 1;
        lstrcpy (lpItem->lpSOM, lpSOM);
    }
    else
    {
        lpItem->lpSOM = lpItem->lpGPOName + lstrlen (lpItem->lpGPOName) + 1;
        lstrcpy (lpItem->lpSOM, lpSOM);
    }

    //
    // Note that the DS SOM's may contain characters such as '"' that 
    // must be escaped with a "\" in WMI -- thus the SOM name will contain
    // '\' escape chars that are not actually present in the real SOM name,
    // so we call a function that removes them
    //
    lpItem->lpUnescapedSOM = lpItem->lpSOM + lstrlen (lpItem->lpSOM) + 1;        
    CopyUnescapedSOM( lpItem->lpUnescapedSOM, lpItem->lpSOM );

    lpItem->lpFiltering = lpItem->lpUnescapedSOM + lstrlen (lpItem->lpUnescapedSOM) + 1;
    lstrcpy (lpItem->lpFiltering, lpFiltering);

    if (pSD)
    {
        // sd has to be pointer aligned. This is currently aligning it to
        // 8 byte boundary

        DWORD dwOffset;

        dwOffset = (DWORD) ((LPBYTE)(lpItem->lpFiltering + lstrlen (lpItem->lpFiltering) + 1) - (LPBYTE)lpItem);
        lpItem->pSD = (LPBYTE)lpItem + ALIGN_SIZE_TO_NEXTPTR(dwOffset);

        CopyMemory (lpItem->pSD, pSD, dwSDSize);
    }

    lpItem->dwVersion = dwVersion;
    lpItem->bApplied = bApplied;


    //
    // Add item to the link list
    //

    if (*lpList)
    {
        lpTemp = *lpList;

        while (lpTemp)
        {
            if (!lpTemp->pNext)
            {
                lpTemp->pNext = lpItem;
                break;
            }
            lpTemp = lpTemp->pNext;
        }
    }
    else
    {
        *lpList = lpItem;
    }


    return TRUE;
}

VOID CRSOPComponentData::FreeGPOListData(LPGPOLISTITEM lpList)
{
    LPGPOLISTITEM lpTemp;


    do {
        lpTemp = lpList->pNext;
        LocalFree (lpList);
        lpList = lpTemp;

    } while (lpTemp);
}

void CRSOPComponentData::BuildGPOList (LPGPOLISTITEM * lpList, LPTSTR lpNamespace)
{
    HRESULT hr;
    ULONG n, ulIndex = 0, ulOrder, ulAppliedOrder;
    IWbemClassObject * pObjGPLink = NULL;
    IWbemClassObject * pObjGPO = NULL;
    IWbemClassObject * pObjSOM = NULL;
    IEnumWbemClassObject * pAppliedEnum = NULL;
    IEnumWbemClassObject * pNotAppliedEnum = NULL;
    BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
    BSTR strAppliedQuery = SysAllocString(TEXT("SELECT * FROM RSOP_GPLink where AppliedOrder > 0"));
    BSTR strNotAppliedQuery = SysAllocString(TEXT("SELECT * FROM RSOP_GPLink where AppliedOrder = 0"));
    BSTR strNamespace = SysAllocString(lpNamespace);
    BSTR strTemp = NULL;
    WCHAR * szGPOName = NULL;
    WCHAR * szSOM = NULL;
    WCHAR * szGPOPath = NULL;
    WCHAR szFiltering[80] = {0};
    BSTR bstrTemp = NULL;
    ULONG ul = 0, ulVersion = 0;
    BOOL bLinkEnabled, bGPOEnabled, bAccessDenied, bFilterAllowed, bSOMBlocked;
    BOOL bProcessAppliedList = TRUE;
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    LV_COLUMN lvcol;
    BOOL      bValidGPOData;
    LPBYTE pSD = NULL;
    DWORD dwDataSize = 0;


    //
    // Get a locator instance
    //

    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *)&pLocator);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: CoCreateInstance failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Connect to the namespace
    //

    hr = pLocator->ConnectServer(lpNamespace,
                                 NULL,
                                 NULL,
                                 NULL,
                                 0,
                                 NULL,
                                 NULL,
                                 &pNamespace);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: ConnectServer failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Query for the RSOP_GPLink (applied) instances 
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strAppliedQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY,
                               NULL,
                               &pAppliedEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: ExecQuery failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Query for the RSOP_GPLink (notapplied) instances 
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strNotAppliedQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY,
                               NULL,
                               &pNotAppliedEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: ExecQuery (notapplied) failed with 0x%x"), hr));
        goto cleanup;
    }


    bProcessAppliedList = FALSE;

    //
    // Loop through the results
    //

    while (TRUE)
    {

        if (!bProcessAppliedList) {
            
            //
            // No need to sort the not applied list
            //

            hr = pNotAppliedEnum->Next(WBEM_INFINITE, 1, &pObjGPLink, &n);
            if (FAILED(hr) || (n == 0))
            {
                DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::BuildGPOList: Getting applied links")));
                bProcessAppliedList = TRUE;
            }
            else {
                hr = GetParameter(pObjGPLink, TEXT("AppliedOrder"), ulOrder);
                if (FAILED(hr))
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get link order with 0x%x"), hr));
                    goto cleanup;
                }
            }
        }

        
        //
        // Reset the enumerator so we can look through the results to find the
        // correct index
        //

        if (bProcessAppliedList) {
            pAppliedEnum->Reset();


            //
            // Find the correct index in the result set
            //
            
            ulIndex++;
            ulOrder = 0;
            do {
                hr = pAppliedEnum->Next(WBEM_INFINITE, 1, &pObjGPLink, &n);
                if (FAILED(hr) || (n == 0))
                {
                    goto cleanup;
                }


                hr = GetParameter(pObjGPLink, TEXT("AppliedOrder"), ulOrder);
                if (FAILED(hr))
                {
                    DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get link order with 0x%x"), hr));
                    goto cleanup;
                }

                if (ulOrder != ulIndex)
                {
                    pObjGPLink->Release();
                    pObjGPLink = NULL;
                }

            } while (ulOrder != ulIndex);


            if (FAILED(hr)) {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Next failed with error 0x%x"), hr));
                goto cleanup;
            }
        }



        //
        // Get the applied order of this link
        //

        hr = GetParameter(pObjGPLink, TEXT("AppliedOrder"), ulAppliedOrder);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get applied order with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the enabled state of the link
        //

        hr = GetParameter(pObjGPLink, TEXT("enabled"), bLinkEnabled);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get enabled with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the GPO path
        //

        hr = GetParameterBSTR(pObjGPLink, TEXT("GPO"), bstrTemp);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get GPO with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Set the default GPO name to be the gpo path.  Don't worry about
        // freeing this string because the GetParameter call will free the buffer
        // when the real name is successfully queried. Sometimes the rsop_gpo instance
        // won't exist if this gpo is new.
        //

        szGPOName = new TCHAR[_tcslen(bstrTemp) + 1];

        if (!szGPOName)
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to allocate memory for temp gpo name.")));
            goto cleanup;
        }

        if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | NORM_STOP_ON_NULL,
                           TEXT("RSOP_GPO.id="), 12, bstrTemp, 12) == CSTR_EQUAL)
        {
            // removing the first and last quote
            lstrcpy (szGPOName, bstrTemp+13);
            szGPOName[lstrlen(szGPOName)-1] = TEXT('\0');
        }
        else
        {
            lstrcpy (szGPOName, bstrTemp);
        }


        //
        // Add ldap to the path if appropriate
        //

        if (lstrcmpi(szGPOName, TEXT("LocalGPO")))
        {
            szGPOPath = (LPTSTR) LocalAlloc (LPTR, (lstrlen(szGPOName) + 10) * sizeof(WCHAR));

            if (!szGPOPath)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to allocate memory for full path with %d"),
                         GetLastError()));
                goto cleanup;
            }

            lstrcpy (szGPOPath, TEXT("LDAP://"));
            lstrcat (szGPOPath, szGPOName);
        }
        else
        {
            szGPOPath = NULL;
        }



        bValidGPOData = FALSE;

        //
        // Bind to the GPO
        //

        hr = pNamespace->GetObject(
                          bstrTemp,
                          WBEM_FLAG_RETURN_WBEM_COMPLETE,
                          NULL,
                          &pObjGPO,
                          NULL);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: GetObject for GPO %s failed with 0x%x"),
                      bstrTemp, hr));
            SysFreeString (bstrTemp);
            bstrTemp = NULL;
            goto GetSOMData;
        }
        SysFreeString (bstrTemp);
        bstrTemp = NULL;



        //
        // Get the GPO name
        //

        hr = GetParameter(pObjGPO, TEXT("name"), szGPOName);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get name with 0x%x"), hr));
            goto GetSOMData;

        }


        //
        // Get the version number
        //

        hr = GetParameter(pObjGPO, TEXT("version"), ulVersion);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get version with 0x%x"), hr));
            goto GetSOMData;

        }


        //
        // Get the enabled state of the GPO
        //

        hr = GetParameter(pObjGPO, TEXT("enabled"), bGPOEnabled);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get gpo enabled state with 0x%x"), hr));
            goto GetSOMData;
        }


        //
        // Get the WMI filter state of the GPO
        //

        hr = GetParameter(pObjGPO, TEXT("filterAllowed"), bFilterAllowed);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get gpo enabled state with 0x%x"), hr));
            goto GetSOMData;
        }



        //
        // Check for access denied
        //

        hr = GetParameter(pObjGPO, TEXT("accessDenied"), bAccessDenied);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get accessdenied with 0x%x"), hr));
            goto GetSOMData;
        }


        //
        // Get the security descriptor
        //

        if (szGPOPath)
        {
            hr = GetParameterBytes(pObjGPO, TEXT("securityDescriptor"), &pSD, &dwDataSize);
            if (FAILED(hr))
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get security descriptor with 0x%x"), hr));
                goto GetSOMData;
            }
        }

        
        bValidGPOData = TRUE;

GetSOMData:

        //
        // Get the SOM for this link (the S,D,OU that this GPO is linked to)
        //

        hr = GetParameterBSTR(pObjGPLink, TEXT("SOM"), bstrTemp);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get SOM with 0x%x"), hr));
            goto AddNode;
        }


        //
        // Bind to the SOM instance
        //

        hr = pNamespace->GetObject(
                          bstrTemp,
                          WBEM_FLAG_RETURN_WBEM_COMPLETE,
                          NULL,
                          &pObjSOM,
                          NULL);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: GetObject for SOM of %s failed with 0x%x"),
                     bstrTemp, hr));
            SysFreeString (bstrTemp);
            bstrTemp = NULL;
            goto AddNode;
        }

        SysFreeString (bstrTemp);
        bstrTemp = NULL;


        //
        // Get SOM name
        //

        hr = GetParameter(pObjSOM, TEXT("id"), szSOM);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get som id with 0x%x"), hr));
            goto AddNode;
        }

        //
        // Get blocked from above
        //

        hr = GetParameter(pObjSOM, TEXT("blocked"), bSOMBlocked);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to get som id with 0x%x"), hr));
            goto AddNode;
        }



AddNode:

        //
        // Decide on the filtering name
        //

        if (ulAppliedOrder > 0)
        {
            LoadString(g_hInstance, IDS_APPLIED, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if (!bLinkEnabled)
        {
            LoadString(g_hInstance, IDS_DISABLEDLINK, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if (bSOMBlocked) {
            LoadString(g_hInstance, IDS_BLOCKEDSOM, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if ((bValidGPOData) && (!bGPOEnabled))
        {
            LoadString(g_hInstance, IDS_DISABLEDGPO, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if ((bValidGPOData) && (bAccessDenied))
        {
            LoadString(g_hInstance, IDS_SECURITYDENIED, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if ((bValidGPOData) && (!bFilterAllowed))
        {
            LoadString(g_hInstance, IDS_WMIFILTERFAILED, szFiltering, ARRAYSIZE(szFiltering));
        }
        else if ((bValidGPOData) && (ulVersion == 0))
        {
            LoadString(g_hInstance, IDS_NODATA, szFiltering, ARRAYSIZE(szFiltering));
        }
        else
        {
            LoadString(g_hInstance, IDS_UNKNOWNREASON, szFiltering, ARRAYSIZE(szFiltering));
        }


        if (!szSOM)
        {
            szSOM = new TCHAR[2];

            if (!szSOM)
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: Failed to allocate memory for temp som name.")));
                goto cleanup;
            }

            szSOM[0] = TEXT(' ');
        }

        //
        // Add this node to the list
        //

        if (!AddGPOListNode(szGPOName, szGPOPath, szSOM, szFiltering, ulVersion,
                            ((ulAppliedOrder > 0) ? TRUE : FALSE), pSD, dwDataSize, lpList))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOList: AddGPOListNode failed.")));
        }



        //
        // Prepare for next iteration
        //

        if (pObjSOM)
        {
            pObjSOM->Release();
            pObjSOM = NULL;
        }
        if (pObjGPO)
        {
            pObjGPO->Release();
            pObjGPO = NULL;
        }
        if (pObjGPLink)
        {
            pObjGPLink->Release();
            pObjGPLink = NULL;
        }

        if (szGPOName)
        {
            delete [] szGPOName;
            szGPOName = NULL;
        }

        if (szSOM)
        {
            delete [] szSOM;
            szSOM = NULL;
        }

        if (szGPOPath)
        {
            LocalFree (szGPOPath);
            szGPOPath = NULL;
        }

        if (pSD)
        {
            LocalFree (pSD);
            pSD = NULL;
            dwDataSize = 0;
        }

        ulVersion = 0;
    }

cleanup:
    if (szGPOPath)
    {
        LocalFree (szGPOPath);
    }
    if (pSD)
    {
        LocalFree (pSD);
    }
    if (szGPOName)
    {
        delete [] szGPOName;
    }
    if (szSOM)
    {
        delete [] szSOM;
    }
    if (pObjSOM)
    {
        pObjSOM->Release();
    }
    if (pObjGPO)
    {
        pObjGPO->Release();
    }
    if (pObjGPLink)
    {
        pObjGPLink->Release();
    }
    if (pAppliedEnum)
    {
        pAppliedEnum->Release();
    }
    if (pNotAppliedEnum)
    {
        pNotAppliedEnum->Release();
    }
    if (pNamespace)
    {
        pNamespace->Release();
    }
    if (pLocator)
    {
        pLocator->Release();
    }
    SysFreeString(strQueryLanguage);
    SysFreeString(strAppliedQuery);
    SysFreeString(strNotAppliedQuery);
    SysFreeString(strNamespace);
}

void CRSOPComponentData::BuildGPOLists (void)
{
    LPTSTR lpNamespace, lpEnd;

    lpNamespace = (LPTSTR) LocalAlloc (LPTR, (lstrlen(m_szNamespace) + 20) * sizeof(TCHAR));

    if (lpNamespace)
    {
        lstrcpy (lpNamespace, m_szNamespace);
        lpEnd = CheckSlash(lpNamespace);

        lstrcpy (lpEnd, TEXT("User"));

        if (m_pUserGPOList)
        {
            FreeGPOListData(m_pUserGPOList);
            m_pUserGPOList = NULL;
        }

        BuildGPOList (&m_pUserGPOList, lpNamespace);


        lstrcpy (lpEnd, TEXT("Computer"));

        if (m_pComputerGPOList)
        {
            FreeGPOListData(m_pComputerGPOList);
            m_pComputerGPOList = NULL;
        }

        BuildGPOList (&m_pComputerGPOList, lpNamespace);

        LocalFree (lpNamespace);
    }
    else
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildGPOLists: Failed to allocate memory for namespace with %d"),
                 GetLastError()));
    }
}

void CRSOPComponentData::PrepGPOList(HWND hList, BOOL bSOM, BOOL bFiltering,
                                     BOOL bVersion, DWORD dwCount)
{
    RECT rect;
    WCHAR szHeading[256];
    LV_COLUMN lvcol;
    LONG lWidth;
    INT cxName = 0, cxSOM = 0, cxFiltering = 0, cxVersion = 0, iTotal = 0;
    INT iColIndex = 0;


    //
    // Delete any previous columns
    //

    SendMessage (hList, LVM_DELETECOLUMN, 3, 0);
    SendMessage (hList, LVM_DELETECOLUMN, 2, 0);
    SendMessage (hList, LVM_DELETECOLUMN, 1, 0);
    SendMessage (hList, LVM_DELETECOLUMN, 0, 0);


    //
    // Decide on the column widths
    //

    GetClientRect(hList, &rect);

    if (dwCount > (DWORD)ListView_GetCountPerPage(hList))
    {
        lWidth = (rect.right - rect.left) - GetSystemMetrics(SM_CYHSCROLL);
    }
    else
    {
        lWidth = rect.right - rect.left;
    }


    if (bFiltering)
    {
        cxFiltering = (lWidth * 30) / 100;
        iTotal += cxFiltering;
    }

    if (bVersion)
    {
        cxVersion = (lWidth * 30) / 100;
        iTotal += cxVersion;
    }

    if (bSOM)
    {
        cxSOM = (lWidth - iTotal) / 2;
        iTotal += cxSOM;
        cxName = lWidth - iTotal;
    }
    else
    {
        cxName = lWidth - iTotal;
    }


    //
    // Insert the GPO Name column and then any appropriate columns
    //

    memset(&lvcol, 0, sizeof(lvcol));

    lvcol.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
    lvcol.fmt = LVCFMT_LEFT;
    lvcol.pszText = szHeading;
    lvcol.cx = cxName;
    LoadString(g_hInstance, IDS_GPO_NAME, szHeading, ARRAYSIZE(szHeading));
    ListView_InsertColumn(hList, iColIndex, &lvcol);
    iColIndex++;


    if (bFiltering)
    {
        lvcol.cx = cxFiltering;
        LoadString(g_hInstance, IDS_FILTERING, szHeading, ARRAYSIZE(szHeading));
        ListView_InsertColumn(hList, iColIndex, &lvcol);
        iColIndex++;
    }

    if (bSOM)
    {
        lvcol.cx = cxSOM;
        LoadString(g_hInstance, IDS_SOM, szHeading, ARRAYSIZE(szHeading));
        ListView_InsertColumn(hList, iColIndex, &lvcol);
        iColIndex++;
    }

    if (bVersion)
    {
        lvcol.cx = cxVersion;
        LoadString(g_hInstance, IDS_VERSION, szHeading, ARRAYSIZE(szHeading));
        ListView_InsertColumn(hList, iColIndex, &lvcol);
    }


    //
    // Turn on some listview features
    //

    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
                LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);

}

void CRSOPComponentData::FillGPOList(HWND hDlg, DWORD dwListID, LPGPOLISTITEM lpList,
                                     BOOL bSOM, BOOL bFiltering, BOOL bVersion, BOOL bInitial)
{
    LV_COLUMN lvcol;
    HWND hList;
    LV_ITEM item;
    int iItem;
    TCHAR szVersion[80];
    TCHAR szVersionFormat[50];
    INT iColIndex, iDefault = 0;
    LPGPOLISTITEM lpItem, lpDefault = NULL;
    DWORD dwCount = 0;
    LVFINDINFO FindInfo;


    LoadString(g_hInstance, IDS_VERSIONFORMAT, szVersionFormat, ARRAYSIZE(szVersionFormat));

    hList = GetDlgItem(hDlg, dwListID);
    ListView_DeleteAllItems(hList);

    lpItem = lpList;

    while (lpItem)
    {
        if (bInitial)
        {
            if (LOWORD(lpItem->dwVersion) != HIWORD(lpItem->dwVersion))
            {
                bVersion = TRUE;
                CheckDlgButton (hDlg, IDC_CHECK3, BST_CHECKED);
            }
        }
        lpItem = lpItem->pNext;
        dwCount++;
    }


    PrepGPOList(hList, bSOM, bFiltering, bVersion, dwCount);

    lpItem = lpList;

    while (lpItem)
    {
        if (lpItem->bApplied || bFiltering)
        {
            wsprintf (szVersion, szVersionFormat, LOWORD(lpItem->dwVersion), HIWORD(lpItem->dwVersion));

            iColIndex = 0;
            memset(&item, 0, sizeof(item));
            item.mask = LVIF_TEXT | LVIF_PARAM;
            item.pszText = lpItem->lpGPOName;
            item.iItem = 0;
            item.lParam = (LPARAM) lpItem;
            iItem = ListView_InsertItem(hList, &item);
            iColIndex++;

            if (bInitial)
            {
                if (LOWORD(lpItem->dwVersion) != HIWORD(lpItem->dwVersion))
                {
                    lpDefault = lpItem;
                }
            }

            if (bFiltering)
            {
                item.mask = LVIF_TEXT;
                item.pszText = lpItem->lpFiltering;
                item.iItem = iItem;
                item.iSubItem = iColIndex;
                ListView_SetItem(hList, &item);
                iColIndex++;
            }

            if (bSOM)
            {
                item.mask = LVIF_TEXT;
                item.pszText = lpItem->lpUnescapedSOM;
                item.iItem = iItem;
                item.iSubItem = iColIndex;
                ListView_SetItem(hList, &item);
                iColIndex++;
            }

            if (bVersion)
            {
                item.mask = LVIF_TEXT;
                item.pszText = szVersion;
                item.iItem = iItem;
                item.iSubItem = iColIndex;
                ListView_SetItem(hList, &item);
            }
        }

        lpItem = lpItem->pNext;
    }


    if (lpDefault)
    {
        ZeroMemory (&FindInfo, sizeof(FindInfo));
        FindInfo.flags = LVFI_PARAM;
        FindInfo.lParam = (LPARAM) lpDefault;

        iDefault = ListView_FindItem(hList, -1, &FindInfo);

        if (iDefault == -1)
        {
            iDefault = 0;
        }
    }


    //
    // Select a item
    //

    item.mask = LVIF_STATE;
    item.iItem = iDefault;
    item.iSubItem = 0;
    item.state = LVIS_SELECTED | LVIS_FOCUSED;
    item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;

    SendMessage (hList, LVM_SETITEMSTATE, (WPARAM)iDefault, (LPARAM) &item);
    SendMessage (hList, LVM_ENSUREVISIBLE, iDefault, FALSE);

}

void CRSOPComponentData::OnSecurity(HWND hDlg)
{
    HWND hLV;
    INT i;
    HRESULT hr;
    LVITEM item;
    LPGPOLISTITEM lpItem;
    TCHAR szGPOName[MAX_FRIENDLYNAME];
    PROPSHEETHEADER psh;
    HPROPSHEETPAGE hPages[2];

    //
    // Get the selected item (if any)
    //

    hLV = GetDlgItem (hDlg, IDC_LIST1);
    i = ListView_GetNextItem(hLV, -1, LVNI_SELECTED);

    if (i < 0)
    {
        return;
    }


    ZeroMemory (&item, sizeof(item));
    item.mask = LVIF_TEXT | LVIF_PARAM;
    item.iItem = i;
    item.pszText = szGPOName;
    item.cchTextMax = ARRAYSIZE(szGPOName);

    if (!ListView_GetItem (hLV, &item))
    {
        return;
    }

    lpItem = (LPGPOLISTITEM) item.lParam;


    //
    // Create the security page
    //

    hr = DSCreateSecurityPage (lpItem->lpDSPath, L"groupPolicyContainer",
                                    DSSI_IS_ROOT | DSSI_READ_ONLY,
                                    &hPages[0], ReadSecurityDescriptor,
                                    WriteSecurityDescriptor, (LPARAM)lpItem);

    if (FAILED(hr))
    {
        return;
    }


    //
    // Display the property sheet
    //

    ZeroMemory (&psh, sizeof(psh));
    psh.dwSize = sizeof(psh);
    psh.dwFlags = PSH_PROPTITLE;
    psh.hwndParent = hDlg;
    psh.hInstance = g_hInstance;
    psh.pszCaption = szGPOName;
    psh.nPages = 1;
    psh.phpage = hPages;

    PropertySheet (&psh);
}

HRESULT WINAPI CRSOPComponentData::ReadSecurityDescriptor (LPCWSTR lpGPOPath,
                                                           SECURITY_INFORMATION si,
                                                           PSECURITY_DESCRIPTOR *pSD,
                                                           LPARAM lpContext)
{
    LPGPOLISTITEM lpItem;
    HRESULT hr;


    lpItem = (LPGPOLISTITEM) lpContext;

    if (!lpItem)
    {
        return E_FAIL;
    }

    if (si & DACL_SECURITY_INFORMATION)
    {
        *pSD = lpItem->pSD;
    }
    else
    {
        *pSD = NULL;
    }

    return S_OK;
}

HRESULT WINAPI CRSOPComponentData::WriteSecurityDescriptor (LPCWSTR lpGPOPath,
                                                            SECURITY_INFORMATION si,
                                                            PSECURITY_DESCRIPTOR pSD,
                                                            LPARAM lpContext)
{
    return S_OK;
}

void CRSOPComponentData::OnEdit(HWND hDlg)
{
    HWND hLV;
    LVITEM item;
    LPGPOLISTITEM lpItem;
    INT i;
    SHELLEXECUTEINFO ExecInfo;
    TCHAR szArgs[MAX_PATH + 30];

    //
    // Get the selected item (if any)
    //

    hLV = GetDlgItem (hDlg, IDC_LIST1);
    i = ListView_GetNextItem(hLV, -1, LVNI_SELECTED);

    if (i < 0)
    {
        return;
    }


    ZeroMemory (&item, sizeof(item));
    item.mask = LVIF_PARAM;
    item.iItem = i;

    if (!ListView_GetItem (hLV, &item))
    {
        return;
    }

    lpItem = (LPGPOLISTITEM) item.lParam;


    if (lpItem->lpDSPath)
    {
        if (!SpawnGPE(lpItem->lpDSPath, GPHintUnknown, NULL, hDlg))
        {
            ReportError (hDlg, GetLastError(), IDS_SPAWNGPEFAILED);
        }
    }
    else
    {
        ZeroMemory (&ExecInfo, sizeof(ExecInfo));
        ExecInfo.cbSize = sizeof(ExecInfo);
        ExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
        ExecInfo.lpVerb = TEXT("open");
        ExecInfo.lpFile = TEXT("gpedit.msc");
        ExecInfo.nShow = SW_SHOWNORMAL;

        if (lstrcmpi(m_szComputerName, TEXT(".")))
        {
            wsprintf (szArgs, TEXT("/gpcomputer:\"%s\" /gphint:1"), m_szComputerName);
            ExecInfo.lpParameters = szArgs;
        }

        if (ShellExecuteEx (&ExecInfo))
        {
            SetWaitCursor();
            WaitForInputIdle (ExecInfo.hProcess, 10000);
            ClearWaitCursor();
            CloseHandle (ExecInfo.hProcess);
        }
        else
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::OnEdit: ShellExecuteEx failed with %d"),
                     GetLastError()));
            ReportError(NULL, GetLastError(), IDS_SPAWNGPEFAILED);
        }
    }
}

void CRSOPComponentData::OnContextMenu(HWND hDlg, LPARAM lParam)
{
    LPGPOLISTITEM lpItem;
    LVITEM item;
    HMENU hPopup;
    HWND hLV;
    int i;
    RECT rc;
    POINT pt;

    //
    // Get the selected item (if any)
    //

    hLV = GetDlgItem (hDlg, IDC_LIST1);
    i = ListView_GetNextItem(hLV, -1, LVNI_SELECTED);

    if (i < 0)
    {
        return;
    }

    item.mask = LVIF_PARAM;
    item.iItem = i;
    item.iSubItem = 0;

    if (!ListView_GetItem (GetDlgItem(hDlg, IDC_LIST1), &item))
    {
        return;
    }

    lpItem = (LPGPOLISTITEM) item.lParam;


    //
    // Figure out where to place the context menu
    //

    pt.x = ((int)(short)LOWORD(lParam));
    pt.y = ((int)(short)HIWORD(lParam));

    GetWindowRect (hLV, &rc);

    if (!PtInRect (&rc, pt))
    {
        if ((lParam == (LPARAM) -1) && (i >= 0))
        {
            rc.left = LVIR_SELECTBOUNDS;
            SendMessage (hLV, LVM_GETITEMRECT, i, (LPARAM) &rc);

            pt.x = rc.left + 8;
            pt.y = rc.top + ((rc.bottom - rc.top) / 2);

            ClientToScreen (hLV, &pt);
        }
        else
        {
            pt.x = rc.left + ((rc.right - rc.left) / 2);
            pt.y = rc.top + ((rc.bottom - rc.top) / 2);
        }
    }


    //
    // Load the context menu
    //


    hPopup = LoadMenu(g_hInstance, MAKEINTRESOURCE(IDM_GPOLIST_CONTEXTMENU));

    if (!hPopup) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::OnContextMenu: LoadMenu failed with %d"),
                 GetLastError()));
        return;
    }

    if (!(lpItem->pSD)) {
        DebugMsg((DM_VERBOSE, TEXT("CRSOPComponentData::OnContextMenu: Disabling Security menu item")));
        EnableMenuItem(GetSubMenu(hPopup, 0), IDM_GPOLIST_SECURITY, MF_GRAYED);
        DrawMenuBar(hDlg);
    }

    //
    // Display the menu
    //

    TrackPopupMenu(GetSubMenu(hPopup, 0), TPM_LEFTALIGN, pt.x, pt.y, 0, hDlg, NULL);

    DestroyMenu(hPopup);
}

void CRSOPComponentData::OnRefreshDisplay(HWND hDlg)
{
    INT iIndex;
    LVITEM item;
    LPGPOLISTITEM lpItem;


    iIndex = ListView_GetNextItem (GetDlgItem(hDlg, IDC_LIST1), -1,
                                   LVNI_ALL | LVNI_SELECTED);

    if (iIndex != -1)
    {

        item.mask = LVIF_PARAM;
        item.iItem = iIndex;
        item.iSubItem = 0;

        if (!ListView_GetItem (GetDlgItem(hDlg, IDC_LIST1), &item))
        {
            return;
        }

        lpItem = (LPGPOLISTITEM) item.lParam;

        if (lpItem->pSD)
        {
            EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), TRUE);
        }
        else
        {
            EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
        }

        EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), TRUE);
    }
    else
    {
        EnableWindow (GetDlgItem(hDlg, IDC_BUTTON1), FALSE);
        EnableWindow (GetDlgItem(hDlg, IDC_BUTTON2), FALSE);
    }
}

INT_PTR CALLBACK CRSOPComponentData::QueryDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    WCHAR szBuffer[MAX_PATH];
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        if (pCD)
        {
            pCD->InitializeResultsList (GetDlgItem(hDlg, IDC_LIST1));
            pCD->FillResultsList (GetDlgItem(hDlg, IDC_LIST1));
        }

        break;

    case WM_HELP:      // F1
        WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
        (ULONG_PTR) (LPSTR) aQueryHelpIds);
        break;

    case WM_CONTEXTMENU:      // right mouse click
        WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
        (ULONG_PTR) (LPSTR) aQueryHelpIds);
        return (TRUE);

    }
    return FALSE;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPGPOListMachineProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    WCHAR szBuffer[MAX_PATH];
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        LoadString(g_hInstance, IDS_RSOP_GPOLIST_MACHINE, szBuffer, ARRAYSIZE(szBuffer));
        SetDlgItemText(hDlg, IDC_STATIC1, szBuffer);

        if (pCD)
        {
            pCD->FillGPOList(hDlg, IDC_LIST1, pCD->m_pComputerGPOList, FALSE, FALSE, FALSE, TRUE);
        }
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (pCD)
            {
                switch (LOWORD(wParam))
                {
                case IDC_CHECK1:
                case IDC_CHECK2:
                case IDC_CHECK3:
                    {
                        pCD->FillGPOList(hDlg,
                                         IDC_LIST1,
                                         pCD->m_pComputerGPOList,
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK1), BM_GETCHECK, 0, 0),
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK2), BM_GETCHECK, 0, 0),
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK3), BM_GETCHECK, 0, 0),
                                         FALSE);
                    }
                    break;

                case IDC_BUTTON2:
                case IDM_GPOLIST_EDIT:
                    pCD->OnEdit(hDlg);
                    break;

                case IDC_BUTTON1:
                case IDM_GPOLIST_SECURITY:
                    pCD->OnSecurity(hDlg);
                    break;
                }
                PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            }
        }
        break;

    case WM_NOTIFY:
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (pCD)
        {
            pCD->OnRefreshDisplay(hDlg);
        }
        break;

    case WM_HELP:      // F1
        WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
        (ULONG_PTR) (LPSTR) aGPOListHelpIds);
        break;


    case WM_CONTEXTMENU:
        if (GetDlgItem(hDlg, IDC_LIST1) == (HWND)wParam)
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (pCD)
            {
                pCD->OnContextMenu(hDlg, lParam);
            }
        }
        else
        {
            // right mouse click
            WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
            (ULONG_PTR) (LPSTR) aGPOListHelpIds);
        }
        return TRUE;

    }
    return FALSE;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPGPOListUserProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    WCHAR szBuffer[MAX_PATH];
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);

        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);
        LoadString(g_hInstance, IDS_RSOP_GPOLIST_USER, szBuffer, ARRAYSIZE(szBuffer));
        SetDlgItemText(hDlg, IDC_STATIC1, szBuffer);

        if (pCD)
        {
            pCD->FillGPOList(hDlg, IDC_LIST1, pCD->m_pUserGPOList, FALSE, FALSE, FALSE, TRUE);
        }
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        break;

    case WM_COMMAND:
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (pCD)
            {
                switch (LOWORD(wParam))
                {
                case IDC_CHECK1:
                case IDC_CHECK2:
                case IDC_CHECK3:
                    {
                        pCD->FillGPOList(hDlg,
                                         IDC_LIST1,
                                         pCD->m_pUserGPOList,
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK1), BM_GETCHECK, 0, 0),
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK2), BM_GETCHECK, 0, 0),
                                         (BOOL) SendMessage(GetDlgItem(hDlg, IDC_CHECK3), BM_GETCHECK, 0, 0),
                                         FALSE);
                    }
                    break;

                case IDC_BUTTON2:
                case IDM_GPOLIST_EDIT:
                    pCD->OnEdit(hDlg);
                    break;

                case IDC_BUTTON1:
                case IDM_GPOLIST_SECURITY:
                    pCD->OnSecurity(hDlg);
                    break;
                }
            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            }
        }
        break;

    case WM_NOTIFY:
        PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

        if (pCD)
        {
            pCD->OnRefreshDisplay(hDlg);
        }
        break;

    case WM_HELP:      // F1
        WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
        (ULONG_PTR) (LPSTR) aGPOListHelpIds);
        break;

    case WM_CONTEXTMENU:
        if (GetDlgItem(hDlg, IDC_LIST1) == (HWND)wParam)
        {
            pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);

            if (pCD)
            {
                pCD->OnContextMenu(hDlg, lParam);
            }
        }
        else
        {
            // right mouse click
            WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
            (ULONG_PTR) (LPSTR) aGPOListHelpIds);
        }
        return TRUE;

    }
    return FALSE;
}

void CRSOPComponentData::QueryRSoPPolicySettingStatusInstances (LPTSTR lpNamespace)
{
    HRESULT hr;
    ULONG n;
    IWbemClassObject * pStatus = NULL;
    IEnumWbemClassObject * pEnum = NULL;
    BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
    BSTR strQuery = SysAllocString(TEXT("SELECT * FROM RSoP_PolicySettingStatus"));
    BSTR strNamespace = SysAllocString(lpNamespace);
    BSTR bstrEventSource = NULL;
    BSTR bstrEventLogName = NULL;
    DWORD dwEventID;
    BSTR bstrEventTime = NULL;
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    SYSTEMTIME EventTime, BeginTime, EndTime;
    XBStr xbstrWbemTime;
    FILETIME ft;
    ULARGE_INTEGER ulTime;


    //
    // Get a locator instance
    //

    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *)&pLocator);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: CoCreateInstance failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Connect to the namespace
    //

    hr = pLocator->ConnectServer(lpNamespace,
                                 NULL,
                                 NULL,
                                 NULL,
                                 0,
                                 NULL,
                                 NULL,
                                 &pNamespace);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: ConnectServer failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Query for the RSoP_PolicySettingStatus instances
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
                               NULL,
                               &pEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: ExecQuery failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Loop through the results
    //

    while (TRUE)
    {

        //
        // Get 1 instance
        //

        hr = pEnum->Next(WBEM_INFINITE, 1, &pStatus, &n);

        if (FAILED(hr) || (n == 0))
        {
            goto cleanup;
        }


        //
        // Get the event source name
        //

        hr = GetParameterBSTR(pStatus, TEXT("eventSource"), bstrEventSource);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: Failed to get display name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the event log name
        //

        hr = GetParameterBSTR(pStatus, TEXT("eventLogName"), bstrEventLogName);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: Failed to get display name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the event ID
        //

        hr = GetParameter(pStatus, TEXT("eventID"), (ULONG)dwEventID);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: Failed to get display name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the EventTime in bstr format
        //

        hr = GetParameterBSTR(pStatus, TEXT("eventTime"), bstrEventTime);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: Failed to get event time with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Convert it to system time format
        //

        xbstrWbemTime = bstrEventTime;

        hr = WbemTimeToSystemTime(xbstrWbemTime, EventTime);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: WbemTimeToSystemTime failed with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Take the event time minus 1 second to get the begin time
        //

        if (!SystemTimeToFileTime (&EventTime, &ft))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: SystemTimeToFileTime failed with %d"), GetLastError()));
            goto cleanup;
        }

        ulTime.LowPart = ft.dwLowDateTime;
        ulTime.HighPart = ft.dwHighDateTime;

        ulTime.QuadPart = ulTime.QuadPart - 10000000;  // 1 second

        ft.dwLowDateTime = ulTime.LowPart;
        ft.dwHighDateTime = ulTime.HighPart;

        if (!FileTimeToSystemTime (&ft, &BeginTime))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: FileTimeToSystemTime failed with %d"), GetLastError()));
            goto cleanup;
        }


        //
        // Take the event time plus 1 second to get the end time
        //

        if (!SystemTimeToFileTime (&EventTime, &ft))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: SystemTimeToFileTime failed with %d"), GetLastError()));
            goto cleanup;
        }

        ulTime.LowPart = ft.dwLowDateTime;
        ulTime.HighPart = ft.dwHighDateTime;

        ulTime.QuadPart = ulTime.QuadPart + 10000000;  // 1 second

        ft.dwLowDateTime = ulTime.LowPart;
        ft.dwHighDateTime = ulTime.HighPart;

        if (!FileTimeToSystemTime (&ft, &EndTime))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::QueryRSoPPolicySettingStatusInstances: FileTimeToSystemTime failed with %d"), GetLastError()));
            goto cleanup;
        }


        //
        // Get the event log source information
        //

        if (m_pEvents)
        {
            m_pEvents->QueryForEventLogEntries ((m_bDiagnostic ? m_szComputerName : m_szDC),
                                                bstrEventLogName, bstrEventSource, dwEventID,
                                                &BeginTime, &EndTime);
        }

        //
        // Prepare for next iteration
        //

        SysFreeString (bstrEventSource);
        bstrEventSource = NULL;

        SysFreeString (bstrEventLogName);
        bstrEventLogName = NULL;

        SysFreeString (bstrEventTime);
        bstrEventTime = NULL;

        pStatus->Release();
        pStatus = NULL;
    }

cleanup:

    if (bstrEventSource)
    {
        SysFreeString (bstrEventSource);
    }
    if (bstrEventLogName)
    {
        SysFreeString (bstrEventLogName);
    }
    if (bstrEventTime)
    {
        SysFreeString (bstrEventTime);
    }
    if (pEnum)
    {
        pEnum->Release();
    }
    if (pNamespace)
    {
        pNamespace->Release();
    }
    if (pLocator)
    {
        pLocator->Release();
    }
    SysFreeString(strQueryLanguage);
    SysFreeString(strQuery);
    SysFreeString(strNamespace);
}

void CRSOPComponentData::GetEventLogSources (IWbemServices * pNamespace,
                                             LPTSTR lpCSEGUID, LPTSTR lpComputerName,
                                             SYSTEMTIME *BeginTime, SYSTEMTIME *EndTime,
                                             LPSOURCEENTRY *lpSources)
{
    HRESULT hr;
    ULONG n;
    BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
    BSTR strQuery = NULL;
    LPTSTR lpQuery;
    const TCHAR szBaseQuery [] = TEXT("SELECT * FROM RSOP_ExtensionEventSourceLink WHERE extensionStatus=\"RSOP_ExtensionStatus.extensionGuid=\\\"%s\\\"\"");
    IEnumWbemClassObject * pEnum = NULL;
    IWbemClassObject * pLink = NULL;
    IWbemClassObject * pEventSource = NULL;
    BSTR bstrEventSource = NULL;
    BSTR bstrEventLogName = NULL;
    BSTR bstrEventSourceName = NULL;


    //
    // Build the query first
    //

    lpQuery = (LPTSTR) LocalAlloc (LPTR, (lstrlen(szBaseQuery) + 50) * sizeof(TCHAR));

    if (!lpQuery)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: Failed  to allocate memory for query")));
        goto cleanup;
    }

    wsprintf (lpQuery, szBaseQuery, lpCSEGUID);

    strQuery = SysAllocString(lpQuery);

    LocalFree (lpQuery);

    if (!strQuery)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: Failed  to allocate memory for query (2)")));
        goto cleanup;
    }


    //
    // Query for the RSOP_ExtensionEventSourceLink instances that match this CSE
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
                               NULL,
                               &pEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: ExecQuery failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Loop through the results
    //

    while (TRUE)
    {

        //
        // Get 1 instance
        //

        hr = pEnum->Next(WBEM_INFINITE, 1, &pLink, &n);

        if (FAILED(hr) || (n == 0))
        {
            goto cleanup;
        }


        //
        // Get the eventSource reference
        //

        hr = GetParameterBSTR(pLink, TEXT("eventSource"), bstrEventSource);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: Failed to get event source reference with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the eventSource instance
        //

        hr = pNamespace->GetObject(
                          bstrEventSource,
                          WBEM_FLAG_RETURN_WBEM_COMPLETE,
                          NULL,
                          &pEventSource,
                          NULL);

        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: GetObject for event source of %s failed with 0x%x"),
                     bstrEventSource, hr));
            goto loopagain;
        }


        //
        // Get the eventLogSource property
        //

        hr = GetParameterBSTR(pEventSource, TEXT("eventLogSource"), bstrEventSourceName);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: Failed to get event source name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the eventLogName property
        //

        hr = GetParameterBSTR(pEventSource, TEXT("eventLogName"), bstrEventLogName);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::GetEventLogSources: Failed to get event log name with 0x%x"), hr));
            goto cleanup;
        }


        if (m_pEvents)
        {
            //
            // Add it to the list of sources
            //

            m_pEvents->AddSourceEntry (bstrEventLogName, bstrEventSourceName, lpSources);


            //
            // Initialize the event log database for this source if we are working
            // with a live query.  If this is archived data, the event log entries
            // will be reloaded from the saved console file.
            //

            if (!m_bArchiveData)
            {
                m_pEvents->QueryForEventLogEntries (lpComputerName,
                                                    bstrEventLogName, bstrEventSourceName,
                                                    0, BeginTime, EndTime);
            }
        }


        //
        // Clean up for next item
        //

        SysFreeString (bstrEventLogName);
        bstrEventLogName = NULL;

        SysFreeString (bstrEventSourceName);
        bstrEventSourceName = NULL;

        pEventSource->Release();
        pEventSource = NULL;

loopagain:
        SysFreeString (bstrEventSource);
        bstrEventSource = NULL;

        pLink->Release();
        pLink = NULL;
    }

cleanup:


    if (bstrEventSourceName)
    {
        SysFreeString (bstrEventSourceName);
    }

    if (bstrEventLogName)
    {
        SysFreeString (bstrEventLogName);
    }

    if (bstrEventSource)
    {
        SysFreeString (bstrEventSource);
    }

    if (pEventSource)
    {
        pEventSource->Release();
    }

    if (pLink)
    {
        pLink->Release();
    }

    if (pEnum)
    {
        pEnum->Release();
    }

    if (strQueryLanguage)
    {
        SysFreeString(strQueryLanguage);
    }

    if (strQuery)
    {
        SysFreeString(strQuery);
    }

}

void CRSOPComponentData::BuildCSEList (LPCSEITEM * lpList, LPTSTR lpNamespace, BOOL *bCSEError, BOOL *bGPCoreError)
{
    HRESULT hr;
    ULONG n;
    IWbemClassObject * pExtension = NULL;
    IEnumWbemClassObject * pEnum = NULL;
    BSTR strQueryLanguage = SysAllocString(TEXT("WQL"));
    BSTR strQuery = SysAllocString(TEXT("SELECT * FROM RSOP_ExtensionStatus"));
    BSTR strNamespace = SysAllocString(lpNamespace);
    BSTR bstrName = NULL;
    BSTR bstrGUID = NULL;
    BSTR bstrBeginTime = NULL;
    BSTR bstrEndTime = NULL;
    ULONG ulLoggingStatus;
    ULONG ulStatus;
    IWbemLocator * pLocator = NULL;
    IWbemServices * pNamespace = NULL;
    SYSTEMTIME BeginTime, EndTime;
    LPTSTR lpSourceNames = NULL;
    XBStr xbstrWbemTime;
    LPSOURCEENTRY lpSources;


    //
    // Get a locator instance
    //

    hr = CoCreateInstance(CLSID_WbemLocator,
                          0,
                          CLSCTX_INPROC_SERVER,
                          IID_IWbemLocator,
                          (LPVOID *)&pLocator);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: CoCreateInstance failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Connect to the namespace
    //

    hr = pLocator->ConnectServer(lpNamespace,
                                 NULL,
                                 NULL,
                                 NULL,
                                 0,
                                 NULL,
                                 NULL,
                                 &pNamespace);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: ConnectServer failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Query for the RSOP_ExtensionStatus instances
    //

    hr = pNamespace->ExecQuery(strQueryLanguage,
                               strQuery,
                               WBEM_FLAG_RETURN_IMMEDIATELY | WBEM_FLAG_FORWARD_ONLY,
                               NULL,
                               &pEnum);
    if (FAILED(hr))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: ExecQuery failed with 0x%x"), hr));
        goto cleanup;
    }


    //
    // Loop through the results
    //

    while (TRUE)
    {

        //
        // Get 1 instance
        //

        hr = pEnum->Next(WBEM_INFINITE, 1, &pExtension, &n);

        if (FAILED(hr) || (n == 0))
        {
            goto cleanup;
        }


        //
        // Get the name
        //

        hr = GetParameterBSTR(pExtension, TEXT("displayName"), bstrName);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: Failed to get display name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the GUID
        //

        hr = GetParameterBSTR(pExtension, TEXT("extensionGuid"), bstrGUID);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: Failed to get display name with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the status
        //

        hr = GetParameter(pExtension, TEXT("error"), ulStatus);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: Failed to get status with 0x%x"), hr));
            goto cleanup;

        }


        //
        // Get the rsop logging status
        //

        hr = GetParameter(pExtension, TEXT("loggingStatus"), ulLoggingStatus);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: Failed to get logging status with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the BeginTime in bstr format
        //

        hr = GetParameterBSTR(pExtension, TEXT("beginTime"), bstrBeginTime);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: Failed to get begin time with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Convert it to system time format
        //

        xbstrWbemTime = bstrBeginTime;

        hr = WbemTimeToSystemTime(xbstrWbemTime, BeginTime);
        if (FAILED(hr))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: WbemTimeToSystemTime failed with 0x%x"), hr));
            goto cleanup;
        }


        //
        // Get the EndTime in bstr format
        //

        hr = GetParameterBSTR(pExtension, TEXT("endTime"), bstrEndTime);

        if (SUCCEEDED(hr))
        {
            //
            // Convert it to system time format
            //

            xbstrWbemTime = bstrEndTime;

            hr = WbemTimeToSystemTime(xbstrWbemTime, EndTime);
            if (FAILED(hr))
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: WbemTimeToSystemTime failed with 0x%x"), hr));
                goto cleanup;
            }
        }
        else
        {
            FILETIME ft;
            ULARGE_INTEGER ulTime;

            //
            // Add 2 minutes to BeginTime to get a close approx of the EndTime
            //

            if (!SystemTimeToFileTime (&BeginTime, &ft))
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: SystemTimeToFileTime failed with %d"), GetLastError()));
                goto cleanup;
            }

            ulTime.LowPart = ft.dwLowDateTime;
            ulTime.HighPart = ft.dwHighDateTime;

            ulTime.QuadPart = ulTime.QuadPart + (10000000 * 120);  // 120 seconds

            ft.dwLowDateTime = ulTime.LowPart;
            ft.dwHighDateTime = ulTime.HighPart;

            if (!FileTimeToSystemTime (&ft, &EndTime))
            {
                DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: FileTimeToSystemTime failed with %d"), GetLastError()));
                goto cleanup;
            }
        }


        //
        // Get the event log source information
        //

        lpSources = NULL;
        GetEventLogSources (pNamespace, bstrGUID, (m_bDiagnostic ? m_szComputerName : m_szDC),
                            &BeginTime, &EndTime, &lpSources);


        //
        // Add this node to the list
        //

        if (!AddCSENode(bstrName, bstrGUID, ulStatus, ulLoggingStatus, &BeginTime, &EndTime,
                        lpList, bCSEError, bGPCoreError, lpSources))
        {
            DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSEList: AddGPOListNode failed.")));
            if (m_pEvents)
            {
                m_pEvents->FreeSourceData (lpSources);
            }
            goto cleanup;
        }


        //
        // Prepare for next iteration
        //

        SysFreeString (bstrName);
        bstrName = NULL;

        SysFreeString (bstrGUID);
        bstrGUID = NULL;

        SysFreeString (bstrBeginTime);
        bstrBeginTime = NULL;

        if (bstrEndTime)
        {
            SysFreeString (bstrEndTime);
            bstrEndTime = NULL;
        }

        LocalFree (lpSourceNames);
        lpSourceNames = NULL;

        pExtension->Release();
        pExtension = NULL;
    }

cleanup:

    if (bstrName)
    {
        SysFreeString (bstrName);
    }
    if (bstrGUID)
    {
        SysFreeString (bstrGUID);
    }
    if (bstrBeginTime)
    {
        SysFreeString (bstrBeginTime);
    }
    if (bstrEndTime)
    {
        SysFreeString (bstrEndTime);
    }
    if (lpSourceNames)
    {
        LocalFree (lpSourceNames);
    }
    if (pEnum)
    {
        pEnum->Release();
    }
    if (pNamespace)
    {
        pNamespace->Release();
    }
    if (pLocator)
    {
        pLocator->Release();
    }
    SysFreeString(strQueryLanguage);
    SysFreeString(strQuery);
    SysFreeString(strNamespace);
}

VOID CRSOPComponentData::BuildCSELists (void)
{
    LPTSTR lpNamespace, lpEnd;

    lpNamespace = (LPTSTR) LocalAlloc (LPTR, (lstrlen(m_szNamespace) + 20) * sizeof(TCHAR));

    if (lpNamespace)
    {
        lstrcpy (lpNamespace, m_szNamespace);
        lpEnd = CheckSlash(lpNamespace);

        lstrcpy (lpEnd, TEXT("User"));

        if (m_pUserCSEList)
        {
            FreeCSEData(m_pUserCSEList);
            m_pUserCSEList = NULL;
        }

        BuildCSEList (&m_pUserCSEList, lpNamespace, &m_bUserCSEError, &m_bUserGPCoreError);

        if (!m_bArchiveData)
        {
            QueryRSoPPolicySettingStatusInstances (lpNamespace);
        }


        lstrcpy (lpEnd, TEXT("Computer"));

        if (m_pComputerCSEList)
        {
            FreeCSEData(m_pComputerCSEList);
            m_pComputerCSEList = NULL;
        }

        BuildCSEList (&m_pComputerCSEList, lpNamespace, &m_bComputerCSEError, &m_bComputerGPCoreError);

        if (!m_bArchiveData)
        {
            QueryRSoPPolicySettingStatusInstances (lpNamespace);
        }

        LocalFree (lpNamespace);
    }
    else
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::BuildCSELists: Failed to allocate memory for namespace with %d"),
                 GetLastError()));
    }
}

BOOL CRSOPComponentData::AddCSENode(LPTSTR lpName, LPTSTR lpGUID, DWORD dwStatus,
                                    ULONG ulLoggingStatus, SYSTEMTIME *pBeginTime, SYSTEMTIME *pEndTime,
                                    LPCSEITEM *lpList, BOOL *bCSEError, BOOL *bGPCoreError,
                                    LPSOURCEENTRY lpSources)
{
    DWORD dwSize;
    LPCSEITEM lpItem, lpTemp;
    GUID guid;


    //
    // Calculate the size of the new item
    //

    dwSize = sizeof (CSEITEM);

    dwSize += ((lstrlen(lpName) + 1) * sizeof(TCHAR));
    dwSize += ((lstrlen(lpGUID) + 1) * sizeof(TCHAR));


    //
    // Allocate space for it
    //

    lpItem = (LPCSEITEM) LocalAlloc (LPTR, dwSize);

    if (!lpItem) {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::AddCSENode: Failed to allocate memory with %d"),
                 GetLastError()));
        return FALSE;
    }


    //
    // Fill in item
    //

    lpItem->lpName = (LPTSTR)(((LPBYTE)lpItem) + sizeof(CSEITEM));
    lstrcpy (lpItem->lpName, lpName);

    lpItem->lpGUID = lpItem->lpName + lstrlen (lpItem->lpName) + 1;
    lstrcpy (lpItem->lpGUID, lpGUID);

    lpItem->dwStatus = dwStatus;
    lpItem->ulLoggingStatus = ulLoggingStatus;
    lpItem->lpEventSources = lpSources;

    CopyMemory ((LPBYTE)&lpItem->BeginTime, pBeginTime, sizeof(SYSTEMTIME));
    CopyMemory ((LPBYTE)&lpItem->EndTime, pEndTime, sizeof(SYSTEMTIME));


    //
    // Add item to the link list
    //

    if (*lpList)
    {
        StringToGuid( lpGUID, &guid);

        if (IsNullGUID (&guid))
        {
            lpItem->pNext = *lpList;
            *lpList = lpItem;
        }
        else
        {
            lpTemp = *lpList;

            while (lpTemp)
            {
                if (!lpTemp->pNext)
                {
                    lpTemp->pNext = lpItem;
                    break;
                }
                lpTemp = lpTemp->pNext;
            }
        }
    }
    else
    {
        *lpList = lpItem;
    }


    //
    // Set the error flag if appropriate
    //

    if ((dwStatus != ERROR_SUCCESS) || (ulLoggingStatus == 2))
    {
        StringToGuid( lpGUID, &guid);

        if (IsNullGUID (&guid))
        {
            *bGPCoreError = TRUE;
        }
        else
        {
            *bCSEError =  TRUE;
        }
    }

    return TRUE;
}

VOID CRSOPComponentData::FreeCSEData(LPCSEITEM lpList)
{
    LPCSEITEM lpTemp;


    do {
        lpTemp = lpList->pNext;
        if (m_pEvents)
        {
            m_pEvents->FreeSourceData (lpList->lpEventSources);
        }
        LocalFree (lpList);
        lpList = lpTemp;

    } while (lpTemp);
}

void CRSOPComponentData::InitializeErrorsDialog(HWND hDlg, LPCSEITEM lpList)
{
    RECT rect;
    WCHAR szBuffer[256];
    LV_COLUMN lvcol;
    LONG lWidth;
    INT cxName = 0, cxStatus = 0, iIndex = 0, iDefault = 0;
    DWORD dwCount = 0;
    HWND hList = GetDlgItem(hDlg, IDC_LIST1);
    LPCSEITEM lpTemp;
    LVITEM item;
    GUID guid;
    BOOL bGPCoreFailed = FALSE;


    //
    // Count the number of components
    //

    lpTemp = lpList;

    while (lpTemp)
    {
        lpTemp = lpTemp->pNext;
        dwCount++;
    }


    //
    // Decide on the column widths
    //

    GetClientRect(hList, &rect);

    if (dwCount > (DWORD)ListView_GetCountPerPage(hList))
    {
        lWidth = (rect.right - rect.left) - GetSystemMetrics(SM_CYHSCROLL);
    }
    else
    {
        lWidth = rect.right - rect.left;
    }


    cxStatus = (lWidth * 35) / 100;
    cxName = lWidth - cxStatus;


    //
    // Insert the component name column and then the status column
    //

    memset(&lvcol, 0, sizeof(lvcol));

    lvcol.mask = LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
    lvcol.fmt = LVCFMT_LEFT;
    lvcol.pszText = szBuffer;
    lvcol.cx = cxName;
    LoadString(g_hInstance, IDS_COMPONENT_NAME, szBuffer, ARRAYSIZE(szBuffer));
    ListView_InsertColumn(hList, 0, &lvcol);


    lvcol.cx = cxStatus;
    LoadString(g_hInstance, IDS_STATUS, szBuffer, ARRAYSIZE(szBuffer));
    ListView_InsertColumn(hList, 1, &lvcol);


    //
    // Turn on some listview features
    //

    SendMessage(hList, LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
                LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);


    //
    // Insert the CSE's
    //

    lpTemp = lpList;

    while (lpTemp)
    {
        ZeroMemory (&item, sizeof(item));

        item.mask = LVIF_TEXT | LVIF_PARAM;
        item.iItem = iIndex;
        item.pszText = lpTemp->lpName;
        item.lParam = (LPARAM) lpTemp;
        iIndex = ListView_InsertItem (hList, &item);


        if (bGPCoreFailed)
        {
            LoadString(g_hInstance, IDS_CSE_NA, szBuffer, ARRAYSIZE(szBuffer));
        }
        else if ((lpTemp->dwStatus == ERROR_SUCCESS) && (lpTemp->ulLoggingStatus != 2))
        {
            if (lpTemp->ulLoggingStatus == 3)
            {
                LoadString(g_hInstance, IDS_SUCCESS2, szBuffer, ARRAYSIZE(szBuffer));
            }
            else
            {
                LoadString(g_hInstance, IDS_SUCCESS, szBuffer, ARRAYSIZE(szBuffer));
            }
        }
        else if (lpTemp->dwStatus == E_PENDING)
        {
            LoadString(g_hInstance, IDS_PENDING, szBuffer, ARRAYSIZE(szBuffer));
        }
        else if (lpTemp->dwStatus == ERROR_OVERRIDE_NOCHANGES)
        {
            LoadString(g_hInstance, IDS_WARNING, szBuffer, ARRAYSIZE(szBuffer));
        }
        else
        {
            if (lpTemp->ulLoggingStatus == 3)
            {
                LoadString(g_hInstance, IDS_FAILED2, szBuffer, ARRAYSIZE(szBuffer));
            }
            else
            {
                LoadString(g_hInstance, IDS_FAILED, szBuffer, ARRAYSIZE(szBuffer));
            }
        }


        item.mask = LVIF_TEXT;
        item.pszText = szBuffer;
        item.iItem = iIndex;
        item.iSubItem = 1;
        ListView_SetItem(hList, &item);


        //
        // Check if GPCore failed
        //

        StringToGuid( lpTemp->lpGUID, &guid);

        if (IsNullGUID (&guid))
        {
            if (lpTemp->dwStatus != ERROR_SUCCESS)
            {
                bGPCoreFailed = TRUE;
            }
        }

        lpTemp = lpTemp->pNext;
        iIndex++;
    }


    //
    // Select the first non-successful item
    //


    iIndex = 0;

    while (iIndex < ListView_GetItemCount(hList))
    {
        ZeroMemory (&item, sizeof(item));
        item.mask = LVIF_PARAM;
        item.iItem = iIndex;

        if (!ListView_GetItem (hList, &item))
        {
            break;
        }

        if (item.lParam)
        {
            lpTemp = (LPCSEITEM) item.lParam;

            if ((lpTemp->dwStatus != ERROR_SUCCESS) || (lpTemp->ulLoggingStatus == 2))
            {
                iDefault = iIndex;
                break;
            }
        }

        iIndex++;
    }

    item.mask = LVIF_STATE;
    item.iItem = iDefault;
    item.iSubItem = 0;
    item.state = LVIS_SELECTED | LVIS_FOCUSED;
    item.stateMask = LVIS_SELECTED | LVIS_FOCUSED;

    SendMessage (hList, LVM_SETITEMSTATE, iDefault, (LPARAM) &item);
    SendMessage (hList, LVM_ENSUREVISIBLE, iDefault, FALSE);
}

void CRSOPComponentData::RefreshErrorInfo (HWND hDlg)
{
    HWND hList = GetDlgItem(hDlg, IDC_LIST1);
    HWND hEdit = GetDlgItem(hDlg, IDC_EDIT1);
    LPCSEITEM lpItem;
    LVITEM item;
    INT iIndex;
    TCHAR szBuffer[300];
    LPTSTR lpMsg;
    TCHAR szDate[100];
    TCHAR szTime[100];
    TCHAR szFormat[80];
    FILETIME ft, ftLocal;
    SYSTEMTIME systime;
    LPOLESTR lpEventLogText = NULL;
    CHARFORMAT2 chFormat;
    BOOL bBold = FALSE;
    GUID guid;

    iIndex = ListView_GetNextItem (hList, -1, LVNI_ALL | LVNI_SELECTED);

    if (iIndex != -1)
    {
        //
        // Get the CSEITEM pointer
        //

        item.mask = LVIF_PARAM;
        item.iItem = iIndex;
        item.iSubItem = 0;

        if (!ListView_GetItem (hList, &item))
        {
            return;
        }

        lpItem = (LPCSEITEM) item.lParam;

        if (!lpItem)
        {
            return;
        }


        SendMessage (hEdit, WM_SETREDRAW, FALSE, 0);

        //
        // Set the time information
        //

        SendMessage (hEdit, EM_SETSEL, 0, (LPARAM) -1);

        SystemTimeToFileTime (&lpItem->EndTime, &ft);
        FileTimeToLocalFileTime (&ft, &ftLocal);
        FileTimeToSystemTime (&ftLocal, &systime);


        GetDateFormat (LOCALE_USER_DEFAULT, DATE_LONGDATE, &systime,
                       NULL, szDate, ARRAYSIZE (szDate));

        GetTimeFormat (LOCALE_USER_DEFAULT, 0, &systime,
                       NULL, szTime, ARRAYSIZE (szTime));

        LoadString (g_hInstance, IDS_DATETIMEFORMAT, szFormat, ARRAYSIZE(szFormat));
        wsprintf (szBuffer, szFormat, szDate, szTime);


        //
        // Turn italic on
        //

        ZeroMemory (&chFormat, sizeof(chFormat));
        chFormat.cbSize = sizeof(chFormat);
        chFormat.dwMask = CFM_ITALIC;
        chFormat.dwEffects = CFE_ITALIC;

        SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                     (LPARAM) &chFormat);


        SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);


        if (lpItem->ulLoggingStatus == 3)
        {
            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) TEXT("\r\n\r\n"));

            LoadString(g_hInstance, IDS_LEGACYCSE, szBuffer, ARRAYSIZE(szBuffer));
            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);

            LoadString(g_hInstance, IDS_LEGACYCSE1, szBuffer, ARRAYSIZE(szBuffer));
            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);
        }


        //
        // Turn italic off
        //

        ZeroMemory (&chFormat, sizeof(chFormat));
        chFormat.cbSize = sizeof(chFormat);
        chFormat.dwMask = CFM_ITALIC;

        SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                     (LPARAM) &chFormat);


        //
        // Put a blank line in between the time and the main message
        //

        SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
        SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) TEXT("\r\n\r\n"));


        //
        // Set the main message
        //

        if (lpItem->ulLoggingStatus == 2)
        {
            if ( lpItem->dwStatus == ERROR_SUCCESS )
                LoadString(g_hInstance, IDS_LOGGINGFAILED, szBuffer, ARRAYSIZE(szBuffer));
            else
                LoadString(g_hInstance, IDS_FAILEDMSG2, szBuffer, ARRAYSIZE(szBuffer));
            bBold = TRUE;
        }
        else if (lpItem->dwStatus == ERROR_SUCCESS)
        {
            LoadString(g_hInstance, IDS_SUCCESSMSG, szBuffer, ARRAYSIZE(szBuffer));
        }
        else if (lpItem->dwStatus == E_PENDING)
        {
            LoadString(g_hInstance, IDS_PENDINGMSG, szBuffer, ARRAYSIZE(szBuffer));
        }
        else if (lpItem->dwStatus == ERROR_OVERRIDE_NOCHANGES)
        {
            LoadString(g_hInstance, IDS_OVERRIDE, szBuffer, ARRAYSIZE(szBuffer));
            bBold = TRUE;
        }
        else if (lpItem->dwStatus == ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED)
        {
            LoadString(g_hInstance, IDS_SYNC_REQUIRED, szBuffer, ARRAYSIZE(szBuffer));
            bBold = TRUE;
        }
        else
        {
            LoadString(g_hInstance, IDS_FAILEDMSG1, szBuffer, ARRAYSIZE(szBuffer));
            bBold = TRUE;
        }


        if (bBold)
        {
            //
            // Turn bold on
            //

            ZeroMemory (&chFormat, sizeof(chFormat));
            chFormat.cbSize = sizeof(chFormat);
            chFormat.dwMask = CFM_BOLD;
            chFormat.dwEffects = CFE_BOLD;

            SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                         (LPARAM) &chFormat);
        }

        lpMsg = (LPTSTR) LocalAlloc(LPTR, (lstrlen(lpItem->lpName) + lstrlen(szBuffer) + 1) * sizeof(TCHAR));

        if (!lpMsg)
        {
            SendMessage (hEdit, WM_SETREDRAW, TRUE, 0);
            InvalidateRect (hEdit, NULL, TRUE);
            UpdateWindow (hEdit);
            return;
        }

        wsprintf (lpMsg, szBuffer, lpItem->lpName);
        SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
        SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) lpMsg);
        LocalFree (lpMsg);


        //
        // Even if the CSE was successful or if it returned E_PENDING, continue on to get the
        // eventlog msgs
        //

        StringToGuid( lpItem->lpGUID, &guid);

        if (!((lpItem->dwStatus == ERROR_SUCCESS) || (lpItem->dwStatus == E_PENDING)))
        {
            //
            // Print the error code if appropriate
            //

            if (lpItem->dwStatus != ERROR_OVERRIDE_NOCHANGES && lpItem->dwStatus != ERROR_SYNC_FOREGROUND_REFRESH_REQUIRED )
            {
                lpMsg = (LPTSTR) LocalAlloc(LPTR, 300 * sizeof(TCHAR));

                if (lpMsg)
                {
                    LoadMessage (lpItem->dwStatus, lpMsg, 300);

                    SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
                    SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) lpMsg);

                    LocalFree (lpMsg);
                }
            }


            //
            // Special case GPCore to have an additional message
            //

            if (IsNullGUID (&guid))
            {
                LoadString(g_hInstance, IDS_GPCOREFAIL, szBuffer, ARRAYSIZE(szBuffer));
                SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
                SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);
            }

        }
        else {

            if (lpItem->ulLoggingStatus == 2) {

                //
                // Special case GPCore to have an additional message if logging failed
                //

                if (IsNullGUID (&guid))
                {
                    LoadString(g_hInstance, IDS_GPCORE_LOGGINGFAIL, szBuffer, ARRAYSIZE(szBuffer));
                    SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
                    SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);
                }
            }
        }


        if (bBold)
        {
            //
            // Turn bold off
            //

            ZeroMemory (&chFormat, sizeof(chFormat));
            chFormat.cbSize = sizeof(chFormat);
            chFormat.dwMask = CFM_BOLD;

            SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                         (LPARAM) &chFormat);
        }


        //
        // Get any event log text for this CSE
        //

        if (m_pEvents && SUCCEEDED(m_pEvents->GetCSEEntries(&lpItem->BeginTime, &lpItem->EndTime,
                                                            lpItem->lpEventSources, &lpEventLogText,
                                                            (IsNullGUID (&guid)))))
        {
            //
            // Put a blank line between the main message and the Additional information header
            //

            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) TEXT("\r\n"));


            //
            // Turn underline on
            //

            ZeroMemory (&chFormat, sizeof(chFormat));
            chFormat.cbSize = sizeof(chFormat);
            chFormat.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
            chFormat.dwEffects = CFE_UNDERLINE;
            chFormat.bUnderlineType = CFU_UNDERLINE;

            SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                         (LPARAM) &chFormat);

            LoadString(g_hInstance, IDS_ADDITIONALINFO, szBuffer, ARRAYSIZE(szBuffer));
            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) szBuffer);


            //
            // Turn underline off
            //

            ZeroMemory (&chFormat, sizeof(chFormat));
            chFormat.cbSize = sizeof(chFormat);
            chFormat.dwMask = CFM_UNDERLINETYPE | CFM_UNDERLINE;
            chFormat.dwEffects = CFE_UNDERLINE;
            chFormat.bUnderlineType = CFU_UNDERLINENONE;

            SendMessage (hEdit, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD,
                         (LPARAM) &chFormat);


            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) TEXT("\r\n"));


            //
            //  Add the event log info to the edit control
            //

            SendMessage (hEdit, EM_SETSEL, (WPARAM)-1, (LPARAM) -1);
            SendMessage (hEdit, EM_REPLACESEL, 0, (LPARAM) lpEventLogText);

            CoTaskMemFree (lpEventLogText);
        }

        SendMessage (hEdit, EM_SETSEL, 0, 0);
        SendMessage (hEdit, EM_SCROLLCARET, 0, 0);

        SendMessage (hEdit, WM_SETREDRAW, TRUE, 0);
        InvalidateRect (hEdit, NULL, TRUE);
        UpdateWindow (hEdit);
    }

}

void CRSOPComponentData::OnSaveAs (HWND hDlg)
{
    OPENFILENAME ofn;
    TCHAR szFilter[100];
    LPTSTR lpTemp;
    TCHAR szFile[2*MAX_PATH];
    HANDLE hFile;
    DWORD dwSize, dwBytesWritten;


    //
    // Load the filter string and replace the # signs with nulls
    //

    LoadString (g_hInstance, IDS_ERRORFILTER, szFilter, ARRAYSIZE(szFilter));


    lpTemp = szFilter;

    while (*lpTemp)
    {
        if (*lpTemp == TEXT('#'))
            *lpTemp = TEXT('\0');

        lpTemp++;
    }


    //
    // Call the Save common dialog
    //

    szFile[0] = TEXT('\0');
    ZeroMemory (&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hDlg;
    ofn.lpstrFilter = szFilter;
    ofn.nFilterIndex = 1;
    ofn.lpstrFile = szFile;
    ofn.nMaxFile = 2*MAX_PATH;
    ofn.lpstrDefExt = TEXT("txt");
    ofn.Flags = OFN_NOCHANGEDIR | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;

    if (!GetSaveFileName (&ofn))
    {
        return;
    }


    SetWaitCursor ();

    //
    // Create the text file
    //

    hFile = CreateFile (szFile, GENERIC_WRITE, 0, NULL,
                        CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
                        NULL);

    if (hFile == INVALID_HANDLE_VALUE)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::OnSaveAs: CreateFile failed with %d"), GetLastError()));
        ClearWaitCursor ();
        return;
    }


    //
    // Get the text out of the edit control
    //

    dwSize = (DWORD) SendDlgItemMessage (hDlg, IDC_EDIT1, WM_GETTEXTLENGTH, 0, 0);

    lpTemp = (LPTSTR) LocalAlloc (LPTR, (dwSize+2) * sizeof(TCHAR));

    if (!lpTemp)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::OnSaveAs: LocalAlloc failed with %d"), GetLastError()));
        CloseHandle (hFile);
        ClearWaitCursor ();
        return;
    }

    SendDlgItemMessage (hDlg, IDC_EDIT1, WM_GETTEXT, (dwSize+1), (LPARAM) lpTemp);



    //
    // Save it to the new file
    //

    WriteFile(hFile, L"\xfeff\r\n", 3 * sizeof(WCHAR), &dwBytesWritten, NULL);

    if (!WriteFile (hFile, lpTemp, (dwSize * sizeof(TCHAR)), &dwBytesWritten, NULL) ||
        (dwBytesWritten != (dwSize * sizeof(TCHAR))))
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPComponentData::OnSaveAs: Failed to text with %d"),
                 GetLastError()));
    }


    LocalFree (lpTemp);
    CloseHandle (hFile);
    ClearWaitCursor ();

}

INT_PTR CALLBACK CRSOPComponentData::RSOPErrorsMachineProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        if (pCD)
        {
            pCD->InitializeErrorsDialog(hDlg, pCD->m_pComputerCSEList);
            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        }
        break;

    case WM_COMMAND:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD)
        {
            if (LOWORD(wParam) == IDC_BUTTON1)
            {
                pCD->OnSaveAs(hDlg);
            }

            if (LOWORD(wParam) == IDCANCEL)
            {
                SendMessage(GetParent(hDlg), message, wParam, lParam);
            }
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpHdr = (LPNMHDR)lParam;

            if (lpHdr->code == LVN_ITEMCHANGED)
            {
                PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            }
        }
        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD)
        {
            pCD->RefreshErrorInfo (hDlg);
        }
        break;

    case WM_HELP:      // F1
        WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
        (ULONG_PTR) (LPSTR) aErrorsHelpIds);
        break;


    case WM_CONTEXTMENU:
        // right mouse click
        WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
        (ULONG_PTR) (LPSTR) aErrorsHelpIds);
        return TRUE;

    }
    return FALSE;
}

INT_PTR CALLBACK CRSOPComponentData::RSOPErrorsUserProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    CRSOPComponentData * pCD;

    switch (message)
    {
    case WM_INITDIALOG:
        pCD = (CRSOPComponentData *) (((LPPROPSHEETPAGE)lParam)->lParam);
        SetWindowLongPtr (hDlg, DWLP_USER, (LONG_PTR) pCD);

        if (pCD)
        {
            pCD->InitializeErrorsDialog(hDlg, pCD->m_pUserCSEList);
            PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
        }
        break;

    case WM_COMMAND:

        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD)
        {
            if (LOWORD(wParam) == IDC_BUTTON1)
            {
                pCD->OnSaveAs(hDlg);
            }

            if (LOWORD(wParam) == IDCANCEL)
            {
                SendMessage(GetParent(hDlg), message, wParam, lParam);
            }
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpHdr = (LPNMHDR)lParam;

            if (lpHdr->code == LVN_ITEMCHANGED)
            {
                PostMessage (hDlg, WM_REFRESHDISPLAY, 0, 0);
            }
        }
        break;
        break;

    case WM_REFRESHDISPLAY:
        pCD = (CRSOPComponentData *) GetWindowLongPtr (hDlg, DWLP_USER);
        if (pCD)
        {
            pCD->RefreshErrorInfo (hDlg);
        }
        break;

    case WM_HELP:      // F1
        WinHelp((HWND)((LPHELPINFO) lParam)->hItemHandle, HELP_FILE, HELP_WM_HELP,
        (ULONG_PTR) (LPSTR) aErrorsHelpIds);
        break;


    case WM_CONTEXTMENU:
        // right mouse click
        WinHelp((HWND) wParam, HELP_FILE, HELP_CONTEXTMENU,
        (ULONG_PTR) (LPSTR) aErrorsHelpIds);
        return TRUE;

    }
    return FALSE;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory object implementation                                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

CRSOPComponentDataCF::CRSOPComponentDataCF()
{
    m_cRef = 1;
    InterlockedIncrement(&g_cRefThisDll);
}

CRSOPComponentDataCF::~CRSOPComponentDataCF()
{
    InterlockedDecrement(&g_cRefThisDll);
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory object implementation (IUnknown)                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


STDMETHODIMP_(ULONG)
CRSOPComponentDataCF::AddRef()
{
    return ++m_cRef;
}

STDMETHODIMP_(ULONG)
CRSOPComponentDataCF::Release()
{
    if (--m_cRef == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP
CRSOPComponentDataCF::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IClassFactory))
    {
        *ppv = (LPCLASSFACTORY)this;
        m_cRef++;
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory object implementation (IClassFactory)                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


STDMETHODIMP
CRSOPComponentDataCF::CreateInstance(LPUNKNOWN   pUnkOuter,
                                     REFIID      riid,
                                     LPVOID FAR* ppvObj)
{
    *ppvObj = NULL;

    if (pUnkOuter)
        return CLASS_E_NOAGGREGATION;

    CRSOPComponentData *pComponentData = new CRSOPComponentData(); // ref count == 1

    if (!pComponentData)
        return E_OUTOFMEMORY;

    HRESULT hr = pComponentData->QueryInterface(riid, ppvObj);
    pComponentData->Release();                       // release initial ref

    return hr;
}


STDMETHODIMP
CRSOPComponentDataCF::LockServer(BOOL fLock)
{
    return E_NOTIMPL;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// IWbemObjectSink implementation                                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

CCreateSessionSink::CCreateSessionSink(HWND hProgress, DWORD dwThread)
{
    m_cRef = 1;
    InterlockedIncrement(&g_cRefThisDll);

    m_hProgress = hProgress;
    m_dwThread  = dwThread;

    m_bSendQuitMessage = FALSE;
    m_hrSuccess  = S_OK;
    m_pNameSpace = NULL;
    m_ulErrorInfo = 0;


    SendMessage (hProgress, PBM_SETPOS, 0, 0);
}

CCreateSessionSink::~CCreateSessionSink()
{
    if (m_pNameSpace)
    {
        SysFreeString (m_pNameSpace);
    }

    InterlockedDecrement(&g_cRefThisDll);
}

STDMETHODIMP_(ULONG)
CCreateSessionSink::AddRef()
{
    return ++m_cRef;
}

STDMETHODIMP_(ULONG)
CCreateSessionSink::Release()
{
    if (--m_cRef == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP
CCreateSessionSink::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid, IID_IUnknown))
    {
        *ppv = (IUnknown *)this;
        m_cRef++;
        return S_OK;
    }
    else if (IsEqualIID(riid, IID_IWbemObjectSink))
    {
        *ppv = (IWbemObjectSink *)this;
        m_cRef++;
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}

STDMETHODIMP CCreateSessionSink::SendQuitMessage (BOOL bSendQuitMessage)
{
    m_bSendQuitMessage = bSendQuitMessage;
    return S_OK;
}

STDMETHODIMP CCreateSessionSink::GetResult (HRESULT *hSuccess)
{
    *hSuccess = m_hrSuccess;
    return S_OK;
}

STDMETHODIMP CCreateSessionSink::GetNamespace (BSTR *pNamespace)
{
    *pNamespace = m_pNameSpace;
    return S_OK;
}

STDMETHODIMP CCreateSessionSink::GetErrorInfo (ULONG *pulErrorInfo)
{
    *pulErrorInfo = m_ulErrorInfo;
    return S_OK;
}

STDMETHODIMP CCreateSessionSink::Indicate(long lObjCount, IWbemClassObject **pArray)
{
    LONG lIndex;
    HRESULT hr;
    IWbemClassObject *pObject;

    for (lIndex = 0; lIndex < lObjCount; lIndex++)
    {
        pObject = pArray[lIndex];

        hr = GetParameter(pObject, TEXT("hResult"), m_hrSuccess);

        if (SUCCEEDED(hr))
        {
            if (SUCCEEDED(m_hrSuccess))
            {
                GetParameterBSTR(pObject, TEXT("nameSpace"), m_pNameSpace);
            }
            else
            {
                GetParameter(pObject, TEXT("ExtendedInfo"), m_ulErrorInfo);
            }
        }

        DebugMsg((DM_VERBOSE, TEXT("CCreateSessionSink::Indicate:  Status:        0x%x"), m_hrSuccess));
        DebugMsg((DM_VERBOSE, TEXT("CCreateSessionSink::Indicate:  Namespace:     %s"), m_pNameSpace ? m_pNameSpace : TEXT("Null")));
        DebugMsg((DM_VERBOSE, TEXT("CCreateSessionSink::Indicate:  ExtendedInfo:  %d"), m_ulErrorInfo));
    }

    return WBEM_S_NO_ERROR;
}

STDMETHODIMP CCreateSessionSink::SetStatus(LONG lFlags, HRESULT hResult,
                                      BSTR strParam, IWbemClassObject *pObjParam)
{
    HRESULT hr;
    ULONG ulValue;


    if (lFlags == WBEM_STATUS_PROGRESS)
    {
        if (m_hProgress)
        {
            //
            //  The hResult arg contains both the denominator
            //  and the numerator packed together.
            //
            //  Denominator is in the high word
            //  Numerator is in the low word
            //

            ulValue = MAKELONG(HIWORD(hResult), 0);
            SendMessage (m_hProgress, PBM_SETRANGE32, 0, (LPARAM) ulValue);

            ulValue = MAKELONG(LOWORD(hResult), 0);
            SendMessage (m_hProgress, PBM_SETPOS, (WPARAM) ulValue, 0);

            DebugMsg((DM_VERBOSE, TEXT("CCreateSessionSink::SetStatus:  Precentage complete:  %d"), ulValue));
        }
    }

    if (lFlags == WBEM_STATUS_COMPLETE)
    {
        if (m_bSendQuitMessage)
        {
            if (hResult != WBEM_S_NO_ERROR)
            {
                m_hrSuccess = hResult;
                DebugMsg((DM_VERBOSE, TEXT("CCreateSessionSink::SetStatus:  Setting error status to:  0x%x"), m_hrSuccess));
            }

            PostThreadMessage (m_dwThread, WM_QUIT, 0, 0);
        }
    }

    return WBEM_S_NO_ERROR;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory implementation for rsop context menu                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

CRSOPCMenuCF::CRSOPCMenuCF()
{
    m_cRef = 1;
    InterlockedIncrement(&g_cRefThisDll);
}

CRSOPCMenuCF::~CRSOPCMenuCF()
{
    InterlockedDecrement(&g_cRefThisDll);
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory object implementation (IUnknown)                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


STDMETHODIMP_(ULONG)
CRSOPCMenuCF::AddRef()
{
    return InterlockedIncrement(&m_cRef);
}

STDMETHODIMP_(ULONG)
CRSOPCMenuCF::Release()
{
    m_cRef = InterlockedDecrement(&m_cRef);

    if (m_cRef == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP
CRSOPCMenuCF::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IClassFactory))
    {
        *ppv = (LPCLASSFACTORY)this;
        AddRef();
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Class factory object implementation (IClassFactory)                       //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


STDMETHODIMP
CRSOPCMenuCF::CreateInstance(LPUNKNOWN   pUnkOuter,
                             REFIID      riid,
                             LPVOID FAR* ppvObj)
{
    *ppvObj = NULL;

    if (pUnkOuter)
        return CLASS_E_NOAGGREGATION;

    CRSOPCMenu *pRsopCMenu = new CRSOPCMenu(); // ref count == 1

    if (!pRsopCMenu)
        return E_OUTOFMEMORY;

    HRESULT hr = pRsopCMenu->QueryInterface(riid, ppvObj);
    pRsopCMenu->Release();                       // release initial ref

    return hr;
}


STDMETHODIMP
CRSOPCMenuCF::LockServer(BOOL fLock)
{
    return E_NOTIMPL;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPCMenu implementation for rsop context menu                          //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

CRSOPCMenu::CRSOPCMenu()
{
    m_cRef = 1;
    m_lpDSObject = NULL;
    m_szDN = NULL;
    m_szDomain = NULL;
    InterlockedIncrement(&g_cRefThisDll);
}

CRSOPCMenu::~CRSOPCMenu()
{
    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu:: Context menu destroyed")));
    InterlockedDecrement(&g_cRefThisDll);

    if (m_lpDSObject)
        LocalFree(m_lpDSObject);
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPCMenu implementation (IUnknown)                                      //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

STDMETHODIMP_(ULONG)
CRSOPCMenu::AddRef()
{
    return InterlockedIncrement(&m_cRef);
}

STDMETHODIMP_(ULONG)
CRSOPCMenu::Release()
{
    m_cRef = InterlockedDecrement(&m_cRef);

    if (m_cRef == 0)
    {
        delete this;
        return 0;
    }

    return m_cRef;
}

STDMETHODIMP
CRSOPCMenu::QueryInterface(REFIID riid, LPVOID FAR* ppv)
{
    if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IExtendContextMenu))
    {
        *ppv = (LPCLASSFACTORY)this;
        AddRef();
        return S_OK;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// CRSOPCMenu implementation (IExtendContextMenu)                            //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


STDMETHODIMP        
CRSOPCMenu::AddMenuItems(LPDATAOBJECT piDataObject,
                         LPCONTEXTMENUCALLBACK piCallback,
                         long * pInsertionAllowed)
{
    FORMATETC       fm;
    STGMEDIUM       medium;
    LPDSOBJECTNAMES lpNames;
    CONTEXTMENUITEM ctxMenu;
    HRESULT         hr=S_OK;
    LPTSTR          lpTemp;
    HANDLE          hTokenUser = 0;
    BOOL            bPlAccessGranted = FALSE, bLoAccessGranted = FALSE;
    BOOL            bLoNeeded = TRUE;


    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: Entering")));

    
    // if we are not allowed in the tasks menu quit
    if (!((*pInsertionAllowed) & CCM_INSERTIONALLOWED_TASK )) {
        return S_OK;
    }

    
    //
    // Ask DS admin for the ldap path to the selected object
    //

    ZeroMemory (&fm, sizeof(fm));
    fm.cfFormat = (WORD)m_cfDSObjectName;
    fm.tymed = TYMED_HGLOBAL;

    ZeroMemory (&medium, sizeof(medium));
    medium.tymed = TYMED_HGLOBAL;

    medium.hGlobal = GlobalAlloc (GMEM_MOVEABLE | GMEM_NODISCARD, 512);

    if (medium.hGlobal)
    {
        hr = piDataObject->GetData(&fm, &medium);

        if (SUCCEEDED(hr))
        {
            lpNames = (LPDSOBJECTNAMES) GlobalLock (medium.hGlobal);

            if (lpNames) {
                lpTemp = (LPWSTR) (((LPBYTE)lpNames) + lpNames->aObjects[0].offsetName);

                if (m_lpDSObject)
                {
                    LocalFree (m_lpDSObject);
                }

                m_lpDSObject = (LPTSTR) LocalAlloc (LPTR, (lstrlen (lpTemp) + 1) * sizeof(TCHAR));

                if (m_lpDSObject)
                {
                    lstrcpy (m_lpDSObject, lpTemp);
                    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: LDAP path from DS Admin %s"), m_lpDSObject));
                }
                else {
                    hr = HRESULT_FROM_WIN32(GetLastError());
                }
                
                m_rsopHint = RSOPHintUnknown;

                if (lpNames->aObjects[0].offsetClass) {
                    lpTemp = (LPWSTR) (((LPBYTE)lpNames) + lpNames->aObjects[0].offsetClass);

                    if (lstrcmpi (lpTemp, TEXT("domainDNS")) == 0)
                    {
                        m_rsopHint = RSOPHintDomain;
                    }
                    else if (lstrcmpi (lpTemp, TEXT("organizationalUnit")) == 0)
                    {
                        m_rsopHint = RSOPHintOrganizationalUnit;
                    }
                    else if (lstrcmpi (lpTemp, TEXT("site")) == 0)
                    {
                        m_rsopHint = RSOPHintSite;
                    }
                    else if (lstrcmpi (lpTemp, TEXT("user")) == 0)
                    {
                        m_rsopHint = RSOPHintUser;
                    }
                    else if (lstrcmpi (lpTemp, TEXT("computer")) == 0)
                    {
                        m_rsopHint = RSOPHintMachine;
                    }

                    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: m_rsopHint = %d"), m_rsopHint));
                } else {
                    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: No objectclass defined.")));
                }

                GlobalUnlock (medium.hGlobal);

            }
            else {
                hr = HRESULT_FROM_WIN32(GetLastError());
            }
        }

        GlobalFree(medium.hGlobal);
    }
    else {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }


    //
    // if we got our data as expected add the menu
    //

    if (SUCCEEDED(hr)) {
        LPWSTR  szContainer = NULL;

        //
        // Now check whether the user has right to do rsop generation
        // if the container is anything other than the Site
        //

        if (m_szDomain) {
            LocalFree(m_szDomain);
            m_szDomain = NULL;
        }

        ParseDN(m_lpDSObject, &m_szDomain, &m_szDN, &szContainer);


        if ((m_rsopHint == RSOPHintMachine) || (m_rsopHint == RSOPHintUser)) 
            bLoNeeded = TRUE;
        else
            bLoNeeded = FALSE;


        if (m_rsopHint != RSOPHintSite) {
            if (!OpenThreadToken (GetCurrentThread(), TOKEN_IMPERSONATE | TOKEN_DUPLICATE | TOKEN_QUERY, TRUE, &hTokenUser)) {
                if (!OpenProcessToken(GetCurrentProcess(), TOKEN_IMPERSONATE | TOKEN_DUPLICATE | TOKEN_QUERY, &hTokenUser)) {
                    DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::AddMenuItems: Couldn't get process token. Error %d"), GetLastError()));
                    bLoAccessGranted = bPlAccessGranted = FALSE;
                }
            }


            if (hTokenUser) {
                DWORD   dwErr;

                dwErr = CheckAccessForPolicyGeneration( hTokenUser, szContainer, m_szDomain, FALSE, &bPlAccessGranted);

                if (dwErr != ERROR_SUCCESS) {
                    DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::AddMenuItems: CheckAccessForPolicyGeneration. Error %d"), dwErr));
                    bPlAccessGranted = FALSE;
                }


                if (bLoNeeded) {                  
                    dwErr = CheckAccessForPolicyGeneration( hTokenUser, szContainer, m_szDomain, TRUE, &bLoAccessGranted);
                    
                    if (dwErr != ERROR_SUCCESS) {
                        DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::AddMenuItems: CheckAccessForPolicyGeneration. Error %d"), dwErr));
                        bLoAccessGranted = FALSE;
                    }
                }

                CloseHandle(hTokenUser);
            }

        }
        else {
            bPlAccessGranted = TRUE;
        }


        if (bPlAccessGranted) {
            DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: User has right to do Planning RSOP")));

            if ( ! IsPlanningModeAllowed() )
            {
                bPlAccessGranted = FALSE;
                DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: Planning mode is not available because planning mode view is not implemented on non-server SKUs")));
            }
        }

        if (bLoAccessGranted) {
            DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: User has right to do Logging RSOP")));
        }



        //
        // Add the Context menu appropriately
        //
        
        WCHAR szMenuName[150];

        memset(&ctxMenu, 0, sizeof(ctxMenu));

        LoadString (g_hInstance, IDS_RSOP_PLANNING, szMenuName, ARRAYSIZE(szMenuName));
        ctxMenu.strName = szMenuName;
        ctxMenu.strStatusBarText = NULL;
        ctxMenu.lCommandID = RSOP_LAUNCH_PLANNING;  // no sp. flags
        ctxMenu.lInsertionPointID = CCM_INSERTIONPOINTID_3RDPARTY_TASK;
        
        if (bPlAccessGranted)
            ctxMenu.fFlags = MF_ENABLED;
        else
            ctxMenu.fFlags = MF_GRAYED | MF_DISABLED;

        hr = piCallback->AddItem(&ctxMenu);

        if (bLoNeeded) {
            LoadString (g_hInstance, IDS_RSOP_LOGGING, szMenuName, ARRAYSIZE(szMenuName));
            ctxMenu.strName = szMenuName;
            ctxMenu.strStatusBarText = NULL;
            ctxMenu.lCommandID = RSOP_LAUNCH_LOGGING;  // no sp. flags
            ctxMenu.lInsertionPointID = CCM_INSERTIONPOINTID_3RDPARTY_TASK;
                 
            if (bLoAccessGranted)
                ctxMenu.fFlags = MF_ENABLED;
            else
                ctxMenu.fFlags = MF_GRAYED | MF_DISABLED;

            hr = piCallback->AddItem(&ctxMenu);
        }
    }
                

    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::AddMenuItems: Leaving hr = 0x%x"), hr));
    return hr;

}


STDMETHODIMP        
CRSOPCMenu::Command(long lCommandID, LPDATAOBJECT piDataObject)
{
    DWORD   dwSize = 0;
    LPTSTR lpArgs=NULL, lpEnd=NULL;
    SHELLEXECUTEINFO ExecInfo;
    LPTSTR  szUserName=NULL, szMachName=NULL;
    

    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::Command: lCommandID = %d"), lCommandID));

    //
    // Launch rsop.msc with the appropriate cmd line arguments
    //

    dwSize += lstrlen(RSOP_MODE) + 10;


    if (m_rsopHint == RSOPHintSite) {
        dwSize += lstrlen(RSOP_SITENAME) + lstrlen(m_szDN)+10;
    }

    if (m_rsopHint == RSOPHintDomain) {
        dwSize += lstrlen(RSOP_COMP_OU_PREF) + lstrlen(m_szDN)+10;
        dwSize += lstrlen(RSOP_USER_OU_PREF) + lstrlen(m_szDN)+10;
    }

    if (m_rsopHint == RSOPHintOrganizationalUnit) {
        dwSize += lstrlen(RSOP_COMP_OU_PREF) + lstrlen(m_szDN)+10;
        dwSize += lstrlen(RSOP_USER_OU_PREF) + lstrlen(m_szDN)+10;
    }

    if (m_rsopHint == RSOPHintMachine) {
        szMachName = MyTranslateName(m_szDN, NameFullyQualifiedDN, NameSamCompatible);

        if (!szMachName) {
            DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::Command: MyTranslateName failed with error %d"), GetLastError()));
//            ReportError(NULL, GetLastError(), IDS_SPAWNRSOPFAILED);
            goto Exit;
        }
        dwSize += lstrlen(RSOP_COMP_NAME) + lstrlen(szMachName)+10;
    }

    if (m_rsopHint == RSOPHintUser) {
        szUserName = MyTranslateName(m_szDN, NameFullyQualifiedDN, NameSamCompatible);

        if (!szUserName) {
            DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::Command: MyTranslateName failed with error %d"), GetLastError()));
//            ReportError(NULL, GetLastError(), IDS_SPAWNRSOPFAILED);
            goto Exit;
        }
        
        dwSize += lstrlen(RSOP_USER_NAME) + lstrlen(szUserName)+10;
    }

    if (m_szDomain) {
        dwSize += lstrlen(RSOP_DCNAME_PREF) + lstrlen(m_szDomain)+10;
    }

    lpArgs = (LPTSTR) LocalAlloc (LPTR, dwSize * sizeof(TCHAR));

    if (!lpArgs)
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::Command: Failed to allocate memory with %d"),
                 GetLastError()));
//            ReportError(NULL, GetLastError(), IDS_SPAWNRSOPFAILED);
        goto Exit;
    }


    wsprintf (lpArgs, TEXT("/s "));
    lpEnd = lpArgs + lstrlen(lpArgs);


    //
    // Build the command line arguments
    //

    wsprintf(lpEnd, L"%s\"%d\" ", RSOP_MODE, (lCommandID == RSOP_LAUNCH_PLANNING) ? 1 : 0);
    lpEnd = lpArgs + lstrlen(lpArgs);


    if (m_rsopHint == RSOPHintSite) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_SITENAME, m_szDN);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    if (m_rsopHint == RSOPHintDomain) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_COMP_OU_PREF, m_szDN);
        lpEnd = lpArgs + lstrlen(lpArgs);
    
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_USER_OU_PREF, m_szDN);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    if (m_rsopHint == RSOPHintOrganizationalUnit) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_COMP_OU_PREF, m_szDN);
        lpEnd = lpArgs + lstrlen(lpArgs);
    
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_USER_OU_PREF, m_szDN);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    if (m_rsopHint == RSOPHintMachine) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_COMP_NAME, szMachName);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    if (m_rsopHint == RSOPHintUser) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_USER_NAME, szUserName);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    if (m_szDomain) {
        wsprintf(lpEnd, L"%s\"%s\" ", RSOP_DCNAME_PREF, m_szDomain);
        lpEnd = lpArgs + lstrlen(lpArgs);
    }

    DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::Command: Starting GPE with %s"), lpArgs));


    ZeroMemory (&ExecInfo, sizeof(ExecInfo));
    ExecInfo.cbSize = sizeof(ExecInfo);
    ExecInfo.fMask = SEE_MASK_NOCLOSEPROCESS;
    ExecInfo.lpVerb = TEXT("open");
    ExecInfo.lpFile = TEXT("rsop.msc");
    ExecInfo.lpParameters = lpArgs;
    ExecInfo.nShow = SW_SHOWNORMAL;


    if (ShellExecuteEx (&ExecInfo))
    {
        DebugMsg((DM_VERBOSE, TEXT("CRSOPCMenu::Command: Launched rsop tool")));

        SetWaitCursor();
        WaitForInputIdle (ExecInfo.hProcess, 10000);
        ClearWaitCursor();
        CloseHandle (ExecInfo.hProcess);
    }
    else
    {
        DebugMsg((DM_WARNING, TEXT("CRSOPCMenu::Command: ShellExecuteEx failed with %d"),
                 GetLastError()));
//        ReportError(NULL, GetLastError(), IDS_SPAWNRSOPFAILED);
        goto Exit;
    }

Exit:
    if (szUserName) {
        LocalFree(szUserName);
    }
    
    if (szMachName) {
        LocalFree(szMachName);
    }

    if (lpArgs) {
        LocalFree (lpArgs);
    }
    
    return S_OK;
}

BOOL
EnableWMIFilters( LPWSTR szGPOPath )
{
    BOOL bReturn = FALSE;
    LPWSTR szDomain = szGPOPath;
    IWbemLocator* pLocator = 0;
    IWbemServices*  pServices = 0;
    HRESULT hr;

    while ( szDomain )
    {
        if ( CompareString( LOCALE_USER_DEFAULT,
                            NORM_IGNORECASE,
                            szDomain,
                            3,
                            L"DC=",
                            3 ) == CSTR_EQUAL )
        {
            break;
        }
        szDomain++;
    }

    if ( !szDomain )
    {
        goto Exit;
    }


    hr = CoCreateInstance(  CLSID_WbemLocator,
                            0,
                            CLSCTX_INPROC_SERVER,
                            IID_IWbemLocator,
                            (void**) &pLocator );
    if ( FAILED( hr ) )
    {
        goto Exit;
    }

    BSTR xbstrNamespace = SysAllocString( L"\\\\.\\root\\Policy" );
    if ( !xbstrNamespace )
    {
        goto Exit;
    }


    hr = pLocator->ConnectServer(   xbstrNamespace, // namespace
                                    0,              // user
                                    0,              // password
                                    0,              // locale
                                    0,              // security flags
                                    0,              // authority
                                    0,              // Wbem context
                                    &pServices );   // IWbemServices
    SysFreeString( xbstrNamespace );
    if ( FAILED( hr ) )
    {
        goto Exit;
    }

    WCHAR szDomainCanonical[512];
    DWORD dwSize = 512;
    
    if ( !TranslateName(szDomain,
                         NameUnknown,
                         NameCanonical,
                         szDomainCanonical,
                         &dwSize ) )
    {
        goto Exit;
    }

    LPWSTR szTemp = wcsrchr( szDomainCanonical, L'/' );

    if ( szTemp )
    {
        *szTemp = 0;
    }

    WCHAR szBuffer[512];
    wsprintf( szBuffer, L"MSFT_SomFilterStatus.domain=\"%s\"", szDomainCanonical );

    BSTR bstrObjectPath = SysAllocString( szBuffer );
    if ( !bstrObjectPath )
    {
        goto Exit;
    }

    hr = CoSetProxyBlanket(pServices, 
                           RPC_C_AUTHN_WINNT, 
                           RPC_C_AUTHZ_DEFAULT, 
                           0, 
                           RPC_C_AUTHN_LEVEL_CONNECT, 
                           RPC_C_IMP_LEVEL_IMPERSONATE, 
                           0,
                           0);

    IWbemClassObject* xObject = 0;
    hr = pServices->GetObject(  bstrObjectPath,
                                WBEM_FLAG_RETURN_WBEM_COMPLETE,
                                0,
                                &xObject,
                                0 );
    SysFreeString( bstrObjectPath );
    if ( FAILED( hr ) )
    {
        goto Exit;
    }

    VARIANT var;
    VariantInit(&var);

    hr = xObject->Get(L"SchemaAvailable", 0, &var, NULL, NULL);

    if((FAILED(hr)) || ( var.vt == VT_NULL ))
    {
        DebugMsg((DM_WARNING, TEXT("EnableWMIFilters: Get failed for SchemaAvailable with error 0x%x"), hr));
        goto Exit;
    }

    if (var.boolVal == VARIANT_FALSE )
    {
        VariantClear(&var);
        goto Exit;
    }

    VariantClear(&var);
    DebugMsg((DM_VERBOSE, TEXT("Schema is available for wmi filters")));
    bReturn = TRUE;

Exit:
    if ( pLocator )
    {
        pLocator->Release();
    }
    if ( pServices )
    {
        pServices->Release();
    }

    return bReturn;
}


HRESULT CRSOPComponentData::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);
        lstrcpy (BigBoldLogFont.lfFaceName, L"Verdana");
    }

    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);
        lstrcpy (BoldLogFont.lfFaceName, L"Verdana");
    }

    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;
}