/****************************************************************************

   Copyright (c) Microsoft Corporation 1997
   All rights reserved
 
 ***************************************************************************/

#include "pch.h"
#include <shlobj.h>
#include <setupapi.h>
#include <advpub.h>
#include <lm.h>

#include "dialogs.h"

DEFINE_MODULE("Setup");

#define SMALL_BUFFER_SIZE   256
#define MAX_FILES_SIZE      640000

static const TCHAR chSlash = TEXT('\\');

//
// Opens the layout.inf file for a particular platform.
//
HINF
OpenLayoutInf( )
{
    TCHAR   szFilename[ MAX_PATH ];
    HANDLE  hFile;
    UINT    uErr;
    DWORD   dwLen;
	DWORD   dw;

    lstrcpy( szFilename, g_Options.szSourcePath );

    dwLen = lstrlen( szFilename );
    szFilename[ dwLen++ ] = chSlash;

    dw = LoadString( g_hinstance, IDS_NTSETUPINFFILENAME, 
        &szFilename[ dwLen ], ARRAYSIZE( szFilename ) - dwLen );
	Assert( dw );

    hFile = SetupOpenInfFile( szFilename, NULL, INF_STYLE_WIN4, &uErr );	

    return hFile;
}

//
// Creates the RemoteBoot directory tree.
//
HRESULT
CreateDirectories( HWND hDlg )
{
    BOOL  fReturn = FALSE;
    TCHAR szPath[ MAX_PATH ];
    TCHAR szCreating[ SMALL_BUFFER_SIZE ];
    HWND  hProg = GetDlgItem( hDlg, IDC_P_METER );
    DWORD dwLen;
	DWORD dw;

    SendMessage( hProg, PBM_SETRANGE, 0, 
        MAKELPARAM(0, 4 + ( g_Options.fCreateDirectory ? 1 : 0 )) );
    SendMessage( hProg, PBM_SETSTEP, 1, 0 );

    dw = LoadString( g_hinstance, IDS_CREATINGDIRECTORIES, szCreating, 
        ARRAYSIZE( szCreating ) );
	Assert( dw );
    SetWindowText( GetDlgItem( hDlg, IDC_S_OPERATION ), szCreating );

    if ( g_Options.fCreateDirectory )
    {
        fReturn = CreateDirectory( g_Options.szRemoteBootPath, NULL );
        SendMessage( hProg, PBM_DELTAPOS, 1, 0 );
        if ( !fReturn )
            goto Finish;
    }

    lstrcpy( szPath, g_Options.szRemoteBootPath );

    dwLen = lstrlen( szPath );
    szPath[ dwLen ] = chSlash;
    dwLen++;

    dw = LoadString( g_hinstance, IDS_IMAGES, &szPath[ dwLen ], 
        ARRAYSIZE( szPath ) - dwLen );
	Assert( dw );
    CreateDirectory( szPath, NULL );
    SendMessage( hProg, PBM_DELTAPOS, 1, 0 );

    lstrcpy( g_Options.szImagesPath, szPath );

    dw = LoadString( g_hinstance, IDS_TEMPLATEPATH, &szPath[ dwLen ], 
        ARRAYSIZE( szPath )- dwLen );
	Assert( dw );
    CreateDirectory( szPath, NULL );
    SendMessage( hProg, PBM_DELTAPOS, 1, 0 );

    dw = LoadString( g_hinstance, IDS_SETUP, &szPath[ dwLen ], 
        ARRAYSIZE( szPath ) - dwLen );
	Assert( dw );
    CreateDirectory( szPath, NULL );
    SendMessage( hProg, PBM_DELTAPOS, 1, 0 );

    dwLen = lstrlen( szPath );
    szPath[ dwLen ] = chSlash;
    dwLen++;

    lstrcpy( &szPath[ dwLen ], g_Options.szName );
    CreateDirectory( szPath, NULL );
    SendMessage( hProg, PBM_DELTAPOS, 1, 0 );

    /*
    // add '\i386'
    dwLen = lstrlen( szPath );
    szPath[ dwLen ] = chSlash;
    dwLen++;
    dw = LoadString( g_hinstance, IDS_INTELPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
	Assert( dw );
    */
    lstrcpy( g_Options.szSetupPath, szPath );

    fReturn = TRUE;

Finish:
    g_Options.fError = !fReturn;
    return fReturn ? S_OK : E_FAIL;
}


