windows-server-2003/base/remoteboot/admin/addwiz.cpp

//
// Copyright 1997 - Microsoft

//
// IMOS.CPP - Handles the "IntelliMirror OS" IDD_PROP_INTELLIMIRROR_OS tab
//


#include "pch.h"
#include "addwiz.h"
#include "cservice.h"
#include "utils.h"
#include <lm.h>
#include <shlobj.h>
#include <commdlg.h>

DEFINE_MODULE("IMADMUI")
DEFINE_THISCLASS("CAddWiz")
#define THISCLASS CAddWiz
#define LPTHISCLASS LPCADDWIZ

#define BITMAP_WIDTH        16
#define BITMAP_HEIGHT       16
#define LG_BITMAP_WIDTH     32
#define LG_BITMAP_HEIGHT    32
#define NUM_COLUMNS                 5
#define SERVER_START_STRING         L"\\\\%s\\" REMINST_SHARE

//
// CreateInstance()
//
HRESULT
CAddWiz_CreateInstance(
                      HWND  hwndParent,
                      LPUNKNOWN punk )
{
    TraceFunc( "CAddWiz_CreateInstance()\n" );

    LPTHISCLASS lpcc = new THISCLASS( );
    HRESULT hr;

    if (lpcc == NULL) {

        hr = S_FALSE;

    } else {

        hr   = THR( lpcc->Init( hwndParent, punk ) );
        delete lpcc;

    }

    HRETURN(hr);
}

//
// Constructor
//
THISCLASS::THISCLASS( )
{
    TraceClsFunc( "CAddWiz()\n" );

    Assert( !_pszServerName );
    Assert( !_pszSourcePath );
    Assert( !_pszDestPath );
    Assert( !_pszSourceImage );
    Assert( !_pszDestImage );
    Assert( !_pszSourceServerName );

    InterlockIncrement( g_cObjects );

    TraceFuncExit();
}

//
// Init()
//
STDMETHODIMP
THISCLASS::Init(
               HWND hwndParent,
               LPUNKNOWN punk )
{
    TraceClsFunc( "Init()\n" );

    if (!LoadString( g_hInstance, IDS_NA, _szNA, ARRAYSIZE(_szNA))) {
        HRETURN(HRESULT_FROM_WIN32(GetLastError()));
    }

    if (!LoadString( g_hInstance, IDS_USER_LOCATION, _szLocation, ARRAYSIZE(_szLocation))) {
        HRETURN(HRESULT_FROM_WIN32(GetLastError()));
    }

    if ( !punk )
        HRETURN(E_POINTER);

    HRESULT hr = S_OK;

    HPROPSHEETPAGE  rPages[ 10 ];
    PROPSHEETHEADER pshead;

    _punk = punk;
    _punk->AddRef( );

    ZeroMemory( &pshead, sizeof(pshead) );
    pshead.dwSize       = sizeof(pshead);
    pshead.dwFlags      = PSH_WIZARD97 | PSH_PROPTITLE | PSH_HEADER;
    pshead.hInstance    = g_hInstance;
    pshead.pszCaption   = MAKEINTRESOURCE( IDS_ADD_DOT_DOT_DOT );
    pshead.phpage       = rPages;
    pshead.pszbmHeader  = MAKEINTRESOURCE( IDB_HEADER );
    pshead.hwndParent   = hwndParent;

    AddWizardPage( &pshead, IDD_ADD_PAGE1,  Page1DlgProc,  IDS_PAGE1_TITLE,  IDS_PAGE1_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE2,  Page2DlgProc,  IDS_PAGE2_TITLE,  IDS_PAGE2_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE6,  Page6DlgProc,  IDS_PAGE6_TITLE,  IDS_PAGE6_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE3,  Page3DlgProc,  IDS_PAGE3_TITLE,  IDS_PAGE3_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE4,  Page4DlgProc,  IDS_PAGE4_TITLE,  IDS_PAGE4_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE5,  Page5DlgProc,  IDS_PAGE5_TITLE,  IDS_PAGE5_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE7,  Page7DlgProc,  IDS_PAGE7_TITLE,  IDS_PAGE7_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE8,  Page8DlgProc,  IDS_PAGE8_TITLE,  IDS_PAGE8_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE9,  Page9DlgProc,  IDS_PAGE9_TITLE,  IDS_PAGE9_SUBTITLE,  (LPARAM) this );
    AddWizardPage( &pshead, IDD_ADD_PAGE10, Page10DlgProc, IDS_PAGE10_TITLE, IDS_PAGE10_SUBTITLE, (LPARAM) this );

    PropertySheet( &pshead );

    HRETURN(hr);
}

//
// Destructor
//
THISCLASS::~THISCLASS( )
{
    TraceClsFunc( "~CAddWiz()\n" );

    Assert( !_pszPathBuffer );
    if ( !_pszPathBuffer ) {
        TraceFree( _pszPathBuffer );
        _pszPathBuffer = NULL;
    }


    if ( _punk )
        _punk->Release( );

    if ( _pszServerName )
        TraceFree( _pszServerName );

    if ( _pszSourcePath )
        TraceFree( _pszSourcePath );

    if ( _pszSourceServerName )
        TraceFree( _pszSourceServerName );

    if ( _pszDestPath )
        TraceFree( _pszDestPath );

    if ( _pszSourceImage
         && _pszSourceImage != _szNA
         && _pszSourceImage != _szLocation )
        TraceFree( _pszSourceImage );

    if ( _pszDestImage
         && _pszDestImage != _szNA
         && _pszDestImage != _szLocation )
        TraceFree( _pszDestImage );

    InterlockDecrement( g_cObjects );

    TraceFuncExit();
};

// ************************************************************************
//
// Wizard Functions
//
// ************************************************************************

//
// _PopulateSamplesListView( )
//
STDMETHODIMP
THISCLASS::_PopulateSamplesListView(
    LPWSTR pszStartPath
    )
{
    TraceClsFunc( "_PopulateSamplesListView( " );
    TraceMsg( TF_FUNC, "pszStartPath = '%s' )\n", pszStartPath );

    if ( !pszStartPath )
        HRETURN(E_POINTER);

    Assert( _hDlg );
    Assert( _hwndList );

    CWaitCursor Wait;
    HRESULT hr;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    WIN32_FIND_DATA find;

    ListView_DeleteAllItems( _hwndList );

    Assert( !_pszPathBuffer );
    _dwPathBufferSize = wcslen( pszStartPath ) + MAX_PATH;
    _pszPathBuffer = (LPWSTR) TraceAllocString( LMEM_FIXED, _dwPathBufferSize );
    if ( !_pszPathBuffer ) {
        hr = E_OUTOFMEMORY;
        _dwPathBufferSize = 0;
        goto Error;
    }

    wcscpy( _pszPathBuffer, pszStartPath );

    hr = _EnumerateSIFs( );

    Error:
    if ( _pszPathBuffer ) {
        TraceFree( _pszPathBuffer );
        _pszPathBuffer = NULL;
        _dwPathBufferSize = 0;
    }

    HRETURN(hr);
}

//
// _PopulateTemplatesListView( )
//
STDMETHODIMP
THISCLASS::_PopulateTemplatesListView(
    LPWSTR pszStartPath
    )
{
    TraceClsFunc( "_PopulateTemplatesListView( " );
    TraceMsg( TF_FUNC, "pszStartPath = '%s' )\n", pszStartPath );

    if ( !pszStartPath )
        HRETURN(E_POINTER);

    Assert( _hDlg );
    Assert( _hwndList );

    CWaitCursor Wait;
    HRESULT hr;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    WIN32_FIND_DATA find;

    ListView_DeleteAllItems( _hwndList );

    Assert( !_pszPathBuffer );
    _dwPathBufferSize = wcslen( pszStartPath ) + MAX_PATH ;
    _pszPathBuffer = (LPWSTR) TraceAllocString( LMEM_FIXED, _dwPathBufferSize );
    if ( !_pszPathBuffer ) {
        hr = E_OUTOFMEMORY;
        _dwPathBufferSize = 0;
        goto Error;
    }

    if (_snwprintf(_pszPathBuffer,
                   _dwPathBufferSize,
                   L"%s%s",
                   pszStartPath,
                   SLASH_SETUP) < 0) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    _pszPathBuffer[_dwPathBufferSize-1] = L'\0';

    hr = _FindLanguageDirectory( _EnumerateTemplates );

    Error:
    if ( _pszPathBuffer ) {
        TraceFree( _pszPathBuffer );
        _pszPathBuffer = NULL;
        _dwPathBufferSize = 0;
    }

    HRETURN(hr);
}

