You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1511 lines
40 KiB
1511 lines
40 KiB
/*
|
|
* Copyright (c) 2001 Microsoft Corporation
|
|
*
|
|
* Module Name:
|
|
*
|
|
* ocgen.cpp
|
|
*
|
|
* Abstract:
|
|
*
|
|
* This file handles all messages passed by the OC Manager
|
|
*
|
|
* Author:
|
|
*
|
|
* Michael Zoran (mzoran) Dec-2001
|
|
*
|
|
* Environment:
|
|
*
|
|
* User Mode
|
|
*/
|
|
|
|
#define _OCGEN_CPP_
|
|
#include <stdlib.h>
|
|
#include <assert.h>
|
|
#include <tchar.h>
|
|
#include <objbase.h>
|
|
#include <shlwapi.h>
|
|
#include <lm.h>
|
|
#include <malloc.h>
|
|
#include "ocgen.h"
|
|
#pragma hdrstop
|
|
|
|
// also referred to in ocgen.h // forward reference
|
|
|
|
struct BITS_SUBCOMPONENT_DATA
|
|
{
|
|
const TCHAR * SubcomponentName;
|
|
const TCHAR * SubcomponentKeyFileName;
|
|
UINT64 FileVersion;
|
|
BOOL Preinstalled;
|
|
BOOL ShouldUpgrade;
|
|
};
|
|
|
|
DWORD OnInitComponent(LPCTSTR ComponentId, PSETUP_INIT_COMPONENT psc);
|
|
DWORD_PTR OnQueryImage();
|
|
DWORD OnQuerySelStateChange(LPCTSTR ComponentId, LPCTSTR SubcomponentId, UINT state, UINT flags);
|
|
DWORD OnCalcDiskSpace(LPCTSTR ComponentId, LPCTSTR SubcomponentId, DWORD addComponent, HDSKSPC dspace);
|
|
DWORD OnQueueFileOps(LPCTSTR ComponentId, LPCTSTR SubcomponentId, HSPFILEQ queue);
|
|
DWORD OnCompleteInstallation(LPCTSTR ComponentId, LPCTSTR SubcomponentId);
|
|
DWORD OnQueryState(LPCTSTR ComponentId, LPCTSTR SubcomponentId, UINT state);
|
|
DWORD OnAboutToCommitQueue(LPCTSTR ComponentId, LPCTSTR SubcomponentId);
|
|
DWORD OnExtraRoutines(LPCTSTR ComponentId, PEXTRA_ROUTINES per);
|
|
|
|
BOOL VerifyComponent(LPCTSTR ComponentId);
|
|
BOOL StateInfo(LPCTSTR SubcomponentId, BOOL *state);
|
|
DWORD RegisterServers(HINF hinf, LPCTSTR component, DWORD state);
|
|
DWORD EnumSections(HINF hinf, const TCHAR *component, const TCHAR *key, DWORD index, INFCONTEXT *pic, TCHAR *name);
|
|
DWORD RegisterServices(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
DWORD CleanupNetShares(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
DWORD RunExternalProgram(PPER_COMPONENT_DATA cd, LPCTSTR component, DWORD state);
|
|
|
|
BITS_SUBCOMPONENT_DATA* FindSubcomponent( LPCTSTR SubcomponentId );
|
|
DWORD InitializeSubcomponentStates( );
|
|
DWORD GetFileVersion64( LPCTSTR szFullPath, ULONG64 *pVer );
|
|
DWORD GetModuleVersion64( HMODULE hDll, ULONG64 * pVer );
|
|
|
|
BOOL StopIIS();
|
|
BOOL RestartIIS();
|
|
BOOL RegBITSSrv();
|
|
BOOL UnregBITSSrv();
|
|
BOOL SrvFileIsInUse();
|
|
|
|
// for registering dlls
|
|
|
|
typedef HRESULT (__stdcall *pfn)(void);
|
|
|
|
#define KEYWORD_REGSVR TEXT("RegSvr")
|
|
#define KEYWORD_UNREGSVR TEXT("UnregSvr")
|
|
#define KEYWORD_UNINSTALL TEXT("Uninstall")
|
|
#define KEYWORD_SOURCEPATH TEXT("SourcePath")
|
|
#define KEYWORD_DELSHARE TEXT("DelShare")
|
|
#define KEYWORD_ADDSERVICE TEXT("AddService")
|
|
#define KEYWORD_DELSERVICE TEXT("DelService")
|
|
#define KEYWORD_SHARENAME TEXT("Share")
|
|
#define KEYWORD_RUN TEXT("Run")
|
|
#define KEYVAL_SYSTEMSRC TEXT("SystemSrc")
|
|
#define KEYWORD_COMMANDLINE TEXT("CommandLine")
|
|
#define KEYWORD_TICKCOUNT TEXT("TickCount")
|
|
|
|
// Services keywords/options
|
|
#define KEYWORD_SERVICENAME TEXT("ServiceName")
|
|
#define KEYWORD_DISPLAYNAME TEXT("DisplayName")
|
|
#define KEYWORD_SERVICETYPE TEXT("ServiceType")
|
|
#define KEYWORD_STARTTYPE TEXT("StartType")
|
|
#define KEYWORD_ERRORCONTROL TEXT("ErrorControl")
|
|
#define KEYWORD_IMAGEPATH TEXT("BinaryPathName")
|
|
#define KEYWORD_LOADORDER TEXT("LoadOrderGroup")
|
|
#define KEYWORD_DEPENDENCIES TEXT("Dependencies")
|
|
#define KEYWORD_STARTNAME TEXT("ServiceStartName")
|
|
#define KEYWORD_PASSWORD TEXT("Password")
|
|
|
|
#define KEYVAL_ON TEXT("on")
|
|
#define KEYVAL_OFF TEXT("off")
|
|
#define KEYVAL_DEFAULT TEXT("default")
|
|
|
|
const char gszRegisterSvrRoutine[] = "DllRegisterServer";
|
|
const char gszUnregisterSvrRoutine[] = "DllUnregisterServer";
|
|
BOOL g_fRebootNeed = FALSE;
|
|
|
|
BITS_SUBCOMPONENT_DATA g_Subcomponents[] =
|
|
{
|
|
{
|
|
TEXT("BITSServerExtensionsManager"),
|
|
TEXT("bitsmgr.dll"),
|
|
0,
|
|
FALSE,
|
|
FALSE
|
|
},
|
|
|
|
{
|
|
TEXT("BITSServerExtensionsISAPI"),
|
|
TEXT("bitssrv.dll"),
|
|
0,
|
|
FALSE,
|
|
FALSE
|
|
}
|
|
};
|
|
|
|
const ULONG g_NumberSubcomponents = 2;
|
|
BOOL g_AllSubcomponentsPreinstalled = FALSE;
|
|
BOOL g_UpdateNeeded = FALSE;
|
|
BOOL g_IISStopped = FALSE;
|
|
|
|
PER_COMPONENT_DATA g_Component;
|
|
|
|
/*
|
|
* called by CRT when _DllMainCRTStartup is the DLL entry point
|
|
*/
|
|
|
|
BOOL
|
|
WINAPI
|
|
DllMain(
|
|
IN HINSTANCE hinstance,
|
|
IN DWORD reason,
|
|
IN LPVOID reserved
|
|
)
|
|
{
|
|
|
|
BOOL b;
|
|
|
|
UNREFERENCED_PARAMETER(reserved);
|
|
|
|
b = true;
|
|
|
|
switch(reason)
|
|
{
|
|
case DLL_PROCESS_ATTACH:
|
|
ghinst = hinstance;
|
|
loginit();
|
|
|
|
// Fall through to process first thread
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
b = true;
|
|
break;
|
|
|
|
case DLL_PROCESS_DETACH:
|
|
break;
|
|
|
|
case DLL_THREAD_DETACH:
|
|
break;
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
DWORD_PTR
|
|
OcEntry(
|
|
IN LPCTSTR ComponentId,
|
|
IN LPCTSTR SubcomponentId,
|
|
IN UINT Function,
|
|
IN UINT Param1,
|
|
IN OUT PVOID Param2
|
|
)
|
|
{
|
|
|
|
DWORD_PTR rc;
|
|
|
|
DebugTraceOCNotification(Function, ComponentId);
|
|
logOCNotification(Function, ComponentId);
|
|
|
|
switch(Function)
|
|
{
|
|
|
|
case OC_PREINITIALIZE:
|
|
#ifdef ANSI
|
|
rc = OCFLAG_ANSI;
|
|
#else
|
|
rc = OCFLAG_UNICODE;
|
|
#endif
|
|
break;
|
|
|
|
case OC_INIT_COMPONENT:
|
|
rc = OnInitComponent(ComponentId, (PSETUP_INIT_COMPONENT)Param2);
|
|
break;
|
|
|
|
case OC_EXTRA_ROUTINES:
|
|
rc = OnExtraRoutines(ComponentId, (PEXTRA_ROUTINES)Param2);
|
|
break;
|
|
|
|
case OC_SET_LANGUAGE:
|
|
rc = (DWORD_PTR)false;
|
|
break;
|
|
|
|
case OC_QUERY_IMAGE:
|
|
rc = OnQueryImage();
|
|
break;
|
|
|
|
case OC_REQUEST_PAGES:
|
|
rc = 0;
|
|
break;
|
|
|
|
case OC_QUERY_CHANGE_SEL_STATE:
|
|
rc = OnQuerySelStateChange(ComponentId, SubcomponentId, Param1, (UINT)((UINT_PTR)Param2));
|
|
break;
|
|
|
|
case OC_CALC_DISK_SPACE:
|
|
rc = OnCalcDiskSpace(ComponentId, SubcomponentId, Param1, Param2);
|
|
break;
|
|
|
|
case OC_QUEUE_FILE_OPS:
|
|
rc = OnQueueFileOps(ComponentId, SubcomponentId, (HSPFILEQ)Param2);
|
|
break;
|
|
|
|
case OC_NOTIFICATION_FROM_QUEUE:
|
|
rc = NO_ERROR;
|
|
break;
|
|
|
|
case OC_QUERY_STEP_COUNT:
|
|
rc = 2;
|
|
break;
|
|
|
|
case OC_COMPLETE_INSTALLATION:
|
|
rc = OnCompleteInstallation(ComponentId, SubcomponentId);
|
|
break;
|
|
|
|
case OC_CLEANUP:
|
|
rc = NO_ERROR;
|
|
break;
|
|
|
|
case OC_QUERY_STATE:
|
|
rc = OnQueryState(ComponentId, SubcomponentId, Param1);
|
|
break;
|
|
|
|
case OC_NEED_MEDIA:
|
|
rc = false;
|
|
break;
|
|
|
|
case OC_ABOUT_TO_COMMIT_QUEUE:
|
|
rc = OnAboutToCommitQueue(ComponentId,SubcomponentId);
|
|
break;
|
|
|
|
case OC_QUERY_SKIP_PAGE:
|
|
rc = false;
|
|
break;
|
|
|
|
case OC_WIZARD_CREATED:
|
|
rc = NO_ERROR;
|
|
break;
|
|
|
|
default:
|
|
rc = NO_ERROR;
|
|
break;
|
|
}
|
|
|
|
DebugTrace(1, TEXT("processing completed"));
|
|
logOCNotificationCompletion();
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*-------------------------------------------------------*/
|
|
/*
|
|
* OC Manager message handlers
|
|
*
|
|
*-------------------------------------------------------*/
|
|
|
|
/*
|
|
* OnInitComponent()
|
|
*
|
|
* handler for OC_INIT_COMPONENT
|
|
*/
|
|
|
|
DWORD OnInitComponent(LPCTSTR ComponentId, PSETUP_INIT_COMPONENT psc)
|
|
{
|
|
INFCONTEXT context;
|
|
TCHAR buf[256];
|
|
HINF hinf;
|
|
BOOL rc;
|
|
|
|
memset( &g_Component, 0, sizeof( g_Component ) );
|
|
|
|
if (!VerifyComponent( ComponentId ) )
|
|
return NO_ERROR;
|
|
|
|
DWORD dwResult = InitializeSubcomponentStates();
|
|
if ( ERROR_SUCCESS != dwResult )
|
|
return dwResult;
|
|
|
|
g_IISStopped = FALSE;
|
|
|
|
// store component inf handle
|
|
|
|
g_Component.hinf = (psc->ComponentInfHandle == INVALID_HANDLE_VALUE)
|
|
? NULL
|
|
: psc->ComponentInfHandle;
|
|
|
|
// open the inf
|
|
|
|
if (g_Component.hinf)
|
|
SetupOpenAppendInfFile(NULL, g_Component.hinf,NULL);
|
|
|
|
// copy helper routines and flags
|
|
|
|
g_Component.HelperRoutines = psc->HelperRoutines;
|
|
|
|
g_Component.Flags = psc->SetupData.OperationFlags;
|
|
|
|
g_Component.SourcePath = NULL;
|
|
|
|
// play
|
|
|
|
srand(GetTickCount());
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnExtraRoutines()
|
|
*
|
|
* handler for OC_EXTRA_ROUTINES
|
|
*/
|
|
|
|
DWORD OnExtraRoutines(LPCTSTR ComponentId, PEXTRA_ROUTINES per)
|
|
{
|
|
|
|
if (!VerifyComponent( ComponentId ) )
|
|
return NO_ERROR;
|
|
|
|
memcpy(&g_Component.ExtraRoutines, per, sizeof( g_Component.ExtraRoutines ) );
|
|
g_Component.ExtraRoutines.size = sizeof( g_Component.ExtraRoutines );
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnSetLanguage()
|
|
*
|
|
* handler for OC_SET_LANGUAGE
|
|
*/
|
|
|
|
DWORD_PTR OnQueryImage()
|
|
{
|
|
return (DWORD_PTR)LoadBitmap(NULL,MAKEINTRESOURCE(32754)); // OBM_CLOSE
|
|
}
|
|
|
|
|
|
/*
|
|
* OnQuerySelStateChange()
|
|
*
|
|
* don't let the user deselect the sam component
|
|
*/
|
|
|
|
DWORD OnQuerySelStateChange(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
UINT state,
|
|
UINT flags)
|
|
{
|
|
|
|
DWORD rc = true;
|
|
|
|
if ( !VerifyComponent( ComponentId ) )
|
|
return rc;
|
|
|
|
|
|
if ( !_tcsicmp( SubcomponentId, TEXT( "BITSServerExtensions" ) ) )
|
|
{
|
|
|
|
if ( state )
|
|
{
|
|
|
|
if ( flags & OCQ_DEPENDENT_SELECTION )
|
|
{
|
|
rc = false;
|
|
}
|
|
|
|
}
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* OnCalcDiskSpace()
|
|
*
|
|
* handler for OC_ON_CALC_DISK_SPACE
|
|
*/
|
|
|
|
DWORD OnCalcDiskSpace(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
DWORD addComponent,
|
|
HDSKSPC dspace)
|
|
{
|
|
DWORD rc = NO_ERROR;
|
|
TCHAR section[S_SIZE];
|
|
|
|
//
|
|
// Param1 = 0 if for removing component or non-0 if for adding component
|
|
// Param2 = HDSKSPC to operate on
|
|
//
|
|
// Return value is Win32 error code indicating outcome.
|
|
//
|
|
// In our case the private section for this component/subcomponent pair
|
|
// is a simple standard inf install section, so we can use the high-level
|
|
// disk space list api to do what we want.
|
|
//
|
|
|
|
if (!VerifyComponent( ComponentId ) )
|
|
return NO_ERROR;
|
|
|
|
StringCchCopy(section, S_SIZE, SubcomponentId);
|
|
|
|
if (addComponent)
|
|
{
|
|
rc = SetupAddInstallSectionToDiskSpaceList(dspace,
|
|
g_Component.hinf,
|
|
NULL,
|
|
section,
|
|
0,
|
|
0);
|
|
}
|
|
else
|
|
{
|
|
rc = SetupRemoveInstallSectionFromDiskSpaceList(dspace,
|
|
g_Component.hinf,
|
|
NULL,
|
|
section,
|
|
0,
|
|
0);
|
|
}
|
|
|
|
if (!rc)
|
|
rc = GetLastError();
|
|
else
|
|
rc = NO_ERROR;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* OnQueueFileOps()
|
|
*
|
|
* handler for OC_QUEUE_FILE_OPS
|
|
*/
|
|
|
|
DWORD OnQueueFileOps(LPCTSTR ComponentId, LPCTSTR SubcomponentId, HSPFILEQ queue)
|
|
{
|
|
BOOL state;
|
|
BOOL rc;
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
TCHAR srcpathbuf[256];
|
|
TCHAR *srcpath;
|
|
|
|
if (!VerifyComponent(ComponentId))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
g_Component.queue = queue;
|
|
|
|
if (!StateInfo(SubcomponentId, &state))
|
|
return NO_ERROR;
|
|
|
|
StringCchPrintfW(section, 256, SubcomponentId);
|
|
|
|
rc = TRUE;
|
|
if (!state) {
|
|
// being uninstalled. Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(g_Component.hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
|
|
#if 0
|
|
|
|
// removing this since it is redundant
|
|
|
|
// also, unregister the dlls and kill services before deletion
|
|
|
|
SetupInstallServicesFromInfSection(g_Component.hinf, section, 0);
|
|
SetupInstallFromInfSection(NULL,g_Component.hinf,section,SPINST_UNREGSVR,NULL,NULL,0,NULL,NULL,NULL,NULL);
|
|
#endif
|
|
}
|
|
|
|
if (rc) {
|
|
// if uninstalling, don't use version checks
|
|
rc = SetupInstallFilesFromInfSection(g_Component.hinf,
|
|
NULL,
|
|
queue,
|
|
section,
|
|
g_Component.SourcePath,
|
|
// state ? SP_COPY_NEWER : 0);
|
|
0 );
|
|
}
|
|
|
|
if (!rc)
|
|
return GetLastError();
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
/*
|
|
* OnCompleteInstallation
|
|
*
|
|
* handler for OC_COMPLETE_INSTALLATION
|
|
*/
|
|
|
|
DWORD OnCompleteInstallation(LPCTSTR ComponentId, LPCTSTR SubcomponentId)
|
|
{
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
BOOL state;
|
|
BOOL rc;
|
|
DWORD Error = NO_ERROR;
|
|
|
|
// Do post-installation processing in the cleanup section.
|
|
// This way we know all compoents queued for installation
|
|
// have beein installed before we do our stuff.
|
|
|
|
if (!VerifyComponent(ComponentId))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
// if this is gui mode setup, need to regsvr just in case something
|
|
// changed even if the files are not being replaced.
|
|
|
|
if ( !(g_Component.Flags & SETUPOP_STANDALONE) &&
|
|
( ( _tcsicmp( TEXT("BITSServerExtensionsManager"), SubcomponentId ) == 0 ) ||
|
|
( _tcsicmp( TEXT("BITSServerExtensionsISAPI"), SubcomponentId ) == 0 ) ) )
|
|
{
|
|
|
|
BOOL SettingChanged = StateInfo( SubcomponentId, &state );
|
|
|
|
if ( !SettingChanged && !state )
|
|
return NO_ERROR; // if its not installed, leave it uninstalled.
|
|
|
|
}
|
|
|
|
else if ( !StateInfo( SubcomponentId, &state) )
|
|
return NO_ERROR;
|
|
|
|
StringCchPrintfW(section, 256, SubcomponentId);
|
|
|
|
rc = TRUE;
|
|
if (!state) {
|
|
// being uninstalled. Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(g_Component.hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
}
|
|
|
|
if (state) {
|
|
//
|
|
// installation
|
|
//
|
|
|
|
if (rc) {
|
|
|
|
if ( _tcsicmp( TEXT("BITSServerExtensionsISAPI"), SubcomponentId ) == 0 )
|
|
{
|
|
|
|
//
|
|
// Need to register bitssrv.dll from a separate process since
|
|
// registration uses ADSI and ADSI has a bug where it doesn't
|
|
// load propertly if installed from the same process.
|
|
//
|
|
|
|
// process the inf file
|
|
rc = SetupInstallFromInfSection(NULL, // hwndOwner
|
|
g_Component.hinf, // inf handle
|
|
section, // name of component
|
|
SPINST_ALL & ~SPINST_FILES & ~SPINST_REGSVR,
|
|
NULL, // relative key root
|
|
NULL, // source root path
|
|
0, // copy flags
|
|
NULL, // callback routine
|
|
NULL, // callback routine context
|
|
NULL, // device info set
|
|
NULL); // device info struct
|
|
|
|
|
|
if ( rc )
|
|
rc = RegBITSSrv();
|
|
|
|
if ( rc & g_UpdateNeeded & g_IISStopped )
|
|
{
|
|
rc = RestartIIS();
|
|
g_IISStopped = FALSE;
|
|
}
|
|
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
// process the inf file
|
|
rc = SetupInstallFromInfSection(NULL, // hwndOwner
|
|
g_Component.hinf, // inf handle
|
|
section, // name of component
|
|
SPINST_ALL & ~SPINST_FILES,
|
|
NULL, // relative key root
|
|
NULL, // source root path
|
|
0, // copy flags
|
|
NULL, // callback routine
|
|
NULL, // callback routine context
|
|
NULL, // device info set
|
|
NULL); // device info struct
|
|
|
|
}
|
|
|
|
if (rc) {
|
|
rc = SetupInstallServicesFromInfSection(g_Component.hinf, section, 0);
|
|
Error = GetLastError();
|
|
|
|
if (!rc && Error == ERROR_SECTION_NOT_FOUND) {
|
|
rc = TRUE;
|
|
Error = NO_ERROR;
|
|
}
|
|
|
|
if (rc) {
|
|
if (Error == ERROR_SUCCESS_REBOOT_REQUIRED) {
|
|
g_Component.HelperRoutines.SetReboot(g_Component.HelperRoutines.OcManagerContext,TRUE);
|
|
}
|
|
Error = NO_ERROR;
|
|
rc = RunExternalProgram(&g_Component, section, state);
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// uninstallation
|
|
//
|
|
|
|
if (rc)
|
|
{
|
|
|
|
rc = RunExternalProgram(&g_Component, section, state);
|
|
|
|
}
|
|
if (rc) {
|
|
|
|
rc = CleanupNetShares(&g_Component, section, state);
|
|
|
|
}
|
|
}
|
|
|
|
if (!rc && (Error == NO_ERROR) ) {
|
|
Error = GetLastError( );
|
|
}
|
|
|
|
return Error;
|
|
}
|
|
|
|
|
|
/*
|
|
* OnQueryState()
|
|
*
|
|
* handler for OC_QUERY_STATE
|
|
*/
|
|
|
|
DWORD OnQueryState(LPCTSTR ComponentId,
|
|
LPCTSTR SubcomponentId,
|
|
UINT state)
|
|
{
|
|
if ( !VerifyComponent( ComponentId ) )
|
|
return SubcompUseOcManagerDefault;
|
|
|
|
BITS_SUBCOMPONENT_DATA* SubcomponentData =
|
|
FindSubcomponent( SubcomponentId );
|
|
|
|
if ( !SubcomponentData )
|
|
{
|
|
|
|
if ( !_tcsicmp( TEXT( "BITSServerExtensions" ), SubcomponentId ) )
|
|
{
|
|
|
|
if ( OCSELSTATETYPE_ORIGINAL == state &&
|
|
g_AllSubcomponentsPreinstalled )
|
|
return SubcompOn;
|
|
else
|
|
return SubcompUseOcManagerDefault;
|
|
|
|
|
|
}
|
|
else
|
|
return SubcompUseOcManagerDefault;
|
|
|
|
}
|
|
|
|
if ( OCSELSTATETYPE_ORIGINAL == state )
|
|
{
|
|
|
|
return SubcomponentData->Preinstalled ? SubcompOn : SubcompOff;
|
|
|
|
}
|
|
|
|
return SubcompUseOcManagerDefault;
|
|
}
|
|
|
|
/*
|
|
* OnAboutToCommitQueue()
|
|
*
|
|
* handler for OC_ABOUT_TO_COMMIT_QUEUE
|
|
*/
|
|
|
|
DWORD OnAboutToCommitQueue(LPCTSTR ComponentId, LPCTSTR SubcomponentId)
|
|
{
|
|
BOOL state;
|
|
BOOL rc;
|
|
INFCONTEXT context;
|
|
TCHAR section[256];
|
|
TCHAR srcpathbuf[256];
|
|
TCHAR *srcpath;
|
|
|
|
if (!VerifyComponent( ComponentId ))
|
|
return NO_ERROR;
|
|
|
|
if (!SubcomponentId || !*SubcomponentId)
|
|
return NO_ERROR;
|
|
|
|
if (!StateInfo( SubcomponentId, &state))
|
|
return NO_ERROR;
|
|
|
|
if (state) {
|
|
|
|
if ( g_UpdateNeeded &&
|
|
( _tcsicmp( TEXT("BITSServerExtensionsISAPI"), SubcomponentId ) == 0 ))
|
|
{
|
|
|
|
// determine if IIS needs to be stopped.
|
|
|
|
BOOL ISAPIState;
|
|
StateInfo( _T("BITSServerExtensionsISAPI"), &ISAPIState );
|
|
|
|
if ( ISAPIState &&
|
|
SrvFileIsInUse( ) )
|
|
{
|
|
|
|
if (!StopIIS())
|
|
return GetLastError();
|
|
|
|
g_IISStopped=TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
return NO_ERROR;
|
|
}
|
|
|
|
// Fetch uninstall section name.
|
|
rc = SetupFindFirstLine(
|
|
g_Component.hinf,
|
|
SubcomponentId,
|
|
KEYWORD_UNINSTALL,
|
|
&context);
|
|
|
|
if (rc) {
|
|
rc = SetupGetStringField(
|
|
&context,
|
|
1,
|
|
section,
|
|
sizeof(section) / sizeof(TCHAR),
|
|
NULL);
|
|
}
|
|
|
|
if (rc)
|
|
rc = SetupInstallServicesFromInfSection(g_Component.hinf, section, 0);
|
|
|
|
if ( _tcsicmp( TEXT("BITSServerExtensionsISAPI"), SubcomponentId ) == 0 )
|
|
{
|
|
|
|
//
|
|
// Unregister BITS from a separate process for consistency with
|
|
// register. Also, COM has a problem where bitsmgr.dll isn't
|
|
// always unloaded properly after existing virtual directories
|
|
// are disabled. By running uninstall in a separate process,
|
|
// we forece COM to unload bitsmgr.dll.
|
|
//
|
|
|
|
// process the inf file
|
|
if ( rc )
|
|
rc = SetupInstallFromInfSection(NULL, // hwndOwner
|
|
g_Component.hinf, // inf handle
|
|
section, // name of component
|
|
SPINST_ALL & ~SPINST_FILES & ~SPINST_REGSVR & ~SPINST_UNREGSVR,
|
|
NULL, // relative key root
|
|
NULL, // source root path
|
|
0, // copy flags
|
|
NULL, // callback routine
|
|
NULL, // callback routine context
|
|
NULL, // device info set
|
|
NULL); // device info struct
|
|
|
|
|
|
if ( rc )
|
|
rc = UnregBITSSrv();
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
if (rc) {
|
|
rc = SetupInstallFromInfSection(
|
|
NULL,
|
|
g_Component.hinf,
|
|
section,
|
|
SPINST_ALL & ~SPINST_FILES,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
if (rc) {
|
|
SetLastError(NO_ERROR);
|
|
}
|
|
return GetLastError();
|
|
|
|
}
|
|
|
|
BOOL VerifyComponent( LPCTSTR ComponentId )
|
|
{
|
|
if ( !_tcsicmp( ComponentId, TEXT("BITSServerExtensions") ) )
|
|
return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
// loads current selection state info into "state" and
|
|
// returns whether the selection state was changed
|
|
|
|
BOOL
|
|
StateInfo(
|
|
LPCTSTR SubcomponentId,
|
|
BOOL *state
|
|
)
|
|
{
|
|
BOOL rc = TRUE;
|
|
|
|
assert(state);
|
|
|
|
// otherwise, check for a change in installation state
|
|
|
|
*state = g_Component.HelperRoutines.QuerySelectionState(
|
|
g_Component.HelperRoutines.OcManagerContext,
|
|
SubcomponentId,
|
|
OCSELSTATETYPE_CURRENT);
|
|
|
|
if (*state == g_Component.HelperRoutines.QuerySelectionState(
|
|
g_Component.HelperRoutines.OcManagerContext,
|
|
SubcomponentId,
|
|
OCSELSTATETYPE_ORIGINAL))
|
|
{
|
|
// no change
|
|
rc = FALSE;
|
|
}
|
|
|
|
if ( *state )
|
|
{
|
|
|
|
BITS_SUBCOMPONENT_DATA* SubcomponentData = FindSubcomponent( SubcomponentId );
|
|
|
|
if ( SubcomponentData && g_UpdateNeeded )
|
|
rc = TRUE;
|
|
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/*
|
|
* EnumSections()
|
|
*
|
|
* finds the name of a section for a specified keyword
|
|
*/
|
|
|
|
DWORD
|
|
EnumSections(
|
|
HINF hinf,
|
|
const TCHAR *component,
|
|
const TCHAR *key,
|
|
DWORD index,
|
|
INFCONTEXT *pic,
|
|
TCHAR *name
|
|
)
|
|
{
|
|
TCHAR section[S_SIZE];
|
|
|
|
if (!SetupFindFirstLine(hinf, component, NULL, pic))
|
|
return 0;
|
|
|
|
if (!SetupFindNextMatchLine(pic, key, pic))
|
|
return 0;
|
|
|
|
if (index > SetupGetFieldCount(pic))
|
|
return 0;
|
|
|
|
if (!SetupGetStringField(pic, index, section, S_SIZE, NULL))
|
|
return 0;
|
|
|
|
if (name)
|
|
StringCchCopy(name, S_SIZE, section);
|
|
|
|
return SetupFindFirstLine(hinf, section, NULL, pic);
|
|
}
|
|
|
|
|
|
DWORD
|
|
OcLog(
|
|
LPCTSTR ComponentId,
|
|
UINT level,
|
|
LPCTSTR sz
|
|
)
|
|
{
|
|
TCHAR fmt[5000];
|
|
PPER_COMPONENT_DATA cd;
|
|
|
|
if (!VerifyComponent( ComponentId ) )
|
|
return NO_ERROR;
|
|
|
|
assert(g_Component.ExtraRoutines.LogError);
|
|
assert(level);
|
|
assert(sz);
|
|
|
|
StringCchCopy(fmt, 5000, TEXT("%s: %s"));
|
|
|
|
return g_Component.ExtraRoutines.LogError(
|
|
g_Component.HelperRoutines.OcManagerContext,
|
|
level,
|
|
fmt,
|
|
ComponentId,
|
|
sz);
|
|
}
|
|
|
|
DWORD
|
|
CleanupNetShares(
|
|
PPER_COMPONENT_DATA cd,
|
|
LPCTSTR component,
|
|
DWORD state)
|
|
{
|
|
INFCONTEXT ic;
|
|
TCHAR sname[S_SIZE];
|
|
DWORD section;
|
|
TCHAR *keyword;
|
|
|
|
if (state) {
|
|
return NO_ERROR;
|
|
} else {
|
|
keyword = KEYWORD_DELSHARE;
|
|
}
|
|
|
|
for (section = 1;
|
|
EnumSections(cd->hinf, component, keyword, section, &ic, sname);
|
|
section++)
|
|
{
|
|
INFCONTEXT sic;
|
|
NET_API_STATUS netStat;
|
|
|
|
CHAR Temp[SBUF_SIZE];
|
|
TCHAR ShareName[ SBUF_SIZE ];
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_SHARENAME, &sic))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_SHARENAME );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringField(&sic, 1, ShareName, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_SHARENAME );
|
|
continue;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
netStat = NetShareDel( NULL, ShareName, 0 );
|
|
#else // UNICODE
|
|
WCHAR ShareNameW[ SBUF_SIZE ];
|
|
mbstowcs( ShareNameW, ShareName, lstrlen(ShareName));
|
|
netStat = NetShareDel( NULL, ShareNameW, 0 );
|
|
#endif // UNICODE
|
|
if ( netStat != NERR_Success )
|
|
{
|
|
log( TEXT("OCGEN: Failed to remove %s share. Error 0x%08x\r\n"), ShareName, netStat );
|
|
continue;
|
|
}
|
|
|
|
log( TEXT("OCGEN: %s share removed successfully.\r\n"), ShareName );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
DWORD
|
|
RunExternalProgram(
|
|
PPER_COMPONENT_DATA cd,
|
|
LPCTSTR component,
|
|
DWORD state)
|
|
{
|
|
INFCONTEXT ic;
|
|
TCHAR sname[S_SIZE];
|
|
DWORD section;
|
|
TCHAR *keyword;
|
|
|
|
keyword = KEYWORD_RUN;
|
|
|
|
for (section = 1;
|
|
EnumSections(cd->hinf, component, keyword, section, &ic, sname);
|
|
section++)
|
|
{
|
|
INFCONTEXT sic;
|
|
TCHAR CommandLine[ SBUF_SIZE ];
|
|
CHAR szTickCount[ SBUF_SIZE ];
|
|
ULONG TickCount;
|
|
BOOL b;
|
|
STARTUPINFO startupinfo;
|
|
PROCESS_INFORMATION process_information;
|
|
DWORD dwErr;
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_COMMANDLINE , &sic))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_COMMANDLINE );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringField(&sic, 1, CommandLine, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_COMMANDLINE );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupFindFirstLine(cd->hinf, sname, KEYWORD_TICKCOUNT, &sic))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - unable to find %s\r\n"), keyword, KEYWORD_TICKCOUNT );
|
|
continue;
|
|
}
|
|
|
|
if (!SetupGetStringFieldA(&sic, 1, szTickCount, SBUF_SIZE, NULL))
|
|
{
|
|
log( TEXT("OCGEN: %s INF error - incorrect %s line\r\n"), keyword, KEYWORD_TICKCOUNT );
|
|
continue;
|
|
}
|
|
|
|
TickCount = atoi( szTickCount );
|
|
|
|
ZeroMemory( &startupinfo, sizeof(startupinfo) );
|
|
startupinfo.cb = sizeof(startupinfo);
|
|
startupinfo.dwFlags = STARTF_USESHOWWINDOW;
|
|
startupinfo.wShowWindow = SW_HIDE | SW_SHOWMINNOACTIVE;
|
|
|
|
b = CreateProcess( NULL,
|
|
CommandLine,
|
|
NULL,
|
|
NULL,
|
|
FALSE,
|
|
CREATE_DEFAULT_ERROR_MODE,
|
|
NULL,
|
|
NULL,
|
|
&startupinfo,
|
|
&process_information );
|
|
if ( !b )
|
|
{
|
|
log( TEXT("OCGEN: failed to spawn %s process.\r\n"), CommandLine );
|
|
continue;
|
|
}
|
|
|
|
dwErr = WaitForSingleObject( process_information.hProcess, TickCount * 1000 );
|
|
if ( dwErr != NO_ERROR )
|
|
{
|
|
log( TEXT("OCGEN: WaitForSingleObject() failed. Error 0x%08x\r\n"), dwErr );
|
|
TerminateProcess( process_information.hProcess, -1 );
|
|
CloseHandle( process_information.hProcess );
|
|
CloseHandle( process_information.hThread );
|
|
continue;
|
|
}
|
|
|
|
CloseHandle( process_information.hProcess );
|
|
CloseHandle( process_information.hThread );
|
|
|
|
log( TEXT("OCGEN: %s successfully completed within %u seconds.\r\n"), CommandLine, TickCount );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BITS_SUBCOMPONENT_DATA*
|
|
FindSubcomponent( LPCTSTR SubcomponentId )
|
|
{
|
|
|
|
for( unsigned int i = 0; i < g_NumberSubcomponents; i++ )
|
|
{
|
|
|
|
if ( _tcsicmp( SubcomponentId, g_Subcomponents[i].SubcomponentName ) == 0 )
|
|
return &g_Subcomponents[i];
|
|
|
|
}
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
DWORD
|
|
InitializeSubcomponentStates()
|
|
{
|
|
|
|
// Load this module's version information
|
|
DWORD dwResult;
|
|
ULONG64 ThisModuleVersion;
|
|
BOOL AllSubcomponentsPreinstalled = TRUE;
|
|
BOOL UpdateNeeded = FALSE;
|
|
|
|
dwResult = GetModuleVersion64( ghinst, &ThisModuleVersion );
|
|
if ( ERROR_SUCCESS != dwResult )
|
|
return dwResult;
|
|
|
|
TCHAR SystemDirectory[ MAX_PATH * 2 ];
|
|
GetSystemWindowsDirectory( SystemDirectory, MAX_PATH + 1 );
|
|
StringCchCat( SystemDirectory, MAX_PATH * 2, TEXT("\\System32\\") );
|
|
|
|
for( unsigned int i = 0; i < g_NumberSubcomponents; i++ )
|
|
{
|
|
|
|
TCHAR FileName[ MAX_PATH * 2 ];
|
|
StringCchCopy( FileName, MAX_PATH * 2, SystemDirectory );
|
|
StringCchCatW( FileName, MAX_PATH * 2, g_Subcomponents[ i ].SubcomponentKeyFileName );
|
|
|
|
dwResult = GetFileVersion64( FileName, &g_Subcomponents[ i ].FileVersion );
|
|
|
|
// If the file isn't found, skip it
|
|
if ( ERROR_FILE_NOT_FOUND == dwResult ||
|
|
ERROR_PATH_NOT_FOUND == dwResult )
|
|
{
|
|
AllSubcomponentsPreinstalled = FALSE;
|
|
continue;
|
|
}
|
|
|
|
if ( dwResult != ERROR_SUCCESS )
|
|
return dwResult;
|
|
|
|
g_Subcomponents[ i ].Preinstalled = TRUE;
|
|
g_Subcomponents[ i ].ShouldUpgrade = g_Subcomponents[ i ].FileVersion < ThisModuleVersion;
|
|
|
|
if ( g_Subcomponents[i].ShouldUpgrade )
|
|
UpdateNeeded = TRUE;
|
|
|
|
}
|
|
|
|
g_AllSubcomponentsPreinstalled = AllSubcomponentsPreinstalled;
|
|
g_UpdateNeeded = UpdateNeeded;
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
DWORD
|
|
GetFileVersion64(
|
|
LPCTSTR szFullPath,
|
|
ULONG64 * pVer
|
|
)
|
|
{
|
|
DWORD dwHandle;
|
|
DWORD dwLen;
|
|
|
|
*pVer = 0;
|
|
|
|
//
|
|
// Check to see if the file exists
|
|
//
|
|
|
|
DWORD dwAttributes = GetFileAttributes( szFullPath );
|
|
|
|
if ( INVALID_FILE_ATTRIBUTES == dwAttributes )
|
|
return GetLastError();
|
|
|
|
//
|
|
// Get the file version info size
|
|
//
|
|
|
|
if ((dwLen = GetFileVersionInfoSize( (LPTSTR)szFullPath, &dwHandle)) == 0)
|
|
return GetLastError();
|
|
|
|
//
|
|
// Allocate enough size to hold version info
|
|
//
|
|
char * VersionInfo = new char[ dwLen ];
|
|
|
|
if ( !VersionInfo )
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
//
|
|
// Get the version info
|
|
//
|
|
if (!GetFileVersionInfo( (LPTSTR)szFullPath, dwHandle, dwLen, VersionInfo ))
|
|
{
|
|
DWORD Error = GetLastError();
|
|
delete[] VersionInfo;
|
|
return Error;
|
|
}
|
|
|
|
{
|
|
|
|
VS_FIXEDFILEINFO *pvsfi;
|
|
UINT dwLen2;
|
|
|
|
if ( VerQueryValue(
|
|
VersionInfo,
|
|
TEXT("\\"),
|
|
(LPVOID *)&pvsfi,
|
|
&dwLen2
|
|
) )
|
|
{
|
|
*pVer = ( ULONG64(pvsfi->dwFileVersionMS) << 32) | (pvsfi->dwFileVersionLS);
|
|
}
|
|
|
|
}
|
|
|
|
delete[] VersionInfo;
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
//
|
|
// This ungainly typedef seems to have no global definition. There are several identical
|
|
// definitions in the Windows NT sources, each of which has that bizarre bit-stripping
|
|
// on szKey. I got mine from \nt\base\ntsetup\srvpack\update\splib\common.h.
|
|
//
|
|
typedef struct tagVERHEAD {
|
|
WORD wTotLen;
|
|
WORD wValLen;
|
|
WORD wType; /* always 0 */
|
|
WCHAR szKey[(sizeof("VS_VERSION_INFO")+3)&~03];
|
|
VS_FIXEDFILEINFO vsf;
|
|
} VERHEAD ;
|
|
|
|
DWORD
|
|
GetModuleVersion64(
|
|
HMODULE hDll,
|
|
ULONG64 * pVer
|
|
)
|
|
{
|
|
DWORD* pdwTranslation;
|
|
VS_FIXEDFILEINFO* pFileInfo;
|
|
UINT uiSize;
|
|
|
|
*pVer = 0;
|
|
|
|
HRSRC hrsrcVersion = FindResource(
|
|
hDll,
|
|
MAKEINTRESOURCE(VS_VERSION_INFO),
|
|
RT_VERSION);
|
|
|
|
if (!hrsrcVersion)
|
|
return GetLastError();
|
|
|
|
HGLOBAL hglobalVersion = LoadResource(hDll, hrsrcVersion);
|
|
if (!hglobalVersion)
|
|
return GetLastError();
|
|
|
|
VERHEAD * pVerHead = (VERHEAD *) LockResource(hglobalVersion);
|
|
if (!pVerHead)
|
|
return GetLastError();
|
|
|
|
// I stole this code from \nt\com\complus\src\shared\util\svcerr.cpp,
|
|
// and the comment is theirs:
|
|
//
|
|
// VerQueryValue will write to the memory, for some reason.
|
|
// Therefore we must make a writable copy of the version
|
|
// resource info before calling that API.
|
|
void *pvVersionInfo = new char[ pVerHead->wTotLen + pVerHead->wTotLen/2 ];
|
|
|
|
if ( !pvVersionInfo )
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
memcpy(pvVersionInfo, pVerHead, pVerHead->wTotLen);
|
|
|
|
// Retrieve file version info
|
|
if ( VerQueryValue( pvVersionInfo,
|
|
L"\\",
|
|
(void**)&pFileInfo,
|
|
&uiSize) )
|
|
{
|
|
*pVer = (ULONG64(pFileInfo->dwFileVersionMS) << 32) | (pFileInfo->dwFileVersionLS);
|
|
}
|
|
|
|
delete[] pvVersionInfo;
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
HRESULT
|
|
BITSGetStartupInfo(
|
|
LPSTARTUPINFOA lpStartupInfo )
|
|
{
|
|
|
|
__try
|
|
{
|
|
GetStartupInfoA( lpStartupInfo );
|
|
}
|
|
__except( EXCEPTION_EXECUTE_HANDLER )
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
return S_OK;
|
|
|
|
}
|
|
|
|
BOOL
|
|
RunProcess(
|
|
const CHAR *Exe,
|
|
const CHAR *CmdLine )
|
|
{
|
|
|
|
//
|
|
// Restarts IIS by calling "iisreset /stop" at the commandline.
|
|
//
|
|
|
|
STARTUPINFOA StartupInfo;
|
|
|
|
HRESULT Hr = BITSGetStartupInfo( &StartupInfo );
|
|
|
|
if ( FAILED( Hr ) )
|
|
{
|
|
SetLastError( Hr );
|
|
return FALSE;
|
|
}
|
|
|
|
PROCESS_INFORMATION ProcessInfo;
|
|
CHAR sApplicationPath[MAX_PATH];
|
|
CHAR *pApplicationName = NULL;
|
|
CHAR sCmdLine[MAX_PATH];
|
|
DWORD dwLen = MAX_PATH;
|
|
DWORD dwCount;
|
|
|
|
dwCount = SearchPathA(NULL, // Search Path, NULL is PATH
|
|
Exe, // Application
|
|
NULL, // Extension (already specified)
|
|
dwLen, // Length (char's) of sApplicationPath
|
|
sApplicationPath, // Path + Name for application
|
|
&pApplicationName ); // File part of sApplicationPath
|
|
|
|
if (dwCount == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (dwCount > dwLen)
|
|
{
|
|
SetLastError( ERROR_BUFFER_OVERFLOW );
|
|
return FALSE;
|
|
}
|
|
|
|
StringCbCopyA(sCmdLine, MAX_PATH, CmdLine);
|
|
|
|
BOOL RetVal = CreateProcessA(
|
|
sApplicationPath, // name of executable module
|
|
sCmdLine, // command line string
|
|
NULL, // SD
|
|
NULL, // SD
|
|
FALSE, // handle inheritance option
|
|
CREATE_NO_WINDOW, // creation flags
|
|
NULL, // new environment block
|
|
NULL, // current directory name
|
|
&StartupInfo, // startup information
|
|
&ProcessInfo // process information
|
|
);
|
|
|
|
if ( !RetVal )
|
|
return FALSE;
|
|
|
|
WaitForSingleObject( ProcessInfo.hProcess, INFINITE );
|
|
|
|
DWORD Status;
|
|
GetExitCodeProcess( ProcessInfo.hProcess, &Status );
|
|
|
|
CloseHandle( ProcessInfo.hProcess );
|
|
CloseHandle( ProcessInfo.hThread );
|
|
|
|
if ( ERROR_SUCCESS == Status )
|
|
return TRUE;
|
|
|
|
SetLastError( Status );
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL
|
|
StopIIS()
|
|
{
|
|
|
|
//
|
|
// Restarts IIS by calling "iisreset /stop" at the commandline.
|
|
//
|
|
|
|
return
|
|
RunProcess(
|
|
"iisreset.exe",
|
|
"iisreset /STOP /NOFORCE" );
|
|
|
|
}
|
|
|
|
BOOL
|
|
RestartIIS()
|
|
{
|
|
|
|
//
|
|
// Restarts IIS by calling "iisreset /restart" at the commandline.
|
|
//
|
|
|
|
return
|
|
RunProcess(
|
|
"iisreset.exe",
|
|
"iisreset /RESTART /NOFORCE" );
|
|
}
|
|
|
|
|
|
BOOL
|
|
RegBITSSrv()
|
|
{
|
|
|
|
return
|
|
RunProcess(
|
|
"regsvr32.exe",
|
|
"regsvr32 /s bitssrv.dll" );
|
|
}
|
|
|
|
BOOL
|
|
UnregBITSSrv()
|
|
{
|
|
return
|
|
RunProcess(
|
|
"regsvr32.exe",
|
|
"regsvr32 /u /s bitssrv.dll" );
|
|
}
|
|
|
|
BOOL
|
|
SrvFileIsInUse()
|
|
{
|
|
// returns true if bitssrv.dll is in use
|
|
|
|
TCHAR FileName[ MAX_PATH * 2 ];
|
|
GetSystemWindowsDirectory( FileName, MAX_PATH + 1 );
|
|
StringCchCat( FileName, MAX_PATH * 2, TEXT("\\System32\\bitssrv.dll") );
|
|
|
|
HANDLE hFile =
|
|
CreateFile(
|
|
FileName,
|
|
GENERIC_WRITE,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL );
|
|
|
|
if ( INVALID_HANDLE_VALUE == hFile )
|
|
{
|
|
if ( GetLastError() == ERROR_SHARING_VIOLATION )
|
|
return TRUE;
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
CloseHandle( hFile );
|
|
return FALSE;
|
|
}
|
|
|