//
// Find the filename part from a complete path.
//
LPTSTR FilenameOnly( LPTSTR pszPath )
{
    LPTSTR psz = pszPath;

    // find the end
    while ( *psz )
        psz++;

    // find the slash
    while ( psz > pszPath && *psz != chSlash )
        psz--;

    // move in front of the slash
    if ( psz != pszPath )
        psz++;

    return psz;
}

typedef struct {
    PVOID pContext;                             // "Context" for DefaultQueueCallback
    HWND  hProg;                                // hwnd to the progress meter
    HWND  hOperation;                           // hwnd to the "current operation"
    DWORD nCopied;                              // number of files copied
    DWORD nToBeCopied;                          // number of file to be copied
    DWORD dwCopyingLength;                      // length of the IDS_COPYING
    TCHAR szCopyingString[ SMALL_BUFFER_SIZE ]; // buffer to create "Copying file.ext..."
} MYCONTEXT, *LPMYCONTEXT;

//
//
//
UINT CALLBACK
CopyFilesCallback(
    IN PVOID Context,
    IN UINT Notification,
    IN UINT Param1,
    IN UINT Param2
    )
{
    MSG  Msg;
    LPMYCONTEXT pMyContext = (LPMYCONTEXT) Context;
	DWORD dw;

    // process some messages
    if ( PeekMessage( &Msg, NULL, 0, 0, PM_REMOVE ) )
    {
        TranslateMessage( &Msg );
        DispatchMessage( &Msg );
    }

    if ( g_Options.fAbort )
    {        
        if ( !g_Options.fError )
        {
            TCHAR    szAbort[ SMALL_BUFFER_SIZE ];

            // change filename text to aborting...
            dw = LoadString( g_hinstance, IDS_ABORTING, szAbort, 
                ARRAYSIZE( szAbort ) );
			Assert( dw );
            SetWindowText( pMyContext->hOperation, szAbort );

            g_Options.fError = TRUE;
        }

        SetLastError(ERROR_CANCELLED);
        return FILEOP_ABORT;
    }

    switch ( Notification )
    {
    case SPFILENOTIFY_ENDCOPY:
        pMyContext->nCopied++;
        SendMessage( pMyContext->hProg, PBM_SETPOS, 
            (1000 * pMyContext->nCopied) / pMyContext->nToBeCopied, 0 );
        break;

    case SPFILENOTIFY_STARTCOPY:
        {
            DWORD    dwLen;
            LPTSTR * ppszCopyingFile = (LPTSTR *) Param1;

            lstrcpy( &pMyContext->szCopyingString[ pMyContext->dwCopyingLength ], 
                FilenameOnly( *ppszCopyingFile ) );
            dwLen = lstrlen( pMyContext->szCopyingString );
            lstrcpy( &pMyContext->szCopyingString[ dwLen ], TEXT("...") );

            SetWindowText( pMyContext->hOperation, pMyContext->szCopyingString );
        }
        break;
    
    case SPFILENOTIFY_RENAMEERROR:
    case SPFILENOTIFY_DELETEERROR:
    case SPFILENOTIFY_COPYERROR:
    case SPFILENOTIFY_NEEDMEDIA:
    case SPFILENOTIFY_LANGMISMATCH:
    case SPFILENOTIFY_TARGETEXISTS:
    case SPFILENOTIFY_TARGETNEWER:
        return SetupDefaultQueueCallback( pMyContext->pContext, Notification, 
            Param1, Param2 );
    }

    return FILEOP_DOIT;
}

//
// Find a character in a NULL terminated string.
//
// Returns NULL is not found.
//
LPTSTR
FindChar( LPTSTR pszSrc, TCHAR ch )
{
    if ( pszSrc )
    {
        while ( *pszSrc )
        {
            if ( *pszSrc == ch )
                return pszSrc;

            pszSrc++;
        }
    }

    return NULL;
}