//
// _PopulateImageListView( )
//
STDMETHODIMP
THISCLASS::_PopulateImageListView(
    LPWSTR pszStartPath 
    )
{
    TraceClsFunc( "_PopulateImageListView( " );
    TraceMsg( TF_FUNC, "pszStartPath = '%s' )\n", pszStartPath );

    if ( !pszStartPath )
        HRETURN(E_POINTER);

    Assert( _hDlg );
    Assert( _hwndList );

    CWaitCursor Wait;
    HRESULT hr;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    WIN32_FIND_DATA find;

    ListView_DeleteAllItems( _hwndList );

    Assert( !_pszPathBuffer );
    _dwPathBufferSize = wcslen( pszStartPath ) + MAX_PATH ;
    _pszPathBuffer = (LPWSTR) TraceAllocString( LMEM_FIXED, _dwPathBufferSize );
    if ( !_pszPathBuffer ) {
        hr = E_OUTOFMEMORY;
        _dwPathBufferSize = 0;
        goto Error;
    }

    if (_snwprintf(_pszPathBuffer,
                   _dwPathBufferSize,
                   L"%s%s",
                   pszStartPath,
                   SLASH_SETUP) < 0) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    hr = _FindLanguageDirectory( _EnumerateImages );

    Error:
    if ( _pszPathBuffer ) {
        TraceFree( _pszPathBuffer );
        _pszPathBuffer = NULL;
        _dwPathBufferSize = 0;
    }

    HRETURN(hr);
}

//
// _FindLanguageDirectory( )
//
STDMETHODIMP
THISCLASS::_FindLanguageDirectory(
                                 LPNEXTOP lpNextOperation )
{
    TraceClsFunc( "_FindLanguageDirectory( ... )\n" );

    HRESULT hr = S_OK;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    ULONG   uLength;
    ULONG   uLength2;
    WIN32_FIND_DATA find;

    Assert( _pszPathBuffer );
    Assert( lpNextOperation );

    uLength = wcslen( _pszPathBuffer );
    if (uLength + sizeof(L"\\*") > _dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }

    wcscat( _pszPathBuffer, L"\\*" );
    uLength2 = wcslen( _pszPathBuffer ) - 1;

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
                 && StrCmp( find.cFileName, L"." ) != 0
                 && StrCmp( find.cFileName, L".." ) != 0 ) {
                _pszPathBuffer[uLength2] = L'\0';
                if ( (wcslen(_pszPathBuffer) + wcslen( find.cFileName ) + 1) > 
                      _dwPathBufferSize) {
                    hr = E_INVALIDARG;
                    goto Error;
                }
                wcscat( _pszPathBuffer, find.cFileName );
                hr = _FindOSDirectory( lpNextOperation );
                if (FAILED(hr))  {
                    goto Error;
                }
            }
        }
        while ( FindNextFile( hFind, &find ) );
    } else {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }

    Error:
    if ( hFind != INVALID_HANDLE_VALUE ) {
        FindClose( hFind );
    }

    // restore the trailing NULL
    _pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _FindOSDirectory( )
//
STDMETHODIMP
THISCLASS::_FindOSDirectory(
                           LPNEXTOP lpNextOperation )
{
    TraceClsFunc( "_FindOSDirectory( ... )\n" );

    HRESULT hr = S_OK;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    ULONG   uLength;
    ULONG   uLength2;
    WIN32_FIND_DATA find;

    Assert( _pszPathBuffer );
    Assert( lpNextOperation );

    uLength = wcslen( _pszPathBuffer );
    if (uLength + sizeof(SLASH_IMAGES L"\\*") > _dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }
    wcscat( _pszPathBuffer, SLASH_IMAGES L"\\*");
    uLength2 = wcslen( _pszPathBuffer ) -1;

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
                 && StrCmp( find.cFileName, L"." ) != 0
                 && StrCmp( find.cFileName, L".." ) != 0 ) {
                _pszPathBuffer[uLength2] = L'\0';
                if ( (wcslen(_pszPathBuffer) + wcslen( find.cFileName ) + 1) > 
                      _dwPathBufferSize) {
                    hr = E_INVALIDARG;
                    goto Error;
                }
                wcscat( _pszPathBuffer, find.cFileName );
                hr = _EnumeratePlatforms( lpNextOperation );
                if (FAILED(hr)) {
                    goto Error;
                }
            }
        }
        while ( FindNextFile( hFind, &find ) );
    } else {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }

    Error:
    if ( hFind != INVALID_HANDLE_VALUE )
        FindClose( hFind );

    _pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _EnumeratePlatforms( )
//
STDMETHODIMP
THISCLASS::_EnumeratePlatforms(
                              LPNEXTOP lpNextOperation )
{
    TraceClsFunc( "_EnumeratePlatforms( ... )\n" );

    HRESULT hr = S_OK;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    ULONG   uLength;
    ULONG   uLength2;
    WIN32_FIND_DATA find;

    Assert( lpNextOperation );
    Assert( _pszPathBuffer );

    uLength = wcslen( _pszPathBuffer );
    if (uLength + sizeof(L"\\*") > _dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }
    wcscat( _pszPathBuffer, L"\\*" );
    uLength2 = wcslen( _pszPathBuffer ) - 1;

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY
                 && StrCmp( find.cFileName, L"." ) != 0
                 && StrCmp( find.cFileName, L".." ) != 0 ) {
                _pszPathBuffer[uLength2] = L'\0';
                if ( (wcslen(_pszPathBuffer) + wcslen( find.cFileName ) + 1) > 
                      _dwPathBufferSize) {
                    hr = E_INVALIDARG;
                    goto Error;
                }
                wcscat( _pszPathBuffer, find.cFileName );
                hr = lpNextOperation( this );
                //
                // we can get ERROR_PATH_NOT_FOUND in several cases
                // like oem preinstall, etc.  just eat the error and
                // continue
                //
                if (hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)) {
                    hr = S_OK;
                }
                if (FAILED(hr)) {
                    goto Error;
                }
            }
        }
        while ( FindNextFile( hFind, &find ) );
    } else {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }

    Error:
    if ( hFind != INVALID_HANDLE_VALUE ) {
        FindClose( hFind );
    }

    // restore the path.
    _pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _EnumerateTemplates( )
//
HRESULT
THISCLASS::_EnumerateTemplates(
                              LPTHISCLASS lpc )
{
    TraceClsFunc( "_EnumerateTemplates( )\n" );

    HRESULT hr;
    ULONG   uLength;

    Assert( lpc );
    Assert( lpc->_pszPathBuffer );
    uLength = wcslen( lpc->_pszPathBuffer );
    if (uLength + sizeof(SLASH_TEMPLATES) > lpc->_dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }
    
    wcscat( lpc->_pszPathBuffer, SLASH_TEMPLATES );

    hr = lpc->_EnumerateSIFs( );

Error:
    lpc->_pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _EnumerateImages( )
//
HRESULT
THISCLASS::_EnumerateImages(
                           LPTHISCLASS lpc )
{
    TraceClsFunc( "_EnumerateImages( )\n" );

    HRESULT hr;

    Assert( lpc );

    hr = lpc->_CheckImageType( );
    if ( hr == S_OK ) {
        hr = lpc->_AddItemToListView( );
    }

    HRETURN(hr);
}

//
// _CheckImageType( )
//
// This won't add an item to the listview. It only checks to make
// sure the image path points to a "Flat" image.
//
// Returns: S_OK - Flat image found
//          S_FALSE - not a flat image
//
HRESULT
THISCLASS::_CheckImageType( )
{
    TraceClsFunc( "_CheckImageType( )\n" );

    HRESULT hr = S_FALSE;
    HANDLE hFind = INVALID_HANDLE_VALUE;
    WIN32_FIND_DATA find;
    ULONG   uLength;
    ULONG   uLength2;

    Assert( _pszPathBuffer );
    uLength = wcslen( _pszPathBuffer );
    if (uLength + sizeof(L"\\ntoskrnl.exe") > _dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }

    //
    // Check for <architecture>\ntoskrnl.exe to see
    // if this is a "flag" image. If we find this file
    // then we're done.
    //
    wcscat( _pszPathBuffer, L"\\ntoskrnl.exe" );

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( !(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
                Assert( _wcsicmp( find.cFileName, L"ntoskrnl.exe" ) == 0 );
                hr = S_OK;
                goto Error;
            }
        }
        while ( FindNextFile( hFind, &find ) );

        FindClose( hFind );
        hFind = INVALID_HANDLE_VALUE;
    }

    //
    // Didn't find the kernel.  Now check every sif
    // file in the TEMPLATES subdirectory and see if
    // he's got an OSCHOOSER_IMAGETYPE_ENTRY.  If he
    // does, see if it's a "flat" image.
    //
    _pszPathBuffer[uLength] = L'\0';
    if (uLength + sizeof(SLASH_TEMPLATES L"\\*.sif") > _dwPathBufferSize) {
        hr = E_INVALIDARG;
        goto Error;
    }

    wcscat( _pszPathBuffer, SLASH_TEMPLATES L"\\*.sif");
    uLength2 = wcslen( _pszPathBuffer ) - 5;

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( !(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
                WCHAR szImageType[ 40 ];
                _pszPathBuffer[uLength2] = L'\0';
                if ( (wcslen(_pszPathBuffer) + wcslen( find.cFileName ) + 1) > 
                      _dwPathBufferSize) {
                    hr = E_INVALIDARG;
                    goto Error;
                }
                wcscat( _pszPathBuffer, find.cFileName );

                GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                         OSCHOOSER_IMAGETYPE_ENTRY,
                                         L"",
                                         szImageType,
                                         ARRAYSIZE(szImageType),
                                         _pszPathBuffer );

                if ( _wcsicmp( szImageType, OSCHOOSER_IMAGETYPE_FLAT ) == 0 ) {
                    hr = S_OK;
                    goto Error;
                }
            }
        }
        while ( FindNextFile( hFind, &find ) );

        FindClose( hFind );
        hFind = INVALID_HANDLE_VALUE;
    }

    Error:
    if ( hFind != INVALID_HANDLE_VALUE ) {
        FindClose( hFind );
    }

    _pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _EnumerateSIFs( )
//
STDMETHODIMP
THISCLASS::_EnumerateSIFs( )
{
    TraceClsFunc( "_EnumerateSIFs( ... )\n" );

    HRESULT hr = S_OK;
    HANDLE  hFind = INVALID_HANDLE_VALUE;
    ULONG   uLength;
    WIN32_FIND_DATA find;

    Assert( _pszPathBuffer );
    if (wcslen(_pszPathBuffer) + ARRAYSIZE(L"\\*.sif") >_dwPathBufferSize) {
        return(E_INVALIDARG);
    }

    wcscat( _pszPathBuffer, L"\\*.sif" );
    uLength = wcslen( _pszPathBuffer ) - ARRAYSIZE(L"*.sif") + 1;
    Assert( uLength <= _dwPathBufferSize );

    hFind = FindFirstFile( _pszPathBuffer, &find );
    if ( hFind != INVALID_HANDLE_VALUE ) {
        do {
            if ( !(find.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) ) {
                _pszPathBuffer[uLength] = L'\0';
                if (wcslen(_pszPathBuffer) + wcslen(find.cFileName) + 1 > _dwPathBufferSize) {
                    hr = E_INVALIDARG;
                    goto Error;
                }

                wcscat( _pszPathBuffer, find.cFileName );

                hr = _AddItemToListView( );
                if (FAILED(hr))
                    goto Error;
            }
        }
        while ( FindNextFile( hFind, &find ) );
    } else {
        hr = HRESULT_FROM_WIN32(GetLastError());
    }

    Error:
    if ( hFind != INVALID_HANDLE_VALUE ) {
        FindClose( hFind );
    }

    _pszPathBuffer[uLength] = L'\0';

    HRETURN(hr);
}

//
// _AddItemToListView( )
//
// Returns: S_OK - Item add successfully
//          S_FALSE - Item is not valid
//          E_OUTOFMEMORY - obvious
//
// Note: this code is nearly identical to PopulateListView() in utils.cpp
//
//
HRESULT
THISCLASS::_AddItemToListView( )
{
    TraceClsFunc( "_AddItemToListView( )\n" );

    Assert( _pszPathBuffer );

    HRESULT hr = S_OK;
    LPSIFINFO pSIF = NULL;
    LV_ITEM lvI;
    INT     iCount = 0;
    LPWSTR  psz;
    LPWSTR  pszLanguage;
    LPWSTR  pszImage;
    LPWSTR  pszArchitecture;

    pSIF = (LPSIFINFO) TraceAlloc( LPTR, sizeof(SIFINFO) );
    if ( !pSIF ) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    ZeroMemory( pSIF, sizeof(SIFINFO));

    pSIF->pszFilePath = (LPWSTR) TraceStrDup( _pszPathBuffer );
    if ( !pSIF->pszFilePath ) {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    psz = &_pszPathBuffer[ wcslen( _pszPathBuffer ) - 4 ];
    if ( _wcsicmp( psz, L".SIF" ) == 0 ) {
        WCHAR szImageType[ 40 ];

        GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                 OSCHOOSER_IMAGETYPE_ENTRY,
                                 L"",
                                 szImageType,
                                 ARRAYSIZE(szImageType),
                                 _pszPathBuffer );
        // only show "Flat" SIFs
        if ( szImageType[0] && _wcsicmp( szImageType, OSCHOOSER_IMAGETYPE_FLAT ) ) {
            hr = S_FALSE; // skipping
            goto Error;
        }

        pSIF->pszDescription =
        (LPWSTR) TraceAllocString( LMEM_FIXED,
                                   REMOTE_INSTALL_MAX_DESCRIPTION_CHAR_COUNT );
        if ( !pSIF->pszDescription ) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }

        GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                 OSCHOOSER_DESCRIPTION_ENTRY,
                                 L"",
                                 pSIF->pszDescription,
                                 REMOTE_INSTALL_MAX_DESCRIPTION_CHAR_COUNT, // doesn't need -1
                                 _pszPathBuffer );

        if ( pSIF->pszDescription[0] == L'\0' ) {
            hr = S_FALSE;
            goto Error; // not a valid OSChooser SIF
        }

        pSIF->pszHelpText = 
        (LPWSTR) TraceAllocString( LMEM_FIXED, 
                                   REMOTE_INSTALL_MAX_HELPTEXT_CHAR_COUNT );

        if ( !pSIF->pszHelpText ) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
        
        GetPrivateProfileString( OSCHOOSER_SIF_SECTION, 
                                 OSCHOOSER_HELPTEXT_ENTRY, 
                                 L"", 
                                 pSIF->pszHelpText, 
                                 REMOTE_INSTALL_MAX_HELPTEXT_CHAR_COUNT, // doesn't need -1
                                 _pszPathBuffer );
    }

    // This path will be in one of these forms:
    // \\server\reminst\setup\english\images\nt50.wks\i386           ( Samples )
    // \\server\reminst\setup\english\images\nt50.wks\i386\templates ( template SIFs )
    // \\server\reminst\setup\english\images                         ( Images )

    // Find the language from the path
    psz = StrStr( _pszPathBuffer, SLASH_SETUP L"\\" );
    if (!psz) {
        goto Language_NA;
    }
    psz++;
    if ( !*psz ) {
        goto Language_NA;
    }
    psz = StrChr( psz, L'\\' );
    if (!psz) {
        goto Language_NA;
    }
    psz++;
    if ( !*psz ) {
        goto Language_NA;
    }
    pszLanguage = psz;
    psz = StrChr( psz, L'\\' );
    if ( psz ) {
        *psz = L'\0';   // terminate
    }
    pSIF->pszLanguage = (LPWSTR) TraceStrDup( pszLanguage );
    if ( psz ) {
        *psz = L'\\';   // restore
    }
    if ( !pSIF->pszLanguage ) {
        hr = E_OUTOFMEMORY;
        goto Language_NA;
    }

    // Find the image directory name from the path
    psz = StrStr( _pszPathBuffer, SLASH_IMAGES L"\\" );
    if ( !psz ) {
        goto Image_NA;
    }
    psz++;
    if ( !*psz ) {
        goto Image_NA;
    }
    psz = StrChr( psz, L'\\' );
    if (!psz) {
        goto Image_NA;
    }
    psz++;
    if ( !*psz ) {
        goto Image_NA;
    }
    pszImage = psz;
    psz = StrChr( psz, L'\\' );
    if ( psz ) {
        *psz = L'\0';   // terminate
    }
    pSIF->pszImageFile = (LPWSTR) TraceStrDup( pszImage );
    if ( psz ) {
        *psz = L'\\';    // restore
    }
    if ( !pSIF->pszImageFile ) {
        hr = E_OUTOFMEMORY;
        goto Image_NA;
    }

    // Find the architecture from the path
    if ( !*psz ) {
        goto Architecture_NA;
    }
    psz++;
    if ( !*psz ) {
        goto Architecture_NA;
    }
    pszArchitecture = psz;
    psz = StrChr( psz, L'\\' );
    if ( psz ) {
        *psz = L'\0';    // terminate
    }
    pSIF->pszArchitecture = (LPWSTR) TraceStrDup( pszArchitecture );
    if ( psz ) {
        *psz = L'\\';    // restore
    }
    if ( !pSIF->pszArchitecture ) {
        hr = E_OUTOFMEMORY;
        goto Architecture_NA;
    }

    goto Done;

    // Set columns that we couldn't determine to "n/a"
    Language_NA:
    pSIF->pszLanguage = _szNA;
    Image_NA:
    pSIF->pszImageFile = _szNA;
    Architecture_NA:
    pSIF->pszArchitecture = _szNA;

    Done:    
    if ( !pSIF->pszDescription ) {
        pSIF->pszDescription = (LPWSTR) TraceStrDup( pSIF->pszImageFile );
        if ( !pSIF->pszDescription ) {
            hr = E_OUTOFMEMORY;
            goto Error;
        }
    }

    lvI.mask        = LVIF_TEXT | LVIF_PARAM;
    lvI.iSubItem    = 0;
    lvI.cchTextMax  = REMOTE_INSTALL_MAX_DESCRIPTION_CHAR_COUNT;
    lvI.lParam      = (LPARAM) pSIF;
    lvI.iItem       = iCount;
    lvI.pszText     = pSIF->pszDescription;
    iCount = ListView_InsertItem( _hwndList, &lvI );
    Assert( iCount != -1 );
    if ( iCount == -1 ) {
        goto Error;
    }

    ListView_SetItemText( _hwndList, iCount, 1, pSIF->pszArchitecture );
    ListView_SetItemText( _hwndList, iCount, 2, pSIF->pszLanguage );
    // ListView_SetItemText( hwndList, iCount, 3, pSIF->pszVersion );
    ListView_SetItemText( _hwndList, iCount, 3, pSIF->pszImageFile );

    pSIF = NULL; // don't free

    Error:
    if ( pSIF )
        THR( _CleanupSIFInfo( pSIF ) );

    HRETURN(hr);
}