//
// change layout format to double-null list
//
void
LayoutToDoubleNullList( LPTSTR pszList )
{
/*
    Borrowed from LAYOUT.INF for reference
;
; filename_on_source = diskid,subdir,size,checksum,spare,spare
; extra fields are nt-specific
;   bootmediaord: _1 (floppy #1)
;                 _2 (floppy #2)
;                 _3 (floppy #3)
;                 _x (textmode setup)
;                nothing (gui mode setup)
;   targetdirectory : 1 - 41 (see "WinntDirectories", above)
;   upgradedisposition : 0 (always copy)
;                        1 (copy if present)
;                        2 (copy if not present)
;                        3 (never copy)
;   textmodedisposition:
;   targetname
;
*/

    static const TCHAR chComma = TEXT(',');
    LPTSTR pszFile     = pszList;
    LPTSTR pszCopyHere = pszList;

    while ( *pszFile )
    {
        MSG    Msg;
        DWORD  dwToNextFile = lstrlen( pszFile );
        LPTSTR pszNext;
        LPTSTR psz = FindChar( pszFile, TEXT('=') );
        Assert( psz );

        // process some messages
        if ( PeekMessage( &Msg, NULL, 0, 0, PM_REMOVE ) )
        {
            TranslateMessage( &Msg );
            DispatchMessage( &Msg );
        }

        *psz = 0;
        psz++;

        pszNext  = FindChar( psz, chComma );
        *pszNext = 0;

        // must be "1"
        if ( !lstrcmp( psz, TEXT("1") ) )
        {
            // copy file name
            lstrcpy( pszCopyHere, pszFile );

            // advance copy pointer
            pszCopyHere += 1 + lstrlen( pszCopyHere );
        }
        else
        {
            AssertMsg( FALSE, "Now what?!" );
        }

        // advanced file pointer
        pszFile += dwToNextFile + 1;
    }

    *pszCopyHere = 0;
}

//
// change semicolon delinated list to double-null list
//
void
SemiColonToDoubleNullList( LPTSTR pszList )
{
    while ( *pszList )
    {
        if ( *pszList == TEXT(';') )
        {
            *pszList = 0;
        }

        pszList++;
    }
    pszList++;
    *pszList = 0;   // double the null.
}


//
// Adds double-null terminated list of file name to the Queue. The filename 
// can have a comma in it indicating a rename operation:
// optionalpath\newname.ext,optionalpath\sourcefil.ext
//
// Returns the number of files added to the Queue.
//
DWORD 
CopyFilesAddToQueue( 
    HSPFILEQ Queue,     // setup Queue
    LPTSTR pszSource,   // source directory
    LPTSTR pszDest,     // destination directory
    LPTSTR pszFiles,    // Double-null terminated file list
    LPTSTR pszSubpath,  // optional sub-path
    DWORD  dwCopyStyle) // flags
{
    DWORD  dwCount = 0;
    LPTSTR psz = pszFiles;
    static const TCHAR chComma = TEXT(',');

    while ( *pszFiles )
    {
        DWORD dwLen;

        psz = pszFiles;
        // check for comma which indicates rename
        while (*psz && *psz != chComma)
            psz++;

        if ( *psz == chComma )
        {
            *psz= 0;   // terminate
            psz++;
        }
        else
        {   // sources name is dest name
            psz = pszFiles;
        }

        SetupQueueCopy( 
            Queue, 
            pszSource, 
            pszSubpath, 
            psz,
            NULL, 
            NULL, 
            pszDest, 
            pszFiles,
            dwCopyStyle );

        // get next file
        pszFiles = psz + lstrlen( psz ) + 1;
        dwCount++;
    }

    return dwCount;
}

//
// Copies the files into the setup directory.
//
HRESULT
CopyFiles( HWND hDlg )
{
    TCHAR   szLayoutFilename[ MAX_PATH ];
    TCHAR   szSystemPath[ MAX_PATH ];
    DWORD   dwLen;
    LPTSTR  psz;
    BOOL    fReturn  = FALSE;
    HWND    hProg    = GetDlgItem( hDlg, IDC_P_METER );
    LPTSTR  pszFiles = (LPTSTR) TraceAlloc( GMEM_FIXED, MAX_FILES_SIZE );
    DWORD   dwCount  = 0;
	DWORD   dw;

    HSPFILEQ Queue;
    MYCONTEXT MyContext;

    if ( !pszFiles || g_Options.fAbort )
        goto Finish;

    // Setup and display next section of dialog
    SendMessage( hProg, PBM_SETRANGE, 0, MAKELPARAM(0, 1000 ));
    SendMessage( hProg, PBM_SETPOS, 0, 0 );

    dw = LoadString( g_hinstance, IDS_BUILDINGFILELIST, szLayoutFilename, ARRAYSIZE( szLayoutFilename ));
	Assert( dw );
    SetDlgItemText( hDlg, IDC_S_OPERATION, szLayoutFilename );

    // Create layout filepath
    lstrcpy( szLayoutFilename, g_Options.szSourcePath );
    dwLen = lstrlen( szLayoutFilename );
    szLayoutFilename[ dwLen ] = chSlash;
    dwLen++;

    dw = LoadString( g_hinstance, IDS_NTSETUPINFFILENAME, 
        &szLayoutFilename[ dwLen ], ARRAYSIZE( szLayoutFilename )- dwLen );
	Assert( dw );

    Queue = SetupOpenFileQueue( );
    
    // add the files from the INF to the Queue
    GetPrivateProfileSection( TEXT("SourceDisksFiles"), pszFiles, MAX_FILES_SIZE, 
        szLayoutFilename );
    LayoutToDoubleNullList( pszFiles );

    if ( g_Options.fIntel )
    {
        TCHAR szPath[ MAX_PATH ];
        DWORD dwLen;

        lstrcpy( szPath, g_Options.szSetupPath );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_INTELPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( dw );

        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_WARNIFSKIP );

        // add the processor dependant files from the INF to the Queue
        GetPrivateProfileSection( TEXT("SourceDisksFiles.x86"), pszFiles, MAX_FILES_SIZE, 
            szLayoutFilename );
        LayoutToDoubleNullList( pszFiles );
        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_WARNIFSKIP );

        // additional files not listed
        dw = LoadString( g_hinstance, IDS_FILESTOBECOPIED, pszFiles, MAX_FILES_SIZE );
        SemiColonToDoubleNullList( pszFiles );
        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, pszFiles, NULL,
            SP_COPY_NEWER | SP_COPY_WARNIFSKIP );
    }

    if ( g_Options.fAlpha )
    {
        TCHAR szPath[ MAX_PATH ];
        DWORD dwLen;

        lstrcpy( szPath, g_Options.szSetupPath );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_ALPHAPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( dw );

        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_WARNIFSKIP );

        // add the processor dependant files from the INF to the Queue
        GetPrivateProfileSection( TEXT("SourceDisksFiles.Alpha"), pszFiles, MAX_FILES_SIZE, 
            szLayoutFilename );
        LayoutToDoubleNullList( pszFiles );
        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_WARNIFSKIP );

        // additional files not listed
        dw = LoadString( g_hinstance, IDS_FILESTOBECOPIED, pszFiles, MAX_FILES_SIZE );
		Assert( dw );
        SemiColonToDoubleNullList( pszFiles );
        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, pszFiles, NULL,
            SP_COPY_NEWER | SP_COPY_WARNIFSKIP );
    }

    // add template files
    if ( g_Options.fIntel )
    {
        TCHAR szPath[ MAX_PATH ];
        DWORD dwLen;

        lstrcpy( szPath, g_Options.szRemoteBootPath );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_TEMPLATEPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( szPath );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_INTELPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( dw );

        dw = LoadString( g_hinstance, IDS_TEMPLATEFILES_INTEL, pszFiles, MAX_FILES_SIZE );
		Assert( dw );
        SemiColonToDoubleNullList( pszFiles );
        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_NOOVERWRITE | SP_COPY_WARNIFSKIP );
    }

    if ( g_Options.fAlpha )
    {
        TCHAR szPath[ MAX_PATH ];
        DWORD dwLen;

        lstrcpy( szPath, g_Options.szRemoteBootPath );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_TEMPLATEPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( dw );
        dwLen = lstrlen( szPath );
        szPath[ dwLen++ ] = chSlash;
        dw = LoadString( g_hinstance, IDS_INTELPATH, &szPath[ dwLen ], ARRAYSIZE( szPath ) - dwLen );
		Assert( dw );

        dw = LoadString( g_hinstance, IDS_TEMPLATEFILES_ALPHA, pszFiles, MAX_FILES_SIZE );
		Assert( dw );

        dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szPath, 
            pszFiles, NULL, SP_COPY_NEWER | SP_COPY_NOOVERWRITE | SP_COPY_WARNIFSKIP );
    }

    /* BEGIN

        ADD/REMOVE PROGRAMS SHOULD DO THIS PART 
    // add the services to the Queue
    GetSystemDirectory( szSystemPath, MAX_PATH );
    dw = LoadString( g_hinstance, IDS_SERVICESFILES, pszFiles, MAX_FILES_SIZE );
	Assert( dw );
    SemiColonToDoubleNullList( pszFiles );
    dwCount += CopyFilesAddToQueue( Queue, g_Options.szSourcePath, szSystemPath, pszFiles, NULL,
        SP_COPY_NEWER | SP_COPY_NOOVERWRITE | SP_COPY_WARNIFSKIP );

       END */

    // This information will be passed to CopyFileCallback() as
    // the Context.
    MyContext.nToBeCopied        = dwCount;
    MyContext.nCopied            = 0;
    MyContext.pContext           = SetupInitDefaultQueueCallback( hDlg );
    MyContext.hProg              = hProg;
    MyContext.hOperation          = GetDlgItem( hDlg, IDC_S_OPERATION );
    MyContext.dwCopyingLength = 
        LoadString( g_hinstance, IDS_COPYING, MyContext.szCopyingString, 
        ARRAYSIZE( MyContext.szCopyingString ) );
	Assert( MyContext.dwCopyingLength );

    // Start copying
    fReturn = SetupCommitFileQueue( hDlg, Queue, (PSP_FILE_CALLBACK) CopyFilesCallback, 
        (PVOID) &MyContext );