//
// _CleanUpSifInfo( )
//
HRESULT
THISCLASS::_CleanupSIFInfo(
                          LPSIFINFO pSIF )
{
    TraceClsFunc( "_CleanupSIFInfo( )\n" );

    if ( !pSIF )
        HRETURN(E_POINTER);

    if ( pSIF->pszFilePath )
        TraceFree( pSIF->pszFilePath );

    if ( pSIF->pszDescription )
        TraceFree( pSIF->pszDescription );

    if (pSIF->pszHelpText) {
        TraceFree( pSIF->pszHelpText );
    }

    //if ( pSIF->pszImageType && pSIF->pszImageType != _szNA )
    //    TraceFree( pSIF->pszImageType );

    if ( pSIF->pszArchitecture  && pSIF->pszArchitecture != _szNA )
        TraceFree( pSIF->pszArchitecture );

    if ( pSIF->pszLanguage && pSIF->pszLanguage != _szNA )
        TraceFree( pSIF->pszLanguage );

    if ( pSIF->pszImageFile && pSIF->pszImageFile != _szNA )
        TraceFree( pSIF->pszImageFile );

    //if ( pSIF->pszVersion && pSIF->pszVersion != _szNA )
    //    TraceFree( pSIF->pszVersion );

    TraceFree( pSIF );

    HRETURN(S_OK);

}

//
// _InitListView( )
//
HRESULT
THISCLASS::_InitListView(
                        HWND hwndList,
                        BOOL fShowDirectoryColumn )
{
    TraceClsFunc( "_InitListView( )\n" );

    CWaitCursor Wait;
    LV_COLUMN   lvC;
    INT         iSubItem;
    INT         iCount;
    LV_ITEM     lvI;
    WCHAR       szText[ 80 ];
    DWORD       dw;

    UINT uColumnWidth[ NUM_COLUMNS ] = { 215, 75, 75, 75, 75};

    lvI.mask        = LVIF_TEXT | LVIF_PARAM;
    lvI.iSubItem    = 0;
    lvI.cchTextMax  = DNS_MAX_NAME_BUFFER_LENGTH;

    // Create the columns
    lvC.mask    = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
    lvC.fmt     = LVCFMT_LEFT;
    lvC.pszText = szText;

    // Add the columns.
    for ( iCount = 0; iCount < NUM_COLUMNS; iCount++ ) {
        INT i;

        if ( iCount == 3 )
            continue; // skip "Version"

        if ( !fShowDirectoryColumn && iCount == 4 )
            continue; // skip "Directory"

        lvC.iSubItem = iCount;
        lvC.cx       = uColumnWidth[iCount];

        szText[0] = L'\0';
        dw = LoadString( g_hInstance,
                         IDS_OS_COLUMN1 + iCount,
                         szText,
                         ARRAYSIZE(szText));
        Assert( dw );

        i = ListView_InsertColumn ( hwndList, iCount, &lvC );
        Assert( i != -1 );
    }

    ListView_DeleteAllItems( hwndList );

    HRETURN(S_OK);
}


//
// Page1DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page1DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            HRESULT hr;
            DWORD cbSize = DNS_MAX_NAME_BUFFER_LENGTH;
            WCHAR szFQDNS[ DNS_MAX_NAME_BUFFER_LENGTH ];
            IIntelliMirrorSAP * pimsap = NULL;
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;

            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            lpc = (LPTHISCLASS) ppsp->lParam;

            Button_SetCheck( GetDlgItem( hDlg, IDC_B_ADDSIF ), BST_CHECKED );

            Assert( lpc->_punk );
            hr = THR( lpc->_punk->QueryInterface( IID_IIntelliMirrorSAP,
                                                  (void**) &pimsap ) );
            if (FAILED(hr)) {
                goto InitDialog_Error;
            }

            Assert( !lpc->_pszServerName );
            hr = THR( pimsap->GetServerName( &lpc->_pszServerName ) );
            if (FAILED(hr)) {
                goto InitDialog_Error;
            }

            if (GetComputerNameEx( ComputerNameNetBIOS, szFQDNS, &cbSize ) &&
                _wcsicmp( szFQDNS, lpc->_pszServerName ) == 0 ) {
                EnableWindow( GetDlgItem( hDlg, IDC_B_NEWIMAGE ), TRUE );
            }

            InitDialog_Error:
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_NEXT );
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                if ( Button_GetCheck( GetDlgItem( hDlg, IDC_B_ADDSIF ) )
                     == BST_CHECKED ) {
                    lpc->_fAddSif = TRUE;
                } else if ( Button_GetCheck( GetDlgItem( hDlg, IDC_B_NEWIMAGE ) )
                            == BST_CHECKED ) {
                    STARTUPINFO startupInfo;
                    PROCESS_INFORMATION pi;
                    BOOL bRet;
                    const WCHAR szCommand[] = L"%systemroot%\\system32\\RISETUP.EXE -add";
                    WCHAR szRealCommandLine[MAX_PATH + 5 + 1]; // 5 for ' -add' and 1 for null

                    lpc->_fAddSif = FALSE;

                    ZeroMemory( &startupInfo, sizeof( startupInfo) );
                    startupInfo.cb = sizeof( startupInfo );

                    if (ExpandEnvironmentStrings(
                                szCommand, 
                                szRealCommandLine, 
                                ARRAYSIZE(szRealCommandLine)) && 
                        CreateProcess(NULL,
                                      szRealCommandLine,
                                      NULL,
                                      NULL,
                                      TRUE,
                                      NORMAL_PRIORITY_CLASS,
                                      NULL,
                                      NULL,
                                      &startupInfo,
                                      &pi )) {
                        CloseHandle( pi.hProcess );
                        CloseHandle( pi.hThread );
                    } else {
                        DWORD dwErr = GetLastError( );
                        MessageBoxFromError( hDlg,
                                             IDS_RISETUP_FAILED_TO_START,
                                             dwErr );
                    }

                    PropSheet_PressButton( GetParent( hDlg ), PSBTN_FINISH );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;
    }

    return FALSE;
}
//
// Page2DlgProc( )
//
// SIF Selection dialog proc.
//
INT_PTR CALLBACK
THISCLASS::Page2DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    LRESULT lResult;

                    lpc->_fCopyFromSamples   = FALSE;
                    lpc->_fCopyFromLocation  = FALSE;
                    lpc->_fCopyFromServer    = FALSE;

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_FROMSAMPLES ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromSamples = TRUE;
                    }

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_SERVER ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromServer = TRUE;
                    }

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_LOCATION ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromLocation = TRUE;
                    }

                    if ( !lpc->_fCopyFromLocation
                         && !lpc->_fCopyFromSamples && !lpc->_fCopyFromServer ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    }
                }
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    LRESULT lResult;

                    lpc->_fCopyFromSamples   = FALSE;
                    lpc->_fCopyFromLocation  = FALSE;
                    lpc->_fCopyFromServer    = FALSE;

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_FROMSAMPLES ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromSamples = TRUE;
                    }

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_SERVER ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromServer = TRUE;
                    }

                    lResult = Button_GetCheck( GetDlgItem( hDlg, IDC_B_LOCATION ) );
                    if ( lResult == BST_CHECKED ) {
                        lpc->_fCopyFromLocation = TRUE;
                    }

                    Assert( lpc->_fCopyFromLocation
                            || lpc->_fCopyFromSamples
                            || lpc->_fCopyFromServer );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;

    case WM_COMMAND:
        TraceMsg( TF_WM, "WM_COMMAND\n" );
        HWND hwnd = (HWND) lParam;
        switch ( LOWORD( wParam ) ) {
        case IDC_B_FROMSAMPLES:
            if ( HIWORD( wParam ) == BN_CLICKED ) {
                LRESULT lResult = Button_GetCheck( hwnd );
                if ( lResult == BST_CHECKED ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;

        case IDC_B_SERVER:
            if ( HIWORD( wParam ) == BN_CLICKED ) {
                LRESULT lResult = Button_GetCheck( hwnd );
                if ( lResult == BST_CHECKED ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;

        case IDC_B_LOCATION:
            if ( HIWORD( wParam ) == BN_CLICKED ) {
                LRESULT lResult = Button_GetCheck( hwnd );
                if ( lResult == BST_CHECKED ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;

        }
        break;
    }

    return FALSE;
}

//
// Page3DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page3DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif || !lpc->_fCopyFromServer ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    ULONG uLength =
                    Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_SERVER ) );
                    if ( !uLength ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    }
                }
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    CWaitCursor Wait;
                    LPSHARE_INFO_1 psi;
                    HWND hwndEdit = GetDlgItem( hDlg, IDC_E_SERVER );
                    ULONG uLength = Edit_GetTextLength( hwndEdit );
                    Assert( uLength );
                    uLength++;  // add one for the NULL

                    // if we had a previous buffer allocated,
                    // see if we can reuse it
                    if ( lpc->_pszSourceServerName && uLength
                         > wcslen(lpc->_pszSourceServerName) + 1 ) {
                        TraceFree( lpc->_pszSourceServerName );
                        lpc->_pszSourceServerName = NULL;
                    }

                    if ( !lpc->_pszSourceServerName ) {
                        lpc->_pszSourceServerName =
                        (LPWSTR) TraceAllocString( LMEM_FIXED, uLength );
                        if ( !lpc->_pszSourceServerName )
                            goto PSN_WIZNEXTABORT;
                    }

                    Edit_GetText( hwndEdit, lpc->_pszSourceServerName, uLength );

                    if ( NERR_Success !=
                         NetShareGetInfo( lpc->_pszSourceServerName,
                                          REMINST_SHARE,
                                          1,
                                          (LPBYTE *) &psi ) ) {
                        MessageBoxFromStrings( hDlg,
                                               IDS_NOTARISERVER_CAPTION,
                                               IDS_NOTARISERVER_TEXT,
                                               MB_OK );
                        SetFocus( hwndEdit );
                        goto PSN_WIZNEXTABORT;
                    } else {
                        NetApiBufferFree( psi );
                    }

                    break;
                    PSN_WIZNEXTABORT:
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 );
                    return TRUE;
                }
                break;

            case LVN_DELETEALLITEMS:
                TraceMsg( TF_WM, "LVN_DELETEALLITEMS - Deleting all items.\n" );
                break;

            case LVN_DELETEITEM:
                TraceMsg( TF_WM, "LVN_DELETEITEM - Deleting an item.\n" );
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
                    LPSIFINFO pSIF = (LPSIFINFO) pnmv->lParam;
                    THR( lpc->_CleanupSIFInfo( pSIF ) );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;

    case WM_COMMAND:
        TraceMsg( TF_WM, "WM_COMMAND\n" );
        HWND hwnd = (HWND) lParam;
        switch ( LOWORD( wParam ) ) {
        case IDC_E_SERVER:
            if ( HIWORD( wParam ) == EN_CHANGE ) {
                LONG uLength = Edit_GetTextLength( hwnd );
                if ( !uLength ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK );
                } else {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;

        case IDC_B_BROWSE:
            if ( HIWORD( wParam ) == BN_CLICKED ) {
                _OnSearch( hDlg );
            }
            break;
        }
        break;
    }

    return FALSE;
}

HRESULT
THISCLASS::_OnSearch(
                    HWND hDlg )
{
    TraceClsFunc( "_OnSearch( )\n" );

    HRESULT hr = E_FAIL;
    DSQUERYINITPARAMS dqip;
    OPENQUERYWINDOW   oqw;
    LPDSOBJECTNAMES   pDsObjects;
    VARIANT var;
    ICommonQuery * pCommonQuery = NULL;
    IDataObject *pdo;

    VariantInit( &var );

    hr = THR( CoCreateInstance( CLSID_CommonQuery, NULL, CLSCTX_INPROC_SERVER, IID_ICommonQuery, (PVOID *)&pCommonQuery) );
    if (FAILED(hr)) {
        goto Error;
    }

    ZeroMemory( &dqip, sizeof(dqip) );
    dqip.cbStruct = sizeof(dqip);
    dqip.dwFlags  = DSQPF_NOSAVE | DSQPF_SHOWHIDDENOBJECTS | DSQPF_ENABLEADMINFEATURES;
    dqip.dwFlags  |= DSQPF_ENABLEADVANCEDFEATURES;

    ZeroMemory( &oqw, sizeof(oqw) );
    oqw.cbStruct           = sizeof(oqw);
    oqw.dwFlags            = OQWF_SHOWOPTIONAL | OQWF_ISSUEONOPEN
                             | OQWF_REMOVESCOPES | OQWF_REMOVEFORMS
                             | OQWF_DEFAULTFORM | OQWF_OKCANCEL | OQWF_SINGLESELECT;
    oqw.clsidHandler       = CLSID_DsQuery;
    oqw.pHandlerParameters = &dqip;
    oqw.clsidDefaultForm   = CLSID_RISrvQueryForm;

    hr = pCommonQuery->OpenQueryWindow( hDlg, &oqw, &pdo);

    if ( SUCCEEDED(hr) && pdo) {
        FORMATETC fmte = {
            (CLIPFORMAT)g_cfDsObjectNames,
            NULL,
            DVASPECT_CONTENT, 
            -1, 
            TYMED_HGLOBAL};
        STGMEDIUM medium = { TYMED_HGLOBAL, NULL, NULL};

        //
        // Retrieve the result from the IDataObject, 
        // in this case CF_DSOBJECTNAMES (dsclient.h) 
        // is needed because it describes 
        // the objects which were selected by the user.
        //
        hr = pdo->GetData(&fmte, &medium);
        if ( SUCCEEDED(hr) ) {
            DSOBJECTNAMES *pdon = (DSOBJECTNAMES*)GlobalLock(medium.hGlobal);
            PWSTR p,FQDN;

            //
            // we want the name of the computer object that was selected.
            // crack the DSOBJECTNAMES structure to get this data, 
            // convert it into a version that the user can view, and set the
            // dialog text to this data.
            //
            //
            // if we can't get this, it's not a problem because this is
            // only a display value
            //
            if ( pdon ) {
                Assert( pdon->cItems == 1);
                p = (PWSTR)((ULONG_PTR)pdon + (ULONG_PTR)pdon->aObjects[0].offsetName);
                if (p && (p = wcsstr(p, L"LDAP://"))) {
                    p += 6;
                    if ((p = wcsstr(p, L"/CN="))) {
                        p += 1;
                        hr = DNtoFQDN( p, &FQDN);

                        if (SUCCEEDED(hr)) {
                            SetDlgItemText( hDlg, IDC_E_SERVER, FQDN );
                            TraceFree( FQDN );
                        }
                    }
                }
                GlobalUnlock(medium.hGlobal);
            }
        }

        ReleaseStgMedium(&medium);
        pdo->Release();
    }

    Error:

    if ( pCommonQuery )
        pCommonQuery->Release();

    if (FAILED(hr)) {
        MessageBoxFromStrings(
                             hDlg, 
                             IDS_PROBLEM_SEARCHING_TITLE, 
                             IDS_PROBLEM_SEARCHING_TEXT, 
                             MB_ICONEXCLAMATION );
    }

    HRETURN(hr);
}


//
// Page4DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page4DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            lpc = (LPTHISCLASS) ppsp->lParam;
            THR( lpc->_InitListView( GetDlgItem( hDlg, IDC_L_SIFS ), TRUE ) );
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif || !lpc->_fCopyFromServer ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                }
                Assert( lpc->_pszSourceServerName );
                if ( lpc->_pszSourceServerName ) {
                    LPWSTR pszStartPath =
                    (LPWSTR) TraceAllocString( LMEM_FIXED,
                                               wcslen( lpc->_pszSourceServerName )
                                               + ARRAYSIZE(SERVER_START_STRING) );
                    if ( pszStartPath ) {
                        wsprintf( pszStartPath,
                                  SERVER_START_STRING,
                                  lpc->_pszSourceServerName );
                        lpc->_hDlg = hDlg;
                        lpc->_hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                        lpc->_PopulateTemplatesListView( pszStartPath );
                        TraceFree( pszStartPath );
                    }
                }
                PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_BACK );
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    LVITEM lvi;
                    HWND hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                    lvi.iItem = ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    Assert( lvi.iItem != -1 );

                    lvi.iSubItem = 0;
                    lvi.mask = LVIF_PARAM;
                    ListView_GetItem( hwndList, &lvi );
                    Assert(lvi.lParam);

                    LPSIFINFO pSIF = (LPSIFINFO) lvi.lParam;

                    if ( lpc->_pszSourcePath )  {
                        TraceFree( lpc->_pszSourcePath );
                        lpc->_pszSourcePath = NULL;
                    }

                    if ( lpc->_pszSourceImage
                         && lpc->_pszSourceImage != lpc->_szNA
                         && lpc->_pszSourceImage != lpc->_szLocation ) {
                        TraceFree( lpc->_pszSourceImage );
                        lpc->_pszSourceImage = NULL;
                    }

                    lpc->_pszSourcePath  = pSIF->pszFilePath;
                    lpc->_pszSourceImage = pSIF->pszImageFile;
                    pSIF->pszFilePath    = NULL;   // don't free this, we're using it
                    pSIF->pszImageFile   = NULL;   // don't free this, we're using it

                    ListView_DeleteAllItems( hwndList );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );

            case LVN_DELETEALLITEMS:
                TraceMsg( TF_WM, "LVN_DELETEALLITEMS - Deleting all items.\n" );
                break;

            case LVN_DELETEITEM:
                TraceMsg( TF_WM, "LVN_DELETEITEM - Deleting an item.\n" );
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
                    LPSIFINFO pSIF = (LPSIFINFO) pnmv->lParam;
                    THR( lpc->_CleanupSIFInfo( pSIF ) );
                }
                break;

            case LVN_ITEMCHANGED:
                {
                    HWND hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                    UINT iItems = ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    if ( iItems != -1 ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    }
                }
                break;
            }
        }
        break;
    }

    return FALSE;
}