Finish:
    SendMessage( hProg, PBM_SETPOS, 1000, 0 );

    if ( Queue )
        SetupCloseFileQueue( Queue );

    if ( pszFiles )
        TraceFree( pszFiles );

    g_Options.fError = !fReturn;
    return fReturn ? S_OK : E_FAIL;
}


//
// Modifies registry entries from the SELFREG.INF resource
//
HRESULT
ModifyRegistry( HWND hDlg )
{
    HRESULT  hr = E_FAIL;
    char     szRemoteBootPath[ MAX_PATH ];
    TCHAR    szText[ SMALL_BUFFER_SIZE ];
    STRENTRY seReg[] = {
        { "25", "%SystemRoot%" },           // NT-specific
        { "11", "%SystemRoot%\\system32" }, // NT-specific
        { "RemoteBoot", szRemoteBootPath },
    };
    STRTABLE stReg = { ARRAYSIZE(seReg), seReg };
    HWND hProg = GetDlgItem( hDlg, IDC_P_METER );
	DWORD dw;

    SendMessage( hProg, PBM_SETRANGE, 0, MAKELPARAM(0, 1 ));
    SendMessage( hProg, PBM_SETPOS, 0, 0 );

    dw = LoadString( g_hinstance, IDS_UPDATING_REGISTRY, szText, ARRAYSIZE( szText ) );
	Assert( dw );
    SetWindowText( GetDlgItem( hDlg, IDC_S_OPERATION ), szText );

    // fill in substitution variables
    WideCharToMultiByte( CP_ACP, 0, g_Options.szRemoteBootPath, -1,
        szRemoteBootPath, ARRAYSIZE( szRemoteBootPath ), NULL, NULL );

    hr = THR( RegInstall( g_hinstance, "InstallRemoteBoot", &stReg) );

    SendMessage( hProg, PBM_SETPOS, 1 , 0 );
    return hr;
}