//
// Page5DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page5DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            Edit_LimitText( GetDlgItem( hDlg, IDC_E_FILEPATH ), MAX_PATH );
            SHAutoComplete(GetDlgItem( hDlg, IDC_E_FILEPATH ), SHACF_AUTOSUGGEST_FORCE_ON | SHACF_FILESYSTEM);
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif || !lpc->_fCopyFromLocation ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    ULONG uLength =
                    Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_FILEPATH ) );
                    if ( !uLength ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    }
                }
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    HWND  hwndEdit = GetDlgItem( hDlg, IDC_E_FILEPATH );
                    ULONG uLength = Edit_GetTextLength( hwndEdit );
                    DWORD dw;
                    Assert( uLength );
                    uLength++;  // add one for the NULL

                    // if we had a previous buffer allocated,
                    // see if we can reuse it
                    if ( lpc->_pszSourcePath && uLength
                         > wcslen(lpc->_pszSourcePath) + 1 ) {
                        TraceFree( lpc->_pszSourcePath );
                        lpc->_pszSourcePath = NULL;
                    }

                    if ( lpc->_pszSourceImage
                         && lpc->_pszSourceImage != lpc->_szNA
                         && lpc->_pszSourceImage != lpc->_szLocation ) {
                        TraceFree( lpc->_pszSourceImage );
                        lpc->_pszSourceImage = NULL;
                    }

                    lpc->_pszSourceImage = lpc->_szLocation;

                    if ( !lpc->_pszSourcePath ) {
                        lpc->_pszSourcePath =
                        (LPWSTR) TraceAllocString( LMEM_FIXED, uLength );
                        if ( !lpc->_pszSourcePath ) {
                            SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 );   // don't change
                            return TRUE;
                        }
                    }

                    Edit_GetText( hwndEdit, lpc->_pszSourcePath, uLength );

                    DWORD dwAttrs = GetFileAttributes( lpc->_pszSourcePath );
                    if ( dwAttrs == 0xFFFFffff ) {   // file doesn't exist
                        DWORD dwErr = GetLastError( );
                        MessageBoxFromError( hDlg, NULL, dwErr );
                        TraceFree( lpc->_pszSourcePath );
                        lpc->_pszSourcePath = NULL;
                        SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't continue
                        return TRUE;
                    } else {   // the SIF image must be a "FLAT" image
                        WCHAR szImageType[ 40 ];

                        GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                                 OSCHOOSER_IMAGETYPE_ENTRY,
                                                 L"",
                                                 szImageType,
                                                 ARRAYSIZE(szImageType),
                                                 lpc->_pszSourcePath );

                        if ( _wcsicmp( szImageType, OSCHOOSER_IMAGETYPE_FLAT ) ) {
                            MessageBoxFromStrings( hDlg,
                                                   IDS_MUST_BE_FLAT_CAPTION,
                                                   IDS_MUST_BE_FLAT_TEXT,
                                                   MB_OK );
                            SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't continue
                            return TRUE;
                        }

                        GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                                 OSCHOOSER_DESCRIPTION_ENTRY,
                                                 L"",
                                                 lpc->_szDescription,
                                                 ARRAYSIZE(lpc->_szDescription),
                                                 lpc->_pszSourcePath );

                        GetPrivateProfileString( OSCHOOSER_SIF_SECTION,
                                                 OSCHOOSER_HELPTEXT_ENTRY,
                                                 L"",
                                                 lpc->_szHelpText,
                                                 ARRAYSIZE(lpc->_szHelpText),
                                                 lpc->_pszSourcePath );
                    }
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;

    case WM_COMMAND:
        TraceMsg( TF_WM, "WM_COMMAND\n" );
        HWND hwnd = (HWND) lParam;
        switch ( LOWORD( wParam ) ) {
        case IDC_E_FILEPATH:
            if ( HIWORD( wParam ) == EN_CHANGE ) {
                LONG uLength = Edit_GetTextLength( hwnd );
                if ( !uLength ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK );
                } else {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;

        case IDC_B_BROWSE:
            if ( HIWORD( wParam ) == BN_CLICKED ) {
                WCHAR szFilter[ 80 ]; // random
                WCHAR szFilepath[ MAX_PATH ] = { L'\0'};   // bigger?
                WCHAR szSIF[ ] = { L"SIF"};
                DWORD dw;
                OPENFILENAME ofn;

                // Build OpenFileName dialogs filter
                ZeroMemory( szFilter, sizeof(szFilter) );
                dw = LoadString( g_hInstance,
                                 IDS_OFN_SIF_FILTER,
                                 szFilter,
                                 ARRAYSIZE(szFilter) );
                Assert( dw );
                dw++;   // include NULL character
                wcscat( &szFilter[dw], L"*.SIF" );
#ifdef DEBUG
                // paranoid... make sure it fits!
                dw += wcslen( &szFilter[dw] ) + 2; // +2 = one for each NULL character
                Assert( dw + 2 <= sizeof(szFilter) );
#endif // DEBUG

                // Build OpenFileName structure
                ZeroMemory( &ofn, sizeof(ofn) );
                ofn.lStructSize = sizeof(ofn);
                ofn.hwndOwner   = hDlg;
                ofn.hInstance   = g_hInstance;
                ofn.lpstrFilter = szFilter;
                ofn.lpstrFile   = szFilepath;
                ofn.nMaxFile    = ARRAYSIZE(szFilepath);
                ofn.Flags       = OFN_ENABLESIZING | OFN_FILEMUSTEXIST
                                  | OFN_HIDEREADONLY;
                ofn.lpstrDefExt = szSIF;
                if ( GetOpenFileName( &ofn ) ) {
                    SetDlgItemText( hDlg, IDC_E_FILEPATH, szFilepath );
                    return TRUE;
                }
            }
            break;
        }
        break;
    }

    return FALSE;
}

//
// Page6DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page6DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            lpc = (LPTHISCLASS) ppsp->lParam;
            THR( lpc->_InitListView( GetDlgItem( hDlg, IDC_L_OSES ), FALSE ) );
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                }
                Assert( lpc->_pszServerName );
                if ( lpc->_pszServerName ) {
                    LPWSTR pszStartPath =
                    (LPWSTR) TraceAllocString( LMEM_FIXED,
                                               wcslen( lpc->_pszServerName )
                                               + ARRAYSIZE(SERVER_START_STRING) );
                    if ( pszStartPath ) {
                        wsprintf( pszStartPath,
                                  SERVER_START_STRING,
                                  lpc->_pszServerName );
                        lpc->_hDlg = hDlg;
                        lpc->_hwndList = GetDlgItem( hDlg, IDC_L_OSES );
                        // bugbug what if this fails?
                        lpc->_PopulateImageListView( pszStartPath );
                        TraceFree( pszStartPath );
                    }
                }
                PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_BACK );
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    LVITEM lvi;
                    HWND hwndList = GetDlgItem( hDlg, IDC_L_OSES );
                    lvi.iItem = ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    Assert( lvi.iItem != -1 );

                    lvi.iSubItem = 0;
                    lvi.mask = LVIF_PARAM;
                    ListView_GetItem( hwndList, &lvi );
                    Assert(lvi.lParam);

                    LPSIFINFO pSIF = (LPSIFINFO) lvi.lParam;

                    if ( lpc->_pszDestPath) {
                        TraceFree( lpc->_pszDestPath );
                        lpc->_pszDestPath = NULL;
                    }

                    lpc->_pszDestPath =
                    (LPWSTR) TraceAllocString( LMEM_FIXED,
                                               wcslen( pSIF->pszFilePath )
                                               + ARRAYSIZE(SLASH_TEMPLATES) );
                    if ( !lpc->_pszDestPath ) {
                        SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't continue;
                        return TRUE;
                    }

                    wcscpy( lpc->_pszDestPath, pSIF->pszFilePath );
                    wcscat( lpc->_pszDestPath, SLASH_TEMPLATES );
                    lpc->_fDestPathIncludesSIF = FALSE;

                    if ( lpc->_pszDestImage
                         && lpc->_pszDestImage != lpc->_szNA )
                        TraceFree( lpc->_pszDestImage );
                    // no need to NULL - it set again below

                    lpc->_pszDestImage = pSIF->pszImageFile;
                    pSIF->pszImageFile = NULL; // don't free this

                    ListView_DeleteAllItems( hwndList );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );

            case LVN_DELETEALLITEMS:
                TraceMsg( TF_WM, "LVN_DELETEALLITEMS - Deleting all items.\n" );
                break;

            case LVN_DELETEITEM:
                TraceMsg( TF_WM, "LVN_DELETEITEM - Deleting an item.\n" );
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
                    LPSIFINFO pSIF = (LPSIFINFO) pnmv->lParam;
                    THR( lpc->_CleanupSIFInfo( pSIF ) );
                }
                break;

            case LVN_ITEMCHANGED:
                {
                    HWND hwndList = GetDlgItem( hDlg, IDC_L_OSES );
                    UINT iItems =
                    ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    if ( iItems != -1 ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    }
                }
                break;
            }
        }
        break;
    }

    return FALSE;
}

//
// Page7DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page7DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            lpc = (LPTHISCLASS) ppsp->lParam;
            THR( lpc->_InitListView( GetDlgItem( hDlg, IDC_L_SIFS ), FALSE ) );
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif || !lpc->_fCopyFromSamples ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                }
                Assert( lpc->_pszDestPath );
                if ( lpc->_pszDestPath ) {
                    LPWSTR pszStartPath =
                    (LPWSTR) TraceStrDup( lpc->_pszDestPath );
                    if ( pszStartPath ) {
                        // remove the "\templates" from the path
                        LPWSTR psz = StrRChr( pszStartPath,
                                              &pszStartPath[wcslen(pszStartPath)],
                                              L'\\' );
                        Assert( psz );
                        if ( psz ) {
                            *psz = L'\0'; // terminate
                            lpc->_hDlg = hDlg;
                            lpc->_hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                            //bugbug this could fail.
                            lpc->_PopulateSamplesListView( pszStartPath );
                            *psz = L'\\'; // restore
                        }
                        TraceFree( pszStartPath );
                    }
                }
                PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_BACK );
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    LVITEM lvi;
                    DWORD  dw;
                    HWND   hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                    lvi.iItem = ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    Assert( lvi.iItem != -1 );

                    lvi.iSubItem = 0;
                    lvi.mask = LVIF_PARAM;
                    ListView_GetItem( hwndList, &lvi );
                    Assert(lvi.lParam);

                    LPSIFINFO pSIF = (LPSIFINFO) lvi.lParam;

                    if ( lpc->_pszSourcePath ) {
                        TraceFree( lpc->_pszSourcePath );
                        lpc->_pszSourcePath = NULL;
                    }

                    if ( lpc->_pszSourceImage
                         && lpc->_pszSourceImage != lpc->_szNA
                         && lpc->_pszSourceImage != lpc->_szLocation ) {
                        TraceFree( lpc->_pszSourceImage );
                        lpc->_pszSourceImage = NULL;
                    }

                    lpc->_pszSourcePath  = pSIF->pszFilePath;
                    lpc->_pszSourceImage = pSIF->pszImageFile;

                    if ( pSIF->pszDescription ) {
                        wcsncpy( lpc->_szDescription, pSIF->pszDescription, ARRAYSIZE(lpc->_szDescription) );
                        lpc->_szDescription[ARRAYSIZE(lpc->_szDescription)-1] = L'\0';
                    } else {
                        lpc->_szDescription[0] = L'\0';
                    }

                    if ( pSIF->pszHelpText ) {
                        wcsncpy( lpc->_szHelpText, pSIF->pszHelpText, ARRAYSIZE(lpc->_szHelpText) );
                        lpc->_szHelpText[ARRAYSIZE(lpc->_szHelpText)-1] = L'\0';
                    } else {
                        lpc->_szHelpText[0] = L'\0';
                    }

                    pSIF->pszFilePath    = NULL;    // don't free this, we're using it
                    pSIF->pszImageFile   = NULL;    // don't free this, we're using it

                    ListView_DeleteAllItems( hwndList );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );

            case LVN_DELETEALLITEMS:
                TraceMsg( TF_WM, "LVN_DELETEALLITEMS - Deleting all items.\n" );
                break;

            case LVN_DELETEITEM:
                TraceMsg( TF_WM, "LVN_DELETEITEM - Deleting an item.\n" );
                {
                    LPNMLISTVIEW pnmv = (LPNMLISTVIEW) lParam;
                    LPSIFINFO pSIF = (LPSIFINFO) pnmv->lParam;
                    THR( lpc->_CleanupSIFInfo( pSIF ) );
                }
                break;

            case LVN_ITEMCHANGED:
                {
                    HWND hwndList = GetDlgItem( hDlg, IDC_L_SIFS );
                    UINT iItems = ListView_GetNextItem( hwndList, -1, LVNI_SELECTED );
                    if ( iItems != -1 ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    }
                }
                break;
            }
        }
        break;
    }

    return FALSE;
}

//
// Page8DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page8DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    Assert( lpc->_pszSourcePath );
                    Assert( lpc->_pszDestPath );

                    LPWSTR pszDestFilePath;
                    ULONG  uDestLength = wcslen( lpc->_pszDestPath );
                    LPWSTR pszFilename;

                    lpc->_fSIFCanExist = FALSE; // reset

                    if ( lpc->_fDestPathIncludesSIF ) {   // strip the filename
                        LPWSTR psz = StrRChr( lpc->_pszDestPath,
                                              &lpc->_pszDestPath[ uDestLength ],
                                              L'\\' );
                        Assert(psz);
                        *psz = L'\0';   // truncate
                        lpc->_fDestPathIncludesSIF = FALSE;

                        if ( !lpc->_fShowedPage8 ) {
                            SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                            return TRUE;
                        }

                        psz++;
                        pszFilename = psz;
                    } else {
                        pszFilename =
                        StrRChr( lpc->_pszSourcePath,
                                 &lpc->_pszSourcePath[wcslen(lpc->_pszSourcePath)],
                                 L'\\' );
                        Assert( pszFilename );
                        pszFilename++;  // move past the '\'

                        pszDestFilePath =
                        (LPWSTR) TraceAllocString( LMEM_FIXED,
                                                   uDestLength + 1
                                                   + wcslen( pszFilename ) + 1 );
                        if ( pszDestFilePath ) {
                            wcscpy( pszDestFilePath, lpc->_pszDestPath );
                            wcscat( pszDestFilePath, L"\\" );
                            wcscat( pszDestFilePath, pszFilename );

                            DWORD dwAttrs = GetFileAttributes( pszDestFilePath );
                            if ( dwAttrs == 0xFFFFffff ) { // file does not exist on destination server.
                                                           // Use the same SIF as the source.
                                TraceFree( lpc->_pszDestPath );
                                lpc->_pszDestPath = pszDestFilePath;
                                lpc->_fDestPathIncludesSIF = TRUE;
                                SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                                return TRUE;
                            }
                            TraceFree( pszDestFilePath );
                        }
                        // else be paranoid and prompt for a name
                    }

                    HWND hwnd = GetDlgItem( hDlg, IDC_E_FILENAME );
                    Assert( uDestLength <= MAX_PATH );
                    Edit_LimitText( hwnd, MAX_PATH - uDestLength );
                    Edit_SetText( hwnd, pszFilename );
                    lpc->_fShowedPage8 = TRUE;
                }
                break;

            case PSN_WIZBACK:
                lpc->_fShowedPage8 = FALSE;     // reset this
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    Assert( lpc->_pszDestPath );
                    Assert( !lpc->_fDestPathIncludesSIF );

                    HWND  hwndEdit    = GetDlgItem( hDlg, IDC_E_FILENAME );
                    ULONG uLength     = Edit_GetTextLength( hwndEdit );
                    ULONG uLengthDest = wcslen( lpc->_pszDestPath );
                    DWORD dwAttrs;

                    Assert( uLength );
                    AssertMsg( uLengthDest + uLength <= MAX_PATH,
                               "The Edit_LimitText() should prevent this from happening." );

                    uLength++;  // add one for the NULL

                    LPWSTR pszNewDestPath =
                    (LPWSTR) TraceAllocString( LMEM_FIXED,
                                               uLengthDest + 1 + uLength );
                    if ( !pszNewDestPath )
                        goto PSN_WIZNEXT_Abort;

                    wcscpy( pszNewDestPath, lpc->_pszDestPath );
                    wcscat( pszNewDestPath, L"\\" );

                    Edit_GetText( hwndEdit, &pszNewDestPath[uLengthDest + 1], uLength );

                    if ( !VerifySIFText( pszNewDestPath )
                         || StrChr( pszNewDestPath, 32 ) != NULL ) { // no spaces!
                        MessageBoxFromStrings( hDlg,
                                               IDS_OSCHOOSER_DIRECTORY_RESTRICTION_TITLE,
                                               IDS_OSCHOOSER_DIRECTORY_RESTRICTION_TEXT,
                                               MB_OK );
                        goto PSN_WIZNEXT_Abort;
                    }

                    // make sure it doesn't exist.
                    dwAttrs = GetFileAttributes( pszNewDestPath );
                    if ( dwAttrs != 0xFFFFffff ) { // file exists, verify with user to overwrite
                        UINT i = MessageBoxFromStrings( hDlg,
                                                        IDS_OVERWRITE_CAPTION,
                                                        IDS_OVERWRITE_TEXT,
                                                        MB_YESNO );
                        if ( i == IDNO ) {
                            goto PSN_WIZNEXT_Abort;
                        } else {
                            lpc->_fSIFCanExist = TRUE;
                        }
                    }

                    uLength = wcslen( pszNewDestPath );
                    if ( _wcsicmp( &pszNewDestPath[ uLength - 4 ], L".SIF" ) != 0 ) {
                        UINT i = MessageBoxFromStrings( hDlg,
                                                        IDC_IMPROPER_EXTENSION_CAPTION,
                                                        IDC_IMPROPER_EXTENSION_TEXT,
                                                        MB_YESNO );
                        if ( i == IDNO )
                            goto PSN_WIZNEXT_Abort;
                    }

                    TraceFree( lpc->_pszDestPath );
                    lpc->_pszDestPath = pszNewDestPath;
                    lpc->_fDestPathIncludesSIF = TRUE;
                    return FALSE; // do it
                    PSN_WIZNEXT_Abort:
                    if ( pszNewDestPath )
                        TraceFree( pszNewDestPath );
                    // no need to NULL, going out of scope
                    SetFocus( hwndEdit );
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't continue
                    return TRUE;
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;

    case WM_COMMAND:
        TraceMsg( TF_WM, "WM_COMMAND\n" );
        HWND hwnd = (HWND) lParam;
        switch ( LOWORD( wParam ) ) {
        case IDC_E_FILENAME:
            if ( HIWORD( wParam ) == EN_CHANGE ) {
                LONG uLength = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_FILENAME ) );
                if ( !uLength ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK );
                } else {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;
        }
        break;
    }

    return FALSE;
}