//
// Creates the services needed for remote boot.
//
HRESULT
StartRemoteBootServices( HWND hDlg )
{
    TCHAR     szTFTPD[ SMALL_BUFFER_SIZE ];
    TCHAR     szBINL[ SMALL_BUFFER_SIZE ];
    TCHAR     szTFTPDName[ SMALL_BUFFER_SIZE ];
    TCHAR     szBINLName[ SMALL_BUFFER_SIZE ];
    TCHAR     szText[ SMALL_BUFFER_SIZE ];
    SC_HANDLE schSystem;
    SC_HANDLE schTFTPD;
    SC_HANDLE schTCPService;
    DWORD     dwErr = S_OK;
    HWND      hProg = GetDlgItem( hDlg, IDC_P_METER );
	DWORD     dw;

    SendMessage( hProg, PBM_SETRANGE, 0, MAKELPARAM(0, 1 ));
    SendMessage( hProg, PBM_SETPOS, 0, 0 );

    dw = LoadString( g_hinstance, IDS_STARTING_SERVICES, szText, ARRAYSIZE( szText ) );
	Assert( dw );
    SetDlgItemText( hDlg, IDC_S_OPERATION, szText );

    dw = LoadString( g_hinstance, IDS_TFTPD,             szTFTPD, 
        ARRAYSIZE( szTFTPD ) );
	Assert( dw );
    dw = LoadString( g_hinstance, IDS_BINL,              szBINL,      
        ARRAYSIZE( szBINL ) );
	Assert( dw );
    dw = LoadString( g_hinstance, IDS_TFTPD_SERVICENAME, szTFTPDName, 
        ARRAYSIZE( szTFTPDName ) );
	Assert( dw );
    dw = LoadString( g_hinstance, IDS_BINL_SERVICENAME,  szBINLName,  
        ARRAYSIZE( szBINLName ) );
	Assert( dw );

    schSystem = OpenSCManager( NULL, NULL, SC_MANAGER_ALL_ACCESS );
    Assert( schSystem );
    if ( !schSystem )
        goto Cleanup;

    schTFTPD = OpenService( schSystem, szTFTPD, 
        STANDARD_RIGHTS_REQUIRED | SERVICE_START );

    schTCPService = OpenService( schSystem, szBINL, 
        STANDARD_RIGHTS_REQUIRED | SERVICE_START );

    // start TFTPD
    if ( !StartService( schTFTPD, 0, NULL ) )
    {
        dwErr = GetLastError( );
        switch ( dwErr )
        {
        default:
            dw = LoadString( g_hinstance, IDS_ERROR_STARTING_SERVICE, szText, 
                ARRAYSIZE( szText ) );
			Assert( dw );
            MessageBox( hDlg, szText, szTFTPDName, MB_OK );
            break;

        case ERROR_SERVICE_ALREADY_RUNNING:
            break;
        }
    }

    // start TCP services
    dw = LoadString( g_hinstance, IDS_STARTING_SERVICES, szText, ARRAYSIZE( szText ) );
	Assert( dw );
    SetDlgItemText( hDlg, IDC_S_OPERATION, szText );
    if ( !StartService( schTCPService, 0, NULL ) )
    {
        dwErr = GetLastError( );
        switch ( dwErr )
        {
        default:
            dw = LoadString( g_hinstance, IDS_ERROR_STARTING_SERVICE, szText, 
                ARRAYSIZE( szText ) );
			Assert( dw );
            MessageBox( hDlg, szText, szBINLName, MB_OK );
            break;

        case ERROR_SERVICE_ALREADY_RUNNING:
            break;
        }
    }
    SendMessage( hProg, PBM_SETPOS, 1 , 0 );

Cleanup:    
    if ( schTCPService )
        CloseServiceHandle( schTCPService );

    if ( schTFTPD )
        CloseServiceHandle( schTFTPD );

    if ( schSystem )
        CloseServiceHandle( schSystem );

    return dwErr;
}

//
// create RemoteBoot share
//
HRESULT
CreateRemoteBootShare( HWND hDlg )
{
    SHARE_INFO_502  si502;
    TCHAR szRemark[ SMALL_BUFFER_SIZE ];
    TCHAR szRemoteBoot[ SMALL_BUFFER_SIZE ];
    TCHAR szText[ SMALL_BUFFER_SIZE ];
    DWORD dwErr;
    HWND  hProg = GetDlgItem( hDlg, IDC_P_METER );
	DWORD dw;

    dw = LoadString( g_hinstance, IDS_CREATINGSHARES, szText, ARRAYSIZE( szText ) );
	Assert( dw );
    SetDlgItemText( hDlg, IDC_S_OPERATION, szText );

    dw = LoadString( g_hinstance, IDS_REMOTEBOOTSHAREREMARK, szRemark, 
        ARRAYSIZE( szRemark ) );
	Assert( dw );
    dw = LoadString( g_hinstance, IDS_REMOTEBOOTSHARENAME, szRemoteBoot, 
        ARRAYSIZE( szRemoteBoot ) );
	Assert( dw );

    si502.shi502_netname             = szRemoteBoot;
    si502.shi502_type                = STYPE_DISKTREE;
    si502.shi502_remark              = szRemark;
    si502.shi502_permissions         = ACCESS_ALL;
    si502.shi502_max_uses            = -1;   // unlimited
    si502.shi502_current_uses        = 0;
    si502.shi502_path                = g_Options.szRemoteBootPath;
    si502.shi502_passwd              = NULL; // ignored
    si502.shi502_reserved            = 0;    // must be zero
    si502.shi502_security_descriptor = NULL;

    NetShareAdd( NULL, 502, (LPBYTE) &si502, &dwErr );
    switch ( dwErr )
    {
        // ignore these
    case NERR_Success:
    case NERR_DuplicateShare:
        break;

    default:
        MessageBoxFromStrings( hDlg, IDS_SHAREERRORCAPTION, IDS_SHAREERRORTEXT, MB_OK );
    }

    SendMessage( hProg, PBM_DELTAPOS, 1 , 0 );

    return dwErr;
}