//
// Page9DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page9DlgProc(
                       HWND hDlg,
                       UINT uMsg,
                       WPARAM wParam,
                       LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            Edit_LimitText( GetDlgItem( hDlg, IDC_E_DESCRIPTION ),
                            ARRAYSIZE(lpc->_szDescription) - 1 );
            Edit_LimitText( GetDlgItem( hDlg, IDC_E_HELPTEXT),
                            ARRAYSIZE(lpc->_szHelpText) - 1 );
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    Assert( lpc->_pszSourcePath );
                    SetDlgItemText( hDlg, IDC_E_DESCRIPTION, lpc->_szDescription);
                    SetDlgItemText( hDlg, IDC_E_HELPTEXT, lpc->_szHelpText );
                    if ( !Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_DESCRIPTION ) )
                         || !Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_HELPTEXT ) ) ) {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK );
                    } else {
                        PropSheet_SetWizButtons( GetParent( hDlg ),
                                                 PSWIZB_BACK | PSWIZB_NEXT );
                    }
                }
                break;

            case PSN_WIZNEXT:
                TraceMsg( TF_WM, "PSN_WIZNEXT\n" );
                {
                    GetDlgItemText( hDlg,
                                    IDC_E_DESCRIPTION,
                                    lpc->_szDescription,
                                    ARRAYSIZE(lpc->_szDescription) );
                    GetDlgItemText( hDlg,
                                    IDC_E_HELPTEXT,
                                    lpc->_szHelpText,
                                    ARRAYSIZE(lpc->_szHelpText) );
                    if ( !VerifySIFText( lpc->_szDescription ) ) {
                        MessageBoxFromStrings( hDlg,
                                               IDS_OSCHOOSER_RESTRICTION_FIELDS_TITLE,
                                               IDS_OSCHOOSER_RESTRICTION_FIELDS_TEXT,
                                               MB_OK );
                        SetFocus( GetDlgItem( hDlg, IDC_E_DESCRIPTION ) );
                        SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't change
                        return TRUE;
                    }

                    if ( !VerifySIFText( lpc->_szHelpText ) ) {
                        MessageBoxFromStrings( hDlg,
                                               IDS_OSCHOOSER_RESTRICTION_FIELDS_TITLE,
                                               IDS_OSCHOOSER_RESTRICTION_FIELDS_TEXT,
                                               MB_OK );
                        SetFocus( GetDlgItem( hDlg, IDC_E_HELPTEXT ) );
                        SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't change
                        return TRUE;
                    }
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;

    case WM_COMMAND:
        TraceMsg( TF_WM, "WM_COMMAND\n" );
        switch ( LOWORD( wParam ) ) {
        case IDC_E_DESCRIPTION:
        case IDC_E_HELPTEXT:
            if ( HIWORD( wParam ) == EN_CHANGE ) {
                if ( !Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_DESCRIPTION ) )
                     || !Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_HELPTEXT ) ) ) {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK );
                } else {
                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_NEXT );
                }
                return TRUE;
            }
            break;
        }
        break;
    }

    return FALSE;
}


//
// Page10DlgProc( )
//
INT_PTR CALLBACK
THISCLASS::Page10DlgProc(
                        HWND hDlg,
                        UINT uMsg,
                        WPARAM wParam,
                        LPARAM lParam )
{
    LPTHISCLASS lpc = (LPTHISCLASS) GetWindowLongPtr( hDlg, GWLP_USERDATA );

    switch ( uMsg ) {
    case WM_INITDIALOG:
        TraceMsg( TF_WM, "WM_INITDIALOG\n" );
        {
            LPPROPSHEETPAGE ppsp = (LPPROPSHEETPAGE) lParam;
            Assert( ppsp );
            Assert( ppsp->lParam );
            SetWindowLongPtr( hDlg, GWLP_USERDATA, ppsp->lParam );
            // lpc = (LPTHISCLASS) ppsp->lParam;
            return TRUE;
        }
        break;

    case WM_NOTIFY:
        {
            LPNMHDR lpnmhdr = (LPNMHDR) lParam;
            Assert( lpc );

            switch ( lpnmhdr->code ) {
            case PSN_SETACTIVE:
                TraceMsg( TF_WM, "PSN_SETACTIVE\n" );
                if ( !lpc->_fAddSif ) {
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't show
                    return TRUE;
                } else {
                    WCHAR szTemp[ MAX_PATH ];
                    RECT  rect;

                    Assert( lpc->_pszSourcePath );
                    Assert( lpc->_pszDestPath );
                    Assert( lpc->_pszSourceImage );
                    Assert( lpc->_pszDestImage );

                    SetDlgItemText( hDlg, IDC_E_SOURCE, lpc->_pszSourcePath );

                    wcsncpy( szTemp, lpc->_pszSourceImage,MAX_PATH );
                    szTemp[MAX_PATH-1] = L'\0';
                    GetWindowRect( GetDlgItem( hDlg, IDC_S_SOURCEIMAGE ), &rect );
                    PathCompactPath( NULL, szTemp, rect.right - rect.left );
                    SetDlgItemText( hDlg, IDC_S_SOURCEIMAGE, szTemp );

                    SetDlgItemText( hDlg, IDC_E_DESTINATION, lpc->_pszDestPath );

                    wcsncpy( szTemp, lpc->_pszDestImage, MAX_PATH );
                    szTemp[MAX_PATH-1] = L'\0';
                    GetWindowRect( GetDlgItem( hDlg, IDC_S_DESTIMAGE ), &rect );
                    PathCompactPath( NULL, szTemp, rect.right - rect.left );
                    SetDlgItemText( hDlg, IDC_S_DESTIMAGE, szTemp );

                    PropSheet_SetWizButtons( GetParent( hDlg ),
                                             PSWIZB_BACK | PSWIZB_FINISH );
                }
                break;

            case PSN_WIZFINISH:
                TraceMsg( TF_WM, "PSN_WIZFINISH\n" );
                Assert( lpc->_pszSourcePath );
                Assert( lpc->_pszDestPath );
                Assert( wcslen( lpc->_pszSourcePath ) <= MAX_PATH );
                Assert( wcslen( lpc->_pszDestPath ) <= MAX_PATH );
                if ( !CopyFile( lpc->_pszSourcePath, lpc->_pszDestPath, !lpc->_fSIFCanExist ) ) {
                    DWORD dwErr = GetLastError( );
                    MessageBoxFromError( hDlg, IDS_ERROR_COPYING_FILE, dwErr );
                    SetWindowLongPtr( hDlg, DWLP_MSGRESULT, -1 ); // don't continue;
                    return TRUE;
                } else {
                    WCHAR szTemp[ REMOTE_INSTALL_MAX_HELPTEXT_CHAR_COUNT + 2 + 1 ];
                    Assert( REMOTE_INSTALL_MAX_DESCRIPTION_CHAR_COUNT
                            < REMOTE_INSTALL_MAX_HELPTEXT_CHAR_COUNT );
                    wsprintf( szTemp, L"\"%s\"", lpc->_szDescription );
                    WritePrivateProfileString( OSCHOOSER_SIF_SECTION,
                                               OSCHOOSER_DESCRIPTION_ENTRY,
                                               szTemp,
                                               lpc->_pszDestPath );
                    wsprintf( szTemp, L"\"%s\"", lpc->_szHelpText );
                    WritePrivateProfileString( OSCHOOSER_SIF_SECTION,
                                               OSCHOOSER_HELPTEXT_ENTRY,
                                               szTemp,
                                               lpc->_pszDestPath );
                }
                break;

            case PSN_QUERYCANCEL:
                TraceMsg( TF_WM, "PSN_QUERYCANCEL\n" );
                return lpc->_VerifyCancel( hDlg );
            }
        }
        break;
    }

    return FALSE;
}


//
// Verifies that the user wanted to cancel setup.
//
INT
THISCLASS::_VerifyCancel( HWND hParent )
{
    TraceClsFunc( "_VerifyCancel( ... )\n" );

    INT iReturn;
    BOOL fAbort = FALSE;

    iReturn = MessageBoxFromStrings( hParent,
                                     IDS_CANCELCAPTION,
                                     IDS_CANCELTEXT,
                                     MB_YESNO | MB_ICONQUESTION );
    if ( iReturn == IDYES ) {
        fAbort = TRUE;
    }

    SetWindowLongPtr( hParent, DWLP_MSGRESULT, ( fAbort ? 0 : -1 ));

    RETURN(!fAbort);
}