2346 lines
75 KiB
C++
2346 lines
75 KiB
C++
#include "stdafx.h"
|
|
#include <winsvc.h>
|
|
#include <winsock2.h>
|
|
#include <nspapi.h>
|
|
#include "w3svc.h"
|
|
#include <inetsvcs.h>
|
|
#include <pwsdata.hxx>
|
|
#include "kill.h"
|
|
#include "svc.h"
|
|
|
|
TCHAR gServicesWhichMustBeRestarted[20][PROCESS_SIZE];
|
|
int gServicesWhichMustBeRestarted_nextuse = 0;
|
|
int gServicesWhichMustBeRestarted_total = 0;
|
|
|
|
extern int g_GlobalDebugLevelFlag;
|
|
|
|
int ServicesRestartList_EntryExists(LPCTSTR szServiceName)
|
|
{
|
|
int iFoundMatch = FALSE;
|
|
|
|
// loop thru the whole list
|
|
for(int i=0; i < gServicesWhichMustBeRestarted_total;i++)
|
|
{
|
|
if (_tcsicmp(gServicesWhichMustBeRestarted[i], szServiceName) == 0)
|
|
{
|
|
iFoundMatch = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return iFoundMatch;
|
|
}
|
|
|
|
|
|
int ServicesRestartList_Add(LPCTSTR szServiceName)
|
|
{
|
|
// check if this value already exists in the globalarary
|
|
if (ServicesRestartList_EntryExists(szServiceName)) {return FALSE;}
|
|
|
|
// move info into global array
|
|
if (gServicesWhichMustBeRestarted_nextuse <= 20)
|
|
{
|
|
_tcscpy(gServicesWhichMustBeRestarted[gServicesWhichMustBeRestarted_nextuse],szServiceName);
|
|
// increment counter to array
|
|
// increment next use space
|
|
++gServicesWhichMustBeRestarted_total;
|
|
++gServicesWhichMustBeRestarted_nextuse;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
int ServicesRestartList_RestartServices(void)
|
|
{
|
|
int iReturn = FALSE;
|
|
INT err = 0;
|
|
|
|
// loop thru the whole list and restart the services in reverse
|
|
// order from how they were entered?
|
|
if (gServicesWhichMustBeRestarted_total >= 1)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("RestartServices()Start.\n")));
|
|
for(int i=0; i < gServicesWhichMustBeRestarted_total;i++)
|
|
{
|
|
if (CheckifServiceExist(gServicesWhichMustBeRestarted[i]) == 0 )
|
|
{
|
|
err = InetStartService(gServicesWhichMustBeRestarted[i]);
|
|
}
|
|
else
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("RestartServices():%s:Not restarting since it no longer exist.\n"),gServicesWhichMustBeRestarted[i]));
|
|
}
|
|
}
|
|
iisDebugOut_End(_T("RestartServices"));
|
|
}
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
DWORD InetStopExtraWait(LPCTSTR lpServiceName)
|
|
{
|
|
DWORD dwSvcMaxSleep = 180000;
|
|
int iFileExist = FALSE;
|
|
|
|
// Wait. How long should we really wait for this service to actually stop?
|
|
// the iisadmin Service can take a long time if the metabase.bin file is huge.
|
|
// So... if it's the iisadmin service we're trying to stop, then
|
|
// check to see how big the metabase.bin file is, then for each 1meg give it 3 minutes (180000)
|
|
if (_tcsicmp(lpServiceName,_T("IISADMIN")) == 0)
|
|
{
|
|
// look for the metabase.bin file
|
|
TCHAR szTempDir[_MAX_PATH];
|
|
_tcscpy(szTempDir, g_pTheApp->m_csPathInetsrv);
|
|
AddPath(szTempDir, _T("Metabase.bin"));
|
|
if (IsFileExist(szTempDir))
|
|
{
|
|
iFileExist = TRUE;
|
|
}
|
|
else
|
|
{
|
|
_tcscpy(szTempDir, g_pTheApp->m_csPathInetsrv);
|
|
AddPath(szTempDir, _T("Metabase.xml"));
|
|
if (IsFileExist(szTempDir))
|
|
{
|
|
iFileExist = TRUE;
|
|
}
|
|
}
|
|
|
|
if (TRUE == iFileExist)
|
|
{
|
|
// Check to see how big it is.
|
|
DWORD dwFileSize = ReturnFileSize(szTempDir);
|
|
if (dwFileSize != 0xFFFFFFFF)
|
|
{
|
|
int iTime = 1;
|
|
// We were able to get the file size.
|
|
// for each meg for size, give it 3 minutes to save.
|
|
if (dwFileSize > 1000000)
|
|
{
|
|
iTime = (dwFileSize/1000000);
|
|
dwSvcMaxSleep = iTime * 180000;
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetStopExtraWait():Metabase.bin is kind of big (>1meg), Lets wait longer for IISADMIN service to stop.maxmilsec=0x%x.\n"),dwSvcMaxSleep));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return dwSvcMaxSleep;
|
|
}
|
|
|
|
// function: IsServiceDisabled
|
|
//
|
|
// Check to see if the service being sent in is disabled
|
|
BOOL
|
|
IsServiceDisabled(LPTSTR szServiceName)
|
|
{
|
|
SC_HANDLE hService;
|
|
SC_HANDLE hSCManager;
|
|
BOOL bRet = FALSE;
|
|
BUFFER buffConfig;
|
|
DWORD dwSizeRequired;
|
|
|
|
hSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT | GENERIC_READ );
|
|
|
|
if ( hSCManager == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
hService = OpenService( hSCManager, szServiceName, SERVICE_QUERY_CONFIG );
|
|
|
|
if ( hService == NULL )
|
|
{
|
|
CloseServiceHandle( hSCManager );
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !QueryServiceConfig( hService, NULL, 0, &dwSizeRequired ) &&
|
|
( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) &&
|
|
buffConfig.Resize( dwSizeRequired ) &&
|
|
QueryServiceConfig( hService, (LPQUERY_SERVICE_CONFIG) buffConfig.QueryPtr(), buffConfig.QuerySize(), &dwSizeRequired )
|
|
)
|
|
{
|
|
// Check the service Startup Type
|
|
bRet = ((LPQUERY_SERVICE_CONFIG) buffConfig.QueryPtr())->dwStartType == SERVICE_DISABLED;
|
|
}
|
|
|
|
CloseServiceHandle( hSCManager );
|
|
CloseServiceHandle( hService );
|
|
|
|
return bRet;
|
|
}
|
|
|
|
// function: SetServiceStart
|
|
//
|
|
// Change the service state
|
|
void
|
|
SetServiceStart(LPTSTR szServiceName, DWORD dwServiceStart)
|
|
{
|
|
SC_HANDLE hService;
|
|
SC_HANDLE hSCManager;
|
|
|
|
hSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT | GENERIC_READ );
|
|
|
|
if ( hSCManager == NULL )
|
|
{
|
|
return;
|
|
}
|
|
|
|
hService = OpenService( hSCManager, szServiceName, SERVICE_CHANGE_CONFIG );
|
|
|
|
if ( hService == NULL )
|
|
{
|
|
CloseServiceHandle( hSCManager );
|
|
return;
|
|
}
|
|
|
|
ChangeServiceConfig( hService,
|
|
SERVICE_NO_CHANGE, // ServiceType
|
|
dwServiceStart, // Startup
|
|
SERVICE_NO_CHANGE, // Error Control
|
|
NULL, // Binary Path
|
|
NULL, // Load order group
|
|
NULL, // TagId
|
|
NULL, // Dependencies
|
|
NULL, // Service Start Name
|
|
NULL, // Password
|
|
NULL ); // StartName
|
|
|
|
CloseServiceHandle( hSCManager );
|
|
CloseServiceHandle( hService );
|
|
}
|
|
|
|
INT InetDisableService( LPCTSTR lpServiceName )
|
|
{
|
|
INT err = 0;
|
|
const DWORD dwSvcSleepInterval = 500 ;
|
|
DWORD dwSvcMaxSleep = 180000 ;
|
|
DWORD dwSleepTotal;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
// Calculcate if this is a "special" service which we
|
|
// need to give more time to in order to stop.
|
|
dwSvcMaxSleep = InetStopExtraWait(lpServiceName);
|
|
|
|
do {
|
|
if ((hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// if the service is running, stop it
|
|
SERVICE_STATUS svcStatus;
|
|
if ( QueryServiceStatus( hService, &svcStatus ))
|
|
{
|
|
if (( svcStatus.dwCurrentState == SERVICE_RUNNING ))
|
|
{
|
|
if ( !ControlService( hService, SERVICE_CONTROL_STOP, &svcStatus ))
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
for ( dwSleepTotal = 0 ;
|
|
dwSleepTotal < dwSvcMaxSleep
|
|
&& (QueryServiceStatus( hService, & svcStatus ))
|
|
&& svcStatus.dwCurrentState == SERVICE_STOP_PENDING ;
|
|
dwSleepTotal += dwSvcSleepInterval )
|
|
{
|
|
::Sleep( dwSvcSleepInterval ) ;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !ChangeServiceConfig( hService,
|
|
SERVICE_NO_CHANGE,
|
|
SERVICE_DISABLED,
|
|
SERVICE_NO_CHANGE,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
NULL ) )
|
|
{
|
|
err = GetLastError();
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetDisableService():ServiceName=%s. Return=0x%x\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetStartService( LPCTSTR lpServiceName )
|
|
{
|
|
iisDebugOut_Start1(_T("InetStartService"),(LPTSTR) lpServiceName);
|
|
|
|
INT err = 0;
|
|
INT err2 = 0;
|
|
const DWORD dwSvcSleepInterval = 500 ;
|
|
DWORD dwSvcMaxSleep = 180000 ;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
// Calculcate if this is a "special" service which we
|
|
// need to give more time to in order to stop.
|
|
dwSvcMaxSleep = InetStopExtraWait(lpServiceName);
|
|
|
|
do
|
|
{
|
|
// set up the service first
|
|
if ((hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
SERVICE_STATUS svcStatus;
|
|
if ( !QueryServiceStatus( hService, &svcStatus ))
|
|
{
|
|
err = ::GetLastError();
|
|
break;
|
|
}
|
|
|
|
if ( svcStatus.dwCurrentState == SERVICE_RUNNING )
|
|
{
|
|
// We will only get this ERROR_SERVICE_MARKED_FOR_DELETE
|
|
// message if the service is already running.
|
|
if ( !::StartService( hService, 0, NULL ))
|
|
{
|
|
err2 = ::GetLastError();
|
|
if (err2 == ERROR_SERVICE_MARKED_FOR_DELETE) {err = err2;}
|
|
}
|
|
break; // service already started and running
|
|
}
|
|
|
|
if ( !::StartService( hService, 0, NULL ))
|
|
{
|
|
err = ::GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Wait for the service to attain "running" status; but
|
|
// wait no more than 3 minute.
|
|
DWORD dwSleepTotal;
|
|
for ( dwSleepTotal = 0 ; dwSleepTotal < dwSvcMaxSleep
|
|
&& (QueryServiceStatus( hService, &svcStatus ))
|
|
&& svcStatus.dwCurrentState == SERVICE_START_PENDING ;
|
|
dwSleepTotal += dwSvcSleepInterval )
|
|
{
|
|
::Sleep( dwSvcSleepInterval ) ;
|
|
}
|
|
|
|
if ( svcStatus.dwCurrentState != SERVICE_RUNNING )
|
|
{
|
|
err = dwSleepTotal > dwSvcMaxSleep ? ERROR_SERVICE_REQUEST_TIMEOUT : svcStatus.dwWin32ExitCode;
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
if (err){iisDebugOut((LOG_TYPE_WARN, _T("InetStartService():ServiceName=%s unable to start WARNING. Err=0x%x.\n"), lpServiceName, err));}
|
|
else{iisDebugOut((LOG_TYPE_TRACE, _T("InetStartService():ServiceName=%s success.\n"), lpServiceName));}
|
|
return(err);
|
|
}
|
|
|
|
DWORD InetQueryServiceStatus( LPCTSTR lpServiceName )
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("InetQueryServiceStatus():ServiceName=%s\n"), (LPTSTR) lpServiceName));
|
|
DWORD dwStatus = 0;
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
SERVICE_STATUS svcStatus;
|
|
|
|
do {
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL ||
|
|
!::QueryServiceStatus( hService, &svcStatus ) )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
dwStatus = svcStatus.dwCurrentState;
|
|
|
|
} while (0);
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("InetQueryServiceStatus():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return( dwStatus );
|
|
}
|
|
|
|
INT InetStopService( LPCTSTR lpServiceName )
|
|
{
|
|
INT err = 0;
|
|
const DWORD dwSvcSleepInterval = 500 ;
|
|
DWORD dwSvcMaxSleep = 180000 ;
|
|
DWORD dwSleepTotal;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
// Calculcate if this is a "special" service which we
|
|
// need to give more time to in order to stop.
|
|
dwSvcMaxSleep = InetStopExtraWait(lpServiceName);
|
|
|
|
do {
|
|
if ((hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
SERVICE_STATUS svcStatus;
|
|
if ( !QueryServiceStatus( hService, &svcStatus ))
|
|
{
|
|
err = ::GetLastError();
|
|
break;
|
|
}
|
|
|
|
if ( svcStatus.dwCurrentState == SERVICE_STOPPED )
|
|
break; // service already stopped
|
|
|
|
if (( svcStatus.dwCurrentState == SERVICE_RUNNING ))
|
|
{
|
|
if ( !ControlService( hService, SERVICE_CONTROL_STOP, &svcStatus ))
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
for ( dwSleepTotal = 0 ;
|
|
dwSleepTotal < dwSvcMaxSleep
|
|
&& (QueryServiceStatus( hService, & svcStatus ))
|
|
&& svcStatus.dwCurrentState == SERVICE_STOP_PENDING ;
|
|
dwSleepTotal += dwSvcSleepInterval )
|
|
{
|
|
::Sleep( dwSvcSleepInterval ) ;
|
|
}
|
|
}
|
|
|
|
if ( svcStatus.dwCurrentState != SERVICE_STOPPED )
|
|
{
|
|
err = dwSleepTotal > dwSvcMaxSleep ?
|
|
ERROR_SERVICE_REQUEST_TIMEOUT :
|
|
svcStatus.dwWin32ExitCode;
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetStopService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetDeleteService( LPCTSTR lpServiceName )
|
|
{
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
/*
|
|
The DeleteService function marks a service for deletion from the service control manager database.
|
|
The database entry is not removed until all open handles to the service have been closed by calls
|
|
to the CloseServiceHandle function, and the service is not running. A running service is stopped
|
|
by a call to the ControlService function with the SERVICE_CONTROL_STOP control code.
|
|
If the service cannot be stopped, the database entry is removed when the system is restarted.
|
|
The service control manager deletes the service by deleting the service key and its subkeys from
|
|
the registry.
|
|
*/
|
|
// To delete service immediately, we need to stop service first
|
|
StopServiceAndDependencies(lpServiceName, FALSE);
|
|
|
|
do {
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL ||
|
|
!::DeleteService( hService ) )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
} while (0);
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetDeleteService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetCreateDriver(LPCTSTR lpServiceName, LPCTSTR lpDisplayName, LPCTSTR lpBinaryPathName, DWORD dwStartType)
|
|
{
|
|
iisDebugOut_Start1(_T("InetCreateDriver"),(LPTSTR) lpServiceName);
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
do {
|
|
if ( (hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
//
|
|
// if Driver already exits then just change the parameters
|
|
//
|
|
if ( CheckifServiceExist( lpServiceName ) == 0 ) {
|
|
|
|
hService = OpenService( hScManager, lpServiceName, GENERIC_ALL );
|
|
|
|
if ( hService ) {
|
|
if ( ChangeServiceConfig(
|
|
hService, // handle to service
|
|
SERVICE_KERNEL_DRIVER, // type of service
|
|
dwStartType, // when to start service
|
|
SERVICE_ERROR_NORMAL, // severity if service fails to start
|
|
lpBinaryPathName, // pointer to service binary file name
|
|
NULL, // pointer to load ordering group name
|
|
NULL, // pointer to variable to get tag identifier
|
|
NULL, // pointer to array of dependency names
|
|
NULL, // pointer to account name of service
|
|
NULL, // pointer to password for service account
|
|
lpDisplayName // pointer to display name
|
|
) ){
|
|
break;
|
|
}
|
|
}
|
|
|
|
} else {
|
|
|
|
hService = ::CreateService( hScManager, lpServiceName, lpDisplayName,
|
|
GENERIC_ALL, SERVICE_KERNEL_DRIVER, dwStartType,
|
|
SERVICE_ERROR_NORMAL, lpBinaryPathName, NULL, NULL,
|
|
NULL, NULL, NULL );
|
|
|
|
if ( hService ) {
|
|
break;
|
|
}
|
|
}
|
|
err = GetLastError();
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetCreateDriver():Name=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetCreateService( LPCTSTR lpServiceName, LPCTSTR lpDisplayName, LPCTSTR lpBinaryPathName, DWORD dwStartType, LPCTSTR lpDependencies)
|
|
{
|
|
iisDebugOut_Start1(_T("InetCreateService"),(LPTSTR) lpServiceName);
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
do {
|
|
if ( (hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
hService = ::CreateService( hScManager, lpServiceName, lpDisplayName,
|
|
GENERIC_ALL, SERVICE_WIN32_SHARE_PROCESS, dwStartType,
|
|
SERVICE_ERROR_NORMAL, lpBinaryPathName, NULL, NULL,
|
|
lpDependencies, _T("LocalSystem"), NULL );
|
|
if ( !hService )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService){CloseServiceHandle(hService);}
|
|
if (hScManager){CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetCreateService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetConfigService( LPCTSTR lpServiceName, LPCTSTR lpDisplayName, LPCTSTR lpBinaryPathName, LPCTSTR lpDependencies)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("InetConfigService():ServiceName=%s\n"), (LPTSTR) lpServiceName));
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
do {
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigService():OpenSCManager or OpenService: Service=%s BinPathName=%s Dependencies=%s Err=0x%x FAILED\n"), lpServiceName, lpBinaryPathName, lpDependencies, err));
|
|
break;
|
|
}
|
|
|
|
if ( !::ChangeServiceConfig(hService, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, lpBinaryPathName, NULL, NULL, lpDependencies, _T("LocalSystem"), NULL, lpDisplayName) )
|
|
{
|
|
err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigService():ChangeServiceConfig: Service=%s BinPathName=%s Dependencies=%s Err=0x%x FAILED\n"), lpServiceName, lpBinaryPathName, lpDependencies, err));
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetConfigService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
INT InetConfigService2( LPCTSTR lpServiceName, LPCTSTR lpDescription)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("InetConfigService2():ServiceName=%s\n"), (LPTSTR) lpServiceName));
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
SERVICE_DESCRIPTION ServiceDescription;
|
|
|
|
do {
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigService2():OpenSCManager or OpenService: Service=%s Err=0x%x FAILED\n"), lpServiceName, err));
|
|
break;
|
|
}
|
|
|
|
if (lpDescription)
|
|
{
|
|
if (_tcscmp(lpDescription, _T("")) != 0)
|
|
{
|
|
ServiceDescription.lpDescription = (LPTSTR) lpDescription;
|
|
if (!ChangeServiceConfig2(hService, SERVICE_CONFIG_DESCRIPTION, (LPVOID)&ServiceDescription))
|
|
{
|
|
err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigService2():ChangeServiceConfig2: Service=%s Err=0x%x FAILED\n"), lpServiceName, err));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetConfigService2():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
|
|
# define SetServiceTypeValues( pSvcTypeValue, dwNS, dwType, dwSize, lpValName, lpVal) \
|
|
( pSvcTypeValue)->dwNameSpace = ( dwNS); \
|
|
( pSvcTypeValue)->dwValueType = ( dwType); \
|
|
( pSvcTypeValue)->dwValueSize = ( dwSize); \
|
|
( pSvcTypeValue)->lpValueName = ( lpValName); \
|
|
( pSvcTypeValue)->lpValue = (PVOID ) ( lpVal); \
|
|
|
|
# define SetServiceTypeValuesDword( pSvcTypeValue, dwNS, lpValName, lpVal) \
|
|
SetServiceTypeValues( (pSvcTypeValue), (dwNS), REG_DWORD, sizeof( DWORD), \
|
|
( lpValName), ( lpVal))
|
|
|
|
BOOL InetRegisterService( LPCTSTR pszMachine, LPCTSTR pszServiceName, GUID *pGuid, DWORD SapId, DWORD TcpPort, BOOL fAdd )
|
|
{
|
|
iisDebugOut_Start1(_T("InetRegisterService"),(LPTSTR) pszServiceName);
|
|
int err;
|
|
|
|
WSADATA WsaData;
|
|
|
|
SERVICE_INFO serviceInfo;
|
|
LPSERVICE_TYPE_INFO_ABS lpServiceTypeInfo ;
|
|
LPSERVICE_TYPE_VALUE_ABS lpServiceTypeValues ;
|
|
BYTE serviceTypeInfoBuffer[sizeof(SERVICE_TYPE_INFO) + 1024];
|
|
// Buffer large enough for 3 values ( SERVICE_TYPE_VALUE_ABS)
|
|
|
|
DWORD Value1 = 1 ;
|
|
DWORD SapValue = SapId;
|
|
DWORD TcpPortValue = TcpPort;
|
|
DWORD statusFlags;
|
|
|
|
//
|
|
// Initialize Windows Sockets DLL
|
|
//
|
|
|
|
err = WSAStartup( 0x0101, & WsaData);
|
|
if ( err == SOCKET_ERROR)
|
|
{
|
|
return ( FALSE);
|
|
}
|
|
|
|
|
|
//
|
|
// Setup the service information to be passed to SetService() for adding
|
|
// or deleting this service. Most of the SERVICE_INFO fields are not
|
|
// required for add or delete operation. The main things of interests are
|
|
// GUIDs and ServiceSpecificInfo structure.
|
|
//
|
|
|
|
memset( (PVOID ) & serviceInfo, 0, sizeof( serviceInfo)); //null all fields
|
|
|
|
serviceInfo.lpServiceType = pGuid;
|
|
serviceInfo.lpMachineName = (LPTSTR)pszMachine;
|
|
|
|
//
|
|
// The "Blob" will contain the service specific information.
|
|
// In this case, fill it with a SERVICE_TYPE_INFO_ABS structure
|
|
// and associated information.
|
|
//
|
|
serviceInfo.ServiceSpecificInfo.pBlobData = serviceTypeInfoBuffer;
|
|
serviceInfo.ServiceSpecificInfo.cbSize = sizeof( serviceTypeInfoBuffer);
|
|
|
|
lpServiceTypeInfo = (LPSERVICE_TYPE_INFO_ABS ) serviceTypeInfoBuffer;
|
|
|
|
//
|
|
// There are totally 3 values associated with this service if we're doing
|
|
// both SPX and TCP, there's only one value if TCP.
|
|
//
|
|
|
|
if ( SapId )
|
|
{
|
|
lpServiceTypeInfo->dwValueCount = 3;
|
|
}
|
|
else
|
|
{
|
|
lpServiceTypeInfo->dwValueCount = 1;
|
|
}
|
|
lpServiceTypeInfo->lpTypeName = (LPTSTR)pszServiceName;
|
|
|
|
lpServiceTypeValues = lpServiceTypeInfo->Values;
|
|
|
|
if ( SapId )
|
|
{
|
|
//
|
|
// 1st value: tells the SAP that this is a connection oriented service.
|
|
//
|
|
SetServiceTypeValuesDword( ( lpServiceTypeValues + 0),
|
|
NS_SAP, // Name Space
|
|
SERVICE_TYPE_VALUE_CONN, // ValueName
|
|
&Value1 // actual value
|
|
);
|
|
|
|
//
|
|
// 2nd Value: tells SAP about object type to be used for broadcasting
|
|
// the service name.
|
|
//
|
|
SetServiceTypeValuesDword( ( lpServiceTypeValues + 1),
|
|
NS_SAP,
|
|
SERVICE_TYPE_VALUE_SAPID,
|
|
&SapValue);
|
|
|
|
//
|
|
// 3rd value: tells TCPIP name-space provider about TCP/IP port to be used.
|
|
//
|
|
SetServiceTypeValuesDword( ( lpServiceTypeValues + 2),
|
|
NS_DNS,
|
|
SERVICE_TYPE_VALUE_TCPPORT,
|
|
&TcpPortValue);
|
|
|
|
}
|
|
else
|
|
{
|
|
SetServiceTypeValuesDword( ( lpServiceTypeValues + 0),
|
|
NS_DNS,
|
|
SERVICE_TYPE_VALUE_TCPPORT,
|
|
&TcpPortValue);
|
|
}
|
|
//
|
|
// Finally, call SetService to actually perform the operation.
|
|
//
|
|
err = SetService(
|
|
NS_DEFAULT, // all default name spaces
|
|
( fAdd ) ? SERVICE_ADD_TYPE : SERVICE_DELETE_TYPE, // either ADD or DELETE
|
|
0, // dwFlags not used
|
|
&serviceInfo, // the service info structure
|
|
NULL, // lpServiceAsyncInfo
|
|
&statusFlags // additional status information
|
|
);
|
|
|
|
// for some unknown reason, the SERVICE_DELETE_TYPE never remove the related registry
|
|
// I have to manually clean it here.
|
|
if (!fAdd)
|
|
{
|
|
CRegKey regSvcTypes(HKEY_LOCAL_MACHINE, _T("System\\CurrentControlSet\\Control\\ServiceProvider\\ServiceTypes"));
|
|
if ((HKEY)regSvcTypes) {regSvcTypes.DeleteTree(pszServiceName);}
|
|
}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetRegisterService():ServiceName=%s.End.Return=%d.\n"), pszServiceName, err));
|
|
return ( err != NO_ERROR);
|
|
} // InetRegisterService()
|
|
|
|
INT CheckifServiceExistAndDependencies( LPCTSTR lpServiceName )
|
|
{
|
|
INT err = 0;
|
|
INT iReturn = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
|
|
BYTE ConfigBuffer[4096];
|
|
LPENUM_SERVICE_STATUS ServiceConfigEnum = (LPENUM_SERVICE_STATUS) &ConfigBuffer;
|
|
|
|
if (( hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
// Failed, or more likely the service doesn't exist
|
|
iReturn = GetLastError();
|
|
goto CheckifServiceExistAndDependencies_Exit;
|
|
}
|
|
|
|
// There was no error and the service exists.
|
|
// Then let's make sure the actual file exists!!!
|
|
// The above calls will only return true if the service has been registered, but
|
|
// the call doesn't actually check if the file exists!
|
|
|
|
// Retrieve the service's config for the BinaryPathName
|
|
// if it fails then hey, we don't have a correctly installed service
|
|
// so return error!
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
iReturn = GetLastError();
|
|
goto CheckifServiceExistAndDependencies_Exit;
|
|
}
|
|
if (!ServiceConfig)
|
|
{
|
|
iReturn = GetLastError();
|
|
goto CheckifServiceExistAndDependencies_Exit;
|
|
}
|
|
|
|
if ( (ServiceConfig->dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (ServiceConfig->dwServiceType & SERVICE_WIN32_SHARE_PROCESS))
|
|
{
|
|
if (ServiceConfig->lpBinaryPathName)
|
|
{
|
|
if (IsFileExist(ServiceConfig->lpBinaryPathName))
|
|
{
|
|
// the service exists and the file exists too!
|
|
iReturn = 0;
|
|
}
|
|
else
|
|
{
|
|
iReturn = ERROR_FILE_NOT_FOUND;
|
|
goto CheckifServiceExistAndDependencies_Exit;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iReturn = 0;
|
|
}
|
|
|
|
|
|
// Get our list of services which we depend upon.
|
|
// let's make sure they are registered and exist.
|
|
|
|
// ServiceConfig->lpDependencies should look something like this
|
|
// service\0service\0\0 double null terminated
|
|
{
|
|
TCHAR * pdest = NULL;
|
|
long RightMostNull = 0;
|
|
|
|
pdest = ServiceConfig->lpDependencies;
|
|
do
|
|
{
|
|
if (*pdest != _T('\0'))
|
|
{
|
|
RightMostNull = RightMostNull + _tcslen(pdest) + 1;
|
|
|
|
// Check if the service exists
|
|
if (0 != CheckifServiceExistAndDependencies(pdest)){iReturn = err;}
|
|
|
|
pdest = _tcschr(pdest, _T('\0'));
|
|
pdest++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
}
|
|
|
|
CheckifServiceExistAndDependencies_Exit:
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
return (iReturn);
|
|
}
|
|
|
|
|
|
|
|
INT CheckifServiceExist( LPCTSTR lpServiceName )
|
|
{
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
if (( hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL
|
|
|| (hService = OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{err = GetLastError();}
|
|
|
|
if (hService) CloseServiceHandle(hService);
|
|
if (hScManager) CloseServiceHandle(hScManager);
|
|
return (err);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------------------------
|
|
Routine Description:
|
|
This routine allocates a buffer for the specified service's configuration parameters,
|
|
and retrieves those parameters into the buffer. The caller is responsible for freeing
|
|
the buffer.
|
|
Remarks:
|
|
The pointer whose address is contained in ServiceConfig is guaranteed to be NULL upon
|
|
return if any error occurred.
|
|
-----------------------------------------------------------------------------------------*/
|
|
DWORD RetrieveServiceConfig(IN SC_HANDLE ServiceHandle,OUT LPQUERY_SERVICE_CONFIG *ServiceConfig)
|
|
{
|
|
DWORD ServiceConfigSize = 0, Err;
|
|
if (NULL == ServiceConfig)
|
|
{
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
*ServiceConfig = NULL;
|
|
while(TRUE)
|
|
{
|
|
if(QueryServiceConfig(ServiceHandle, *ServiceConfig, ServiceConfigSize, &ServiceConfigSize))
|
|
{
|
|
//assert(*ServiceConfig);
|
|
return NO_ERROR;
|
|
}
|
|
else
|
|
{
|
|
Err = GetLastError();
|
|
if(*ServiceConfig)
|
|
{
|
|
free(*ServiceConfig);
|
|
*ServiceConfig=NULL;
|
|
}
|
|
|
|
if(Err == ERROR_INSUFFICIENT_BUFFER)
|
|
{
|
|
// Allocate a larger buffer, and try again.
|
|
*ServiceConfig = (LPQUERY_SERVICE_CONFIG) malloc(ServiceConfigSize);
|
|
|
|
if( !( *ServiceConfig ) )
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
*ServiceConfig = NULL;
|
|
return Err;
|
|
}
|
|
}
|
|
} // while (TRUE)
|
|
}
|
|
|
|
|
|
INT CreateDependencyForService( LPCTSTR lpServiceName, LPCTSTR lpDependency )
|
|
{
|
|
iisDebugOut_Start1(_T("CreateDependencyForService"),(LPTSTR) lpServiceName);
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
TCHAR szTempDependencies[1024];
|
|
TCHAR * pszTempDependencies = NULL;
|
|
pszTempDependencies = szTempDependencies;
|
|
|
|
do {
|
|
// set up the service first
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Get the existing Service information
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
if(!ServiceConfig)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
// Check if our service is already in there.
|
|
// ServiceConfig->lpDependencies should look something like this
|
|
// service\0service\0\0 double null terminated
|
|
TCHAR * pdest = NULL;
|
|
int bFoundFlag = FALSE;
|
|
long RightMostNull = 0;
|
|
|
|
pdest = ServiceConfig->lpDependencies;
|
|
do
|
|
{
|
|
if (*pdest != _T('\0'))
|
|
{
|
|
RightMostNull = RightMostNull + _tcslen(pdest) + 1;
|
|
if (_tcsicmp(pdest, lpDependency) == 0)
|
|
{
|
|
bFoundFlag = TRUE;
|
|
break;
|
|
}
|
|
|
|
// copy the entry onto our string which we'll use later.
|
|
_tcscpy(pszTempDependencies,pdest);
|
|
// position pointer to the end
|
|
pszTempDependencies=pszTempDependencies + RightMostNull;
|
|
|
|
pdest = _tcschr(pdest, _T('\0'));
|
|
pdest++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
|
|
// if the service is already on the dependency list then exit
|
|
if (bFoundFlag == TRUE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
// The Service is not there So Let's add it to the end of the list then change the data
|
|
// The pointer should be at the beginning or at the next entry point
|
|
_tcscpy(pszTempDependencies, lpDependency);
|
|
// position pointer to the end
|
|
pszTempDependencies=pszTempDependencies + (_tcslen(pszTempDependencies) + 1);
|
|
// add another null to the end
|
|
*pszTempDependencies = _T('\0');
|
|
|
|
|
|
if(!::ChangeServiceConfig(hService,SERVICE_NO_CHANGE,SERVICE_NO_CHANGE,SERVICE_NO_CHANGE,NULL,NULL,NULL,szTempDependencies,NULL,NULL,NULL))
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("CreateDependencyForService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return err;
|
|
}
|
|
|
|
|
|
INT RemoveDependencyForService( LPCTSTR lpServiceName, LPCTSTR lpDependency )
|
|
{
|
|
iisDebugOut_Start1(_T("RemoveDependencyForService"),(LPTSTR) lpServiceName);
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
TCHAR szTempDependencies[1024];
|
|
TCHAR * pszTempDependencies = NULL;
|
|
pszTempDependencies = szTempDependencies;
|
|
|
|
do {
|
|
// set up the service first
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Get the existing Service information
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
if(!ServiceConfig)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Check if our service is already in there.
|
|
// ServiceConfig->lpDependencies should look something like this
|
|
// service\0service\0\0 double null terminated
|
|
|
|
TCHAR * pdest = NULL;
|
|
int bFoundFlag = FALSE;
|
|
long RightMostNull = 0;
|
|
_tcsset(szTempDependencies, _T('\0'));
|
|
pdest = ServiceConfig->lpDependencies;
|
|
do
|
|
{
|
|
if (*pdest != _T('\0'))
|
|
{
|
|
RightMostNull = RightMostNull + _tcslen(pdest) + 1;
|
|
if (_tcsicmp(pdest, lpDependency) == 0)
|
|
{
|
|
bFoundFlag = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// copy the entry onto our string which we'll use later.
|
|
_tcscpy(pszTempDependencies,pdest);
|
|
// position pointer to the end
|
|
pszTempDependencies=pszTempDependencies + RightMostNull;
|
|
*pszTempDependencies = _T('\0');
|
|
|
|
/*
|
|
if (_tcslen(szTempDependencies) == 0)
|
|
memcpy(szTempDependencies, pdest, _tcslen(pdest) + 1);
|
|
else
|
|
memcpy(szTempDependencies + _tcslen(szTempDependencies) + 1, pdest, _tcslen(pdest) + 1);
|
|
*/
|
|
}
|
|
pdest = _tcschr(pdest, _T('\0'));
|
|
pdest++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
// if the service was in the list.
|
|
// Then let's remove it.
|
|
if (bFoundFlag == FALSE)
|
|
{
|
|
break;
|
|
}
|
|
|
|
if(!::ChangeServiceConfig(hService,SERVICE_NO_CHANGE,SERVICE_NO_CHANGE,SERVICE_NO_CHANGE,NULL,NULL,NULL,szTempDependencies,NULL,NULL,NULL))
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("RemoveDependencyForService():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return err;
|
|
}
|
|
|
|
INT DisplayDependencyForService( LPCTSTR lpServiceName)
|
|
{
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
|
|
do {
|
|
// set up the service first
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Get the existing Service information
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
if(!ServiceConfig)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
// Check if our service is already in there.
|
|
// ServiceConfig->lpDependencies should look something like this
|
|
// service\0service\0\0 double null terminated
|
|
TCHAR * pdest = NULL;
|
|
int bFoundFlag = FALSE;
|
|
long RightMostNull = 0;
|
|
pdest = ServiceConfig->lpDependencies;
|
|
do
|
|
{
|
|
if (*pdest != _T('\0'))
|
|
{
|
|
pdest = _tcschr(pdest, _T('\0'));
|
|
pdest++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
|
|
|
|
} while ( FALSE );
|
|
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
return err;
|
|
}
|
|
|
|
|
|
//
|
|
//Routine Description:
|
|
// Stop the named service and all those services which depend upon it.
|
|
// And if the service is hung and can't be stopped, then kill the darn thing.
|
|
//
|
|
//Arguments:
|
|
// ServiceName (Name of service to stop)
|
|
//
|
|
//Return Status:
|
|
// TRUE - Indicates service successfully stopped
|
|
// FALSE - Timeout occurred.
|
|
//
|
|
int StopServiceAndDependencies(LPCTSTR ServiceName, int AddToRestartList)
|
|
{
|
|
iisDebugOut_Start1(_T("StopServiceAndDependencies"),(LPTSTR) ServiceName);
|
|
|
|
int Err = 0;
|
|
int iBeforeServiceStatus = 0;
|
|
SC_HANDLE ScManagerHandle = NULL;
|
|
SC_HANDLE ServiceHandle = NULL;
|
|
SERVICE_STATUS ServiceStatus;
|
|
DWORD Timeout;
|
|
int iReturn = FALSE;
|
|
DWORD TimeoutMaxSecs = 60;
|
|
DWORD dwSvcMaxSleep = 0;
|
|
|
|
//
|
|
// Open a handle to the Service.
|
|
//
|
|
ScManagerHandle = OpenSCManager(NULL,NULL,SC_MANAGER_CONNECT );
|
|
if (ScManagerHandle == NULL)
|
|
{
|
|
Err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("StopServiceAndDependencies():OpenSCManager: Err on Service %s Err=0x%x FAILED\n"), ServiceName, Err));
|
|
goto Cleanup;
|
|
}
|
|
|
|
ServiceHandle = OpenService(ScManagerHandle,ServiceName,SERVICE_QUERY_STATUS | SERVICE_INTERROGATE | SERVICE_ENUMERATE_DEPENDENTS | SERVICE_STOP | SERVICE_QUERY_CONFIG );
|
|
if ( ServiceHandle == NULL )
|
|
{
|
|
Err = GetLastError();
|
|
if (Err == ERROR_SERVICE_DOES_NOT_EXIST)
|
|
{
|
|
iReturn = TRUE;
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("StopServiceAndDependencies():%s Service does not exist.\n"), ServiceName));
|
|
}
|
|
else
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("StopServiceAndDependencies():OpenService: Err on Service %s Err=0x%x FAILED\n"), ServiceName, Err));
|
|
}
|
|
goto Cleanup;
|
|
}
|
|
|
|
// Get the before service status.
|
|
if (QueryServiceStatus(ServiceHandle, &ServiceStatus))
|
|
{
|
|
iBeforeServiceStatus = ServiceStatus.dwCurrentState;
|
|
}
|
|
|
|
//
|
|
// Ask the service to stop.
|
|
//
|
|
if ( !ControlService( ServiceHandle, SERVICE_CONTROL_STOP, &ServiceStatus) )
|
|
{
|
|
Err = GetLastError();
|
|
// If there are dependent services running,
|
|
// determine their names and stop them.
|
|
if ( Err == ERROR_DEPENDENT_SERVICES_RUNNING )
|
|
{
|
|
BYTE ConfigBuffer[4096];
|
|
LPENUM_SERVICE_STATUS ServiceConfig = (LPENUM_SERVICE_STATUS) &ConfigBuffer;
|
|
DWORD BytesNeeded;
|
|
DWORD ServiceCount;
|
|
DWORD ServiceIndex;
|
|
|
|
//
|
|
// Get the names of the dependent services.
|
|
//
|
|
if ( !EnumDependentServices( ServiceHandle,SERVICE_ACTIVE,ServiceConfig,sizeof(ConfigBuffer),&BytesNeeded,&ServiceCount ) )
|
|
{
|
|
Err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("StopServiceAndDependencies():EnumDependentServices: Err on Service %s Err=0x%x FAILED\n"), ServiceName, Err));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Stop those services.
|
|
//
|
|
for ( ServiceIndex=0; ServiceIndex<ServiceCount; ServiceIndex++ )
|
|
{
|
|
StopServiceAndDependencies( ServiceConfig[ServiceIndex].lpServiceName, AddToRestartList);
|
|
}
|
|
|
|
//
|
|
// Ask the original service to stop.
|
|
//
|
|
if ( !ControlService( ServiceHandle, SERVICE_CONTROL_STOP, &ServiceStatus) )
|
|
{
|
|
Err = GetLastError();
|
|
|
|
// check if the service is already stopped..
|
|
if ( Err == ERROR_SERVICE_CANNOT_ACCEPT_CTRL || Err == ERROR_SERVICE_NOT_ACTIVE)
|
|
{
|
|
// check if the service is alread stopped.
|
|
if (QueryServiceStatus( ServiceHandle, &ServiceStatus ))
|
|
{
|
|
if ( ServiceStatus.dwCurrentState == SERVICE_STOPPED || ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
|
|
{
|
|
iReturn = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The service must be in a hung mode. Let's kill it.
|
|
iisDebugOut((LOG_TYPE_WARN, _T("StopServiceAndDependencies():'%s' Service must be in a hung mode. Let's kill it.\n"), ServiceName));
|
|
KillService(ServiceHandle);
|
|
goto WaitLoop;
|
|
}
|
|
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// check if the service is already stopped..
|
|
if ( Err == ERROR_SERVICE_CANNOT_ACCEPT_CTRL || Err == ERROR_SERVICE_NOT_ACTIVE)
|
|
{
|
|
// check if the service is alread stopped.
|
|
if (QueryServiceStatus( ServiceHandle, &ServiceStatus ))
|
|
{
|
|
if ( ServiceStatus.dwCurrentState == SERVICE_STOPPED || ServiceStatus.dwCurrentState == SERVICE_STOP_PENDING)
|
|
{
|
|
Err = ServiceStatus.dwCurrentState;
|
|
iReturn = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// The service must be in a hung mode. Let's kill it.
|
|
iisDebugOut((LOG_TYPE_WARN, _T("StopServiceAndDependencies():'%s' Service must be in a hung mode. Let's kill it.\n"), ServiceName));
|
|
KillService(ServiceHandle);
|
|
goto WaitLoop;
|
|
}
|
|
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// We successfully asked the service to stop...
|
|
}
|
|
|
|
|
|
WaitLoop:
|
|
// Calculcate if this is a "special" service which we
|
|
// need to give more time to in order to stop.
|
|
dwSvcMaxSleep = InetStopExtraWait(ServiceName);
|
|
// dwSvcMaxSleep returns 3 minute intervals. so default dwSvcMaxSleep will be 180000 (3 minutes)
|
|
// we need to convert this into how many seconds
|
|
TimeoutMaxSecs = (dwSvcMaxSleep/1000);
|
|
|
|
// Loop waiting for the service to stop.
|
|
for ( Timeout=0; Timeout < TimeoutMaxSecs; Timeout++ )
|
|
{
|
|
// Return or continue waiting depending on the state of the service.
|
|
if ( ServiceStatus.dwCurrentState == SERVICE_STOPPED )
|
|
{
|
|
// The service successfully stopped.
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("StopServiceAndDependencies(): %s Service stopped.\n"), ServiceName));
|
|
iReturn = TRUE;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// Wait a second for the service to finish stopping.
|
|
Sleep( 1000 );
|
|
|
|
// Query the status of the service again.
|
|
if (! QueryServiceStatus( ServiceHandle, &ServiceStatus ))
|
|
{
|
|
Err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("StopServiceAndDependencies():QueryServiceStatus: Err on Service %s Err=0x%x FAILED\n"), ServiceName, Err));
|
|
goto Cleanup;
|
|
}
|
|
|
|
// if the service we are trying to stop is a driver,
|
|
// then heck we should just get out of here..
|
|
if (TRUE == IsThisServiceADriver(ServiceName))
|
|
{
|
|
iisDebugOut((LOG_TYPE_WARN, _T("StopServiceAndDependencies(): %s service is a driver, and can only be removed upon reboot.\n"), ServiceName));
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
|
|
// if we get here then the service failed to stop.
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("StopServiceAndDependencies(): failed to stop %s service.\n"), ServiceName));
|
|
|
|
Cleanup:
|
|
if ( ScManagerHandle != NULL ) {(VOID) CloseServiceHandle(ScManagerHandle);}
|
|
if ( ServiceHandle != NULL ) {(VOID) CloseServiceHandle(ServiceHandle);}
|
|
|
|
// if we successfully stopped this service, then
|
|
// add it to the restart service list
|
|
if (iReturn == TRUE)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("StopServiceAndDependencies(): %s service. success.\n"), ServiceName));
|
|
if (iBeforeServiceStatus == SERVICE_RUNNING)
|
|
{
|
|
if (AddToRestartList) {ServicesRestartList_Add(ServiceName);}
|
|
}
|
|
}
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
// ----------------------------------------------
|
|
// The service must be in a hung mode. Let's kill it.
|
|
// Get the binary path name and use that to kill it.
|
|
// Return true on successfull kill. false otherwise.
|
|
// ----------------------------------------------
|
|
int KillService(SC_HANDLE ServiceHandle)
|
|
{
|
|
int iReturn = FALSE;
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
int iFlagPutItBack = FALSE;
|
|
|
|
// Retrieve the service's config for the BinaryPathName
|
|
// if failed then just return
|
|
if(RetrieveServiceConfig(ServiceHandle, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
goto KillService_Exit;
|
|
}
|
|
if(!ServiceConfig)
|
|
{
|
|
goto KillService_Exit;
|
|
}
|
|
|
|
// The Service can be one of these types:
|
|
// SERVICE_WIN32_OWN_PROCESS: A service type flag that indicates a Win32 service that runs in its own process.
|
|
// SERVICE_WIN32_SHARE_PROCESS: A service type flag that indicates a Win32 service that shares a process with other services.
|
|
// SERVICE_KERNEL_DRIVER: A service type flag that indicates a Windows NT device driver.
|
|
// SERVICE_FILE_SYSTEM_DRIVER: A service type flag that indicates a Windows NT file system driver.
|
|
// SERVICE_INTERACTIVE_PROCESS: A flag that indicates a Win32 service process that can interact with the desktop.
|
|
|
|
// Attempt to kill only if it's a process.
|
|
if ( (ServiceConfig->dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (ServiceConfig->dwServiceType & SERVICE_WIN32_SHARE_PROCESS))
|
|
{
|
|
if ( _tcslen(ServiceConfig->lpBinaryPathName) >= MAX_PATH )
|
|
{
|
|
goto KillService_Exit;
|
|
}
|
|
|
|
// parse out the different parts and take only the filename.ext
|
|
TCHAR pfilename_only[ MAX_PATH ];
|
|
TCHAR pextention_only[ MAX_PATH ];
|
|
_tsplitpath( ServiceConfig->lpBinaryPathName, NULL, NULL, pfilename_only, pextention_only);
|
|
if (pextention_only) {_tcscat(pfilename_only,pextention_only);}
|
|
|
|
if ( _tcsicmp( pfilename_only, _T("lsass") ) == 0 )
|
|
{
|
|
// No matter what service it is, lets not kill lsass.exe
|
|
goto KillService_Exit;
|
|
}
|
|
|
|
// Convert it to ansi for our "kill" function
|
|
char szFile[ MAX_PATH ];
|
|
#if defined(UNICODE) || defined(_UNICODE)
|
|
WideCharToMultiByte( CP_ACP, 0, (WCHAR*)pfilename_only, -1, szFile, MAX_PATH, NULL, NULL );
|
|
#else
|
|
_tcscpy(szFile, pfilename_only);
|
|
#endif
|
|
|
|
// Some of these services have some action to do if the service is killed.
|
|
// like IISADMIN has some restart function which will automagically restart the
|
|
// Service if the process is not properly shutdown.
|
|
// We need to disable this deal because We can't have this service just startup by itself again.
|
|
iFlagPutItBack = FALSE;
|
|
if (_tcsicmp(ServiceConfig->lpServiceStartName,_T("IISADMIN")) == 0)
|
|
{
|
|
// Go lookup the registry for "FailureCommands" and save that information.
|
|
// retrieve from registry
|
|
CString csFailureCommand;
|
|
CRegKey regIISADMINParam(HKEY_LOCAL_MACHINE, REG_IISADMIN);
|
|
if ( (HKEY)regIISADMINParam )
|
|
{
|
|
regIISADMINParam.m_iDisplayWarnings = FALSE;
|
|
if (ERROR_SUCCESS == regIISADMINParam.QueryValue(_T("FailureCommands"), csFailureCommand))
|
|
{
|
|
// Kool, we got it.
|
|
// Set it to do nothing.
|
|
regIISADMINParam.SetValue(_T("FailureCommands"), _T(""));
|
|
iFlagPutItBack = TRUE;
|
|
}
|
|
}
|
|
|
|
// kill the service's process
|
|
if (KillProcessNameReturn0(szFile) == 0) {iReturn = TRUE;}
|
|
|
|
if (TRUE == iFlagPutItBack)
|
|
{
|
|
CRegKey regIISADMINParam(HKEY_LOCAL_MACHINE, REG_IISADMIN);
|
|
if ( (HKEY)regIISADMINParam )
|
|
{
|
|
regIISADMINParam.SetValue(_T("FailureCommands"), csFailureCommand);
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (KillProcessNameReturn0(szFile) == 0) {iReturn = TRUE;}
|
|
}
|
|
}
|
|
|
|
KillService_Exit:
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
|
|
INT CheckifServiceMarkedForDeletion( LPCTSTR lpServiceName )
|
|
{
|
|
INT iReturn = FALSE;
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
// set up the service first
|
|
if ((hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
goto CheckifServiceMarkedForDeletion_Exit;
|
|
}
|
|
|
|
SERVICE_STATUS svcStatus;
|
|
if ( !QueryServiceStatus( hService, &svcStatus ))
|
|
{
|
|
err = ::GetLastError();
|
|
goto CheckifServiceMarkedForDeletion_Exit;
|
|
}
|
|
|
|
if ( svcStatus.dwCurrentState == SERVICE_RUNNING )
|
|
{
|
|
// We will only get this ERROR_SERVICE_MARKED_FOR_DELETE
|
|
// message if the service is already running.
|
|
if ( !::StartService( hService, 0, NULL ))
|
|
{
|
|
err = ::GetLastError();
|
|
if (err == ERROR_SERVICE_MARKED_FOR_DELETE) {iReturn = TRUE;}
|
|
goto CheckifServiceMarkedForDeletion_Exit;
|
|
}
|
|
}
|
|
|
|
CheckifServiceMarkedForDeletion_Exit:
|
|
if (hService) CloseServiceHandle(hService);
|
|
if (hScManager) CloseServiceHandle(hScManager);
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
//
|
|
// warning: This will leave the lpServiceToValidate in the started mode upon exit!
|
|
//
|
|
int ValidateDependentService(LPCTSTR lpServiceToValidate, LPCTSTR lpServiceWhichIsDependent)
|
|
{
|
|
iisDebugOut_Start1(_T("ValidateDependentService"),(LPTSTR) lpServiceToValidate);
|
|
|
|
int iReturn = FALSE;
|
|
INT err = 0;
|
|
int iFailFlag = FALSE;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
|
|
// Let's validate that the lpServiceToValidate is installed fine.
|
|
|
|
// Check if the lpServiceToValidate service EVEN exists
|
|
err = CheckifServiceExistAndDependencies(lpServiceToValidate);
|
|
if ( err != 0 )
|
|
{
|
|
MyMessageBox(NULL, IDS_DEPENDENT_UPON_THIS_SVC_ERR, lpServiceWhichIsDependent,lpServiceWhichIsDependent,err, MB_OK | MB_SETFOREGROUND);
|
|
}
|
|
else
|
|
{
|
|
// Try to start the service
|
|
err = InetStartService(lpServiceToValidate);
|
|
if (err == 0 || err == ERROR_SERVICE_ALREADY_RUNNING)
|
|
{
|
|
err = NERR_Success;
|
|
iReturn = TRUE;
|
|
goto ValidateDependentService_Exit;
|
|
}
|
|
|
|
// Service returned an error when we tried to start it.
|
|
// Check if the error = ERROR_SERVICE_DEPENDENCY_FAIL
|
|
if (err == ERROR_SERVICE_DEPENDENCY_FAIL)
|
|
{
|
|
// Loop thru this services dependencies and try to
|
|
// start them, to find out which one failed to start.
|
|
iFailFlag = FALSE;
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = ::OpenService( hScManager, lpServiceToValidate, GENERIC_ALL )) == NULL ) {iFailFlag = TRUE;}
|
|
// Get the existing Service information
|
|
if (iFailFlag != TRUE) {if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR) {iFailFlag = TRUE;}}
|
|
if (iFailFlag != TRUE) {if(!ServiceConfig){iFailFlag = TRUE;}}
|
|
// Get the dependencies
|
|
if (iFailFlag != TRUE)
|
|
{
|
|
TCHAR * pdest = NULL;
|
|
long RightMostNull = 0;
|
|
pdest = ServiceConfig->lpDependencies;
|
|
do
|
|
{
|
|
if (*pdest != _T('\0'))
|
|
{
|
|
RightMostNull = RightMostNull + _tcslen(pdest) + 1;
|
|
|
|
// Try to start the service...
|
|
err = InetStartService(pdest);
|
|
if (err)
|
|
{
|
|
if (err != ERROR_SERVICE_ALREADY_RUNNING)
|
|
{
|
|
// The pdest
|
|
// Service was unable to start because...
|
|
// MyMessageBox(NULL, IDS_UNABLE_TO_START, pdest, err, MB_OK | MB_SETFOREGROUND);
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("ValidateDependentService():Unable to start ServiceName=%s.\n"), pdest));
|
|
}
|
|
}
|
|
pdest = _tcschr(pdest, _T('\0'));
|
|
pdest++;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
} while (TRUE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MyMessageBox(NULL, IDS_UNABLE_TO_START, lpServiceToValidate, err, MB_OK | MB_SETFOREGROUND);
|
|
}
|
|
|
|
}
|
|
|
|
ValidateDependentService_Exit:
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
iisDebugOut_End1(_T("ValidateDependentService"), lpServiceToValidate, LOG_TYPE_TRACE);
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
|
|
int LogEnumServicesStatus(void)
|
|
{
|
|
int iReturn = FALSE;
|
|
#ifndef _CHICAGO_
|
|
BOOL success = 0;
|
|
SC_HANDLE scm = NULL;
|
|
LPENUM_SERVICE_STATUS status = NULL;
|
|
DWORD numServices=0, sizeNeeded=0, resume=0;
|
|
|
|
// Open a connection to the SCM
|
|
//scm = OpenSCManager(0, 0, GENERIC_ALL);
|
|
scm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
|
|
if (!scm)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("CallEnumServicesStatus():OpenSCManager. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto CallEnumServicesStatus_Exit;
|
|
}
|
|
|
|
// get the number of bytes to allocate
|
|
// MAKE SURE resume starts at 0
|
|
resume = 0;
|
|
success = EnumServicesStatus(scm, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_ACTIVE | SERVICE_INACTIVE, 0, 0, &sizeNeeded, &numServices, &resume);
|
|
if (GetLastError() != ERROR_MORE_DATA)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("CallEnumServicesStatus():EnumServicesStatus0. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto CallEnumServicesStatus_Exit;
|
|
}
|
|
|
|
// Allocate space
|
|
status = (LPENUM_SERVICE_STATUS) LocalAlloc(LPTR, sizeNeeded);
|
|
if( status == NULL )
|
|
{
|
|
goto CallEnumServicesStatus_Exit;
|
|
}
|
|
|
|
// Get the status records. Making an assumption
|
|
// here that no new services get added during
|
|
// the allocation (could lock the database to
|
|
// guarantee that...)
|
|
resume = 0;
|
|
success = EnumServicesStatus(scm, SERVICE_WIN32,SERVICE_ACTIVE | SERVICE_INACTIVE,status, sizeNeeded, &sizeNeeded,&numServices, &resume);
|
|
if (!success)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("CallEnumServicesStatus():EnumServicesStatus. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto CallEnumServicesStatus_Exit;
|
|
}
|
|
|
|
DWORD i;
|
|
for (i=0; i < numServices; i++)
|
|
{
|
|
switch(status[i].ServiceStatus.dwCurrentState)
|
|
{
|
|
case SERVICE_STOPPED:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_STOPPED [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_START_PENDING:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_START_PENDING [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_STOP_PENDING:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_STOP_PENDING [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_RUNNING:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_RUNNING [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_CONTINUE_PENDING:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_CONTINUE_PENDING [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_PAUSE_PENDING:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_PAUSE_PENDING [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
case SERVICE_PAUSED:
|
|
iisDebugOut((LOG_TYPE_PROGRAM_FLOW, _T("SERVICE_PAUSED [%s].\n"), status[i].lpServiceName));
|
|
break;
|
|
}
|
|
}
|
|
iReturn = TRUE;
|
|
|
|
CallEnumServicesStatus_Exit:
|
|
if (status){LocalFree(status);}
|
|
if (scm) {CloseServiceHandle(scm);}
|
|
#endif
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
int InetIsThisExeAService(LPCTSTR lpFileNameToCheck, LPTSTR lpReturnServiceName)
|
|
{
|
|
int iReturn = FALSE;
|
|
#ifndef _CHICAGO_
|
|
BOOL success = 0;
|
|
SC_HANDLE scm = NULL;
|
|
LPENUM_SERVICE_STATUS status = NULL;
|
|
DWORD numServices=0, sizeNeeded=0, resume=0;
|
|
|
|
_tcscpy(lpReturnServiceName, _T(""));
|
|
|
|
// Open a connection to the SCM
|
|
//scm = OpenSCManager(0, 0, GENERIC_ALL);
|
|
scm = OpenSCManager(0, 0, SC_MANAGER_ALL_ACCESS);
|
|
if (!scm)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetIsThisExeAService():OpenSCManager. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto InetIsThisExeAService_Exit;
|
|
}
|
|
|
|
// get the number of bytes to allocate
|
|
// MAKE SURE resume starts at 0
|
|
resume = 0;
|
|
success = EnumServicesStatus(scm, SERVICE_WIN32 | SERVICE_DRIVER, SERVICE_ACTIVE | SERVICE_INACTIVE, 0, 0, &sizeNeeded, &numServices, &resume);
|
|
if (GetLastError() != ERROR_MORE_DATA)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetIsThisExeAService():EnumServicesStatus0. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto InetIsThisExeAService_Exit;
|
|
}
|
|
|
|
// Allocate space
|
|
status = (LPENUM_SERVICE_STATUS) LocalAlloc(LPTR, sizeNeeded);
|
|
if( status == NULL )
|
|
{
|
|
goto InetIsThisExeAService_Exit;
|
|
}
|
|
|
|
// Get the status records. Making an assumption
|
|
// here that no new services get added during
|
|
// the allocation (could lock the database to
|
|
// guarantee that...)
|
|
resume = 0;
|
|
success = EnumServicesStatus(scm, SERVICE_WIN32,SERVICE_ACTIVE | SERVICE_INACTIVE,status, sizeNeeded, &sizeNeeded,&numServices, &resume);
|
|
if (!success)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetIsThisExeAService():EnumServicesStatus. FAILED. err=0x%x\n"), GetLastError()));
|
|
goto InetIsThisExeAService_Exit;
|
|
}
|
|
|
|
DWORD i;
|
|
for (i=0; i < numServices; i++)
|
|
{
|
|
// Use the status[i].lpServiceName
|
|
// to query the service and find out it's binary filename
|
|
if (TRUE == InetIsThisExeAService_Worker(status[i].lpServiceName, lpFileNameToCheck))
|
|
{
|
|
iReturn = TRUE;
|
|
// copy in the service name into the return string.
|
|
_tcscpy(lpReturnServiceName, status[i].lpServiceName);
|
|
goto InetIsThisExeAService_Exit;
|
|
}
|
|
}
|
|
|
|
InetIsThisExeAService_Exit:
|
|
if (status){LocalFree(status);}
|
|
if (scm) {CloseServiceHandle(scm);}
|
|
#endif
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
int InetIsThisExeAService_Worker(LPCTSTR lpServiceName, LPCTSTR lpFileNameToCheck)
|
|
{
|
|
int iReturn = FALSE;
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
|
|
BYTE ConfigBuffer[4096];
|
|
LPENUM_SERVICE_STATUS ServiceConfigEnum = (LPENUM_SERVICE_STATUS) &ConfigBuffer;
|
|
|
|
if (( hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
// Failed, or more likely the service doesn't exist
|
|
//iReturn = GetLastError();
|
|
goto InetIsThisExeAService_Worker_Exit;
|
|
}
|
|
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
//iReturn = GetLastError();
|
|
goto InetIsThisExeAService_Worker_Exit;
|
|
}
|
|
|
|
if(!ServiceConfig)
|
|
{
|
|
goto InetIsThisExeAService_Worker_Exit;
|
|
}
|
|
|
|
if ( (ServiceConfig->dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (ServiceConfig->dwServiceType & SERVICE_WIN32_SHARE_PROCESS))
|
|
{
|
|
if (ServiceConfig->lpBinaryPathName)
|
|
{
|
|
if (_tcsicmp(lpFileNameToCheck, ServiceConfig->lpBinaryPathName) == 0)
|
|
{
|
|
//We found a match!!!!!
|
|
iReturn = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// we did not find a match, based on c:\path\filename and c:\path\filename
|
|
// maybe we try "filename.exe" and "filename.exe"????
|
|
TCHAR szBinaryNameOnly[_MAX_FNAME];
|
|
TCHAR szFileNameToCheckNameOnly[_MAX_FNAME];
|
|
if (TRUE == ReturnFileNameOnly((LPCTSTR) ServiceConfig->lpBinaryPathName, szBinaryNameOnly))
|
|
{
|
|
if (TRUE == ReturnFileNameOnly((LPCTSTR) lpFileNameToCheck, szFileNameToCheckNameOnly))
|
|
{
|
|
if (_tcsicmp(szFileNameToCheckNameOnly, szBinaryNameOnly) == 0)
|
|
{
|
|
//We found a match!!!!!
|
|
iReturn = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
InetIsThisExeAService_Worker_Exit:
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
int IsThisServiceADriver(LPCTSTR lpServiceName)
|
|
{
|
|
int iReturn = FALSE;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig=NULL;
|
|
|
|
BYTE ConfigBuffer[4096];
|
|
LPENUM_SERVICE_STATUS ServiceConfigEnum = (LPENUM_SERVICE_STATUS) &ConfigBuffer;
|
|
if ((hScManager = OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL || (hService = OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
// Failed, or more likely the service doesn't exist
|
|
//iReturn = GetLastError();
|
|
goto IsThisServiceADriver_Exit;
|
|
}
|
|
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
//iReturn = GetLastError();
|
|
goto IsThisServiceADriver_Exit;
|
|
}
|
|
|
|
if(!ServiceConfig)
|
|
{
|
|
//iReturn = GetLastError();
|
|
goto IsThisServiceADriver_Exit;
|
|
}
|
|
|
|
if ( (ServiceConfig->dwServiceType & SERVICE_KERNEL_DRIVER) || (ServiceConfig->dwServiceType & SERVICE_FILE_SYSTEM_DRIVER))
|
|
{
|
|
iReturn = TRUE;
|
|
}
|
|
|
|
IsThisServiceADriver_Exit:
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
int CreateDriver(CString csDriverName, CString csDisplayName, CString csFileName)
|
|
{
|
|
DWORD dwReturn = ERROR_SUCCESS;
|
|
CString csBinPath;
|
|
CString csFile;
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("CreateDriver:%s:%s start.\n"), csDriverName, csFileName));
|
|
|
|
csBinPath = _T("\\SystemRoot\\System32\\drivers\\");
|
|
csBinPath += csFileName;
|
|
|
|
// Check if the file even exists first.
|
|
csFile = g_pTheApp->m_csSysDir;
|
|
csFile += _T("\\Drivers\\");
|
|
csFile += csFileName;
|
|
if (!IsFileExist(csFile))
|
|
{
|
|
dwReturn = ERROR_FILE_NOT_FOUND;
|
|
goto CreateDriver_Exit;
|
|
}
|
|
|
|
//
|
|
// Attempt to create the service, could fail if this is an
|
|
// Refresh Install will leave the driver from the prior
|
|
// Install, becuse if we delete in the remove phase it will
|
|
// get marked for deletion and not get readded now.
|
|
// this could happen in a upgrade as well....
|
|
//
|
|
dwReturn = InetCreateDriver(csDriverName, (LPCTSTR)csDisplayName, (LPCTSTR)csBinPath, SERVICE_DEMAND_START);
|
|
if ( dwReturn != ERROR_SUCCESS )
|
|
{
|
|
if (dwReturn == ERROR_SERVICE_EXISTS)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("CreateDriver:%s:Service exists.\n"), csDriverName));
|
|
dwReturn = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("CreateDriver:%s:failed to create service Err=0x%x.\n"), csDriverName, dwReturn));
|
|
MyMessageBox(NULL, IDS_UNABLE_TO_CREATE_DRIVER, csDriverName, dwReturn, MB_OK | MB_SETFOREGROUND);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("CreateDriver:%s:Successfully created.\n"), csDriverName));
|
|
}
|
|
|
|
CreateDriver_Exit:
|
|
return dwReturn;
|
|
}
|
|
|
|
|
|
DWORD CreateDriver_Wrap(CString csDriverName, CString csDisplayName, CString csFileName,BOOL bDisplayMsgOnErrFlag)
|
|
{
|
|
int bFinishedFlag = FALSE;
|
|
UINT iMsg = NULL;
|
|
DWORD dwReturn = ERROR_SUCCESS;
|
|
|
|
// Create or Config driver spud.sys, NT Server product onloy!!!
|
|
if (g_pTheApp->m_eOS != OS_W95)
|
|
{
|
|
do
|
|
{
|
|
dwReturn = CreateDriver(csDriverName, csDisplayName, csFileName);
|
|
if (dwReturn == ERROR_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (bDisplayMsgOnErrFlag == TRUE)
|
|
{
|
|
iMsg = MyMessageBox( NULL, IDS_RETRY, MB_ABORTRETRYIGNORE | MB_SETFOREGROUND );
|
|
switch ( iMsg )
|
|
{
|
|
case IDIGNORE:
|
|
dwReturn = ERROR_SUCCESS;
|
|
goto CreateDriver_Wrap_Exit;
|
|
case IDABORT:
|
|
dwReturn = ERROR_OPERATION_ABORTED;
|
|
goto CreateDriver_Wrap_Exit;
|
|
case IDRETRY:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// return whatever err happened
|
|
goto CreateDriver_Wrap_Exit;
|
|
}
|
|
|
|
}
|
|
} while (dwReturn != ERROR_SUCCESS);
|
|
}
|
|
|
|
CreateDriver_Wrap_Exit:
|
|
return dwReturn;
|
|
}
|
|
|
|
|
|
INT InetConfigServiceInteractive(LPCTSTR lpServiceName, int AddInteractive)
|
|
{
|
|
iisDebugOut((LOG_TYPE_TRACE_WIN32_API, _T("InetConfigServiceInteractive(%i):ServiceName=%s\n"),AddInteractive,(LPTSTR) lpServiceName));
|
|
|
|
INT err = 0;
|
|
SC_HANDLE hScManager = NULL;
|
|
SC_HANDLE hService = NULL;
|
|
LPQUERY_SERVICE_CONFIG ServiceConfig = NULL;
|
|
DWORD dwNewServiceType = 0;
|
|
BOOL bDoStuff = FALSE;
|
|
|
|
do {
|
|
if ((hScManager = ::OpenSCManager( NULL, NULL, GENERIC_ALL )) == NULL ||
|
|
(hService = ::OpenService( hScManager, lpServiceName, GENERIC_ALL )) == NULL )
|
|
{
|
|
err = GetLastError();
|
|
// if error = ERROR_SERVICE_DOES_NOT_EXIST
|
|
if (ERROR_SERVICE_DOES_NOT_EXIST != err)
|
|
{
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigServiceInteractive():OpenSCManager or OpenService: Service=%s Err=0x%x FAILED\n"), lpServiceName,err));
|
|
}
|
|
break;
|
|
}
|
|
|
|
if(RetrieveServiceConfig(hService, &ServiceConfig) != NO_ERROR)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
if(!ServiceConfig)
|
|
{
|
|
err = GetLastError();
|
|
break;
|
|
}
|
|
|
|
// Interactive flag can only work on own_process or share_process types
|
|
if ( (ServiceConfig->dwServiceType & SERVICE_WIN32_OWN_PROCESS) || (ServiceConfig->dwServiceType & SERVICE_WIN32_SHARE_PROCESS))
|
|
{
|
|
// default it incase someone changes code below and logic gets messed up
|
|
dwNewServiceType = ServiceConfig->dwServiceType;
|
|
|
|
// if the interactive flag is already there
|
|
// then don't do jack, otherwise, add it on
|
|
if (ServiceConfig->dwServiceType & SERVICE_INTERACTIVE_PROCESS)
|
|
{
|
|
// only do stuff if we're asked to remove it!
|
|
if (FALSE == AddInteractive)
|
|
{
|
|
// Remove it from the mask!
|
|
dwNewServiceType = ServiceConfig->dwServiceType & (~SERVICE_INTERACTIVE_PROCESS);
|
|
bDoStuff = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (TRUE == AddInteractive)
|
|
{
|
|
dwNewServiceType = ServiceConfig->dwServiceType | SERVICE_INTERACTIVE_PROCESS;
|
|
bDoStuff = TRUE;
|
|
}
|
|
}
|
|
|
|
if (TRUE == bDoStuff)
|
|
{
|
|
if ( !::ChangeServiceConfig(hService, dwNewServiceType, SERVICE_NO_CHANGE, SERVICE_NO_CHANGE, NULL, NULL, NULL, NULL, NULL, NULL, NULL) )
|
|
{
|
|
err = GetLastError();
|
|
iisDebugOut((LOG_TYPE_ERROR, _T("InetConfigServiceInteractive():ChangeServiceConfig: Service=%s Err=0x%x FAILED\n"), lpServiceName, err));
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
|
|
} while ( FALSE );
|
|
|
|
if (ServiceConfig) {free(ServiceConfig);}
|
|
if (hService) {CloseServiceHandle(hService);}
|
|
if (hScManager) {CloseServiceHandle(hScManager);}
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("InetConfigServiceInteractive():ServiceName=%s. Return=0x%x.\n"), lpServiceName, err));
|
|
return(err);
|
|
}
|
|
|
|
|
|
// This function trys to create the www service
|
|
int MyCreateService(CString csServiceName, CString csDisplayName, CString csBinPath, CString csDependencies, CString csDescription)
|
|
{
|
|
int iReturn = !ERROR_SUCCESS;
|
|
int err = NERR_Success;
|
|
TSTR strDependencies2( MAX_PATH );
|
|
|
|
iisDebugOut((LOG_TYPE_TRACE, _T("MyCreateService:%s,%s,%s,%s.\n"),csServiceName, csDisplayName, csBinPath, csDependencies));
|
|
|
|
if ( !strDependencies2.Copy( csDependencies.GetBuffer(0) ) ||
|
|
!strDependencies2.Append( _T(":") )
|
|
)
|
|
{
|
|
return iReturn;
|
|
}
|
|
|
|
// make sure it ends with a ":"
|
|
// and then replace all the ":", with a "\0" null....
|
|
TCHAR *p = (LPTSTR) strDependencies2.QueryStr();
|
|
while (*p)
|
|
{
|
|
// change ":" to a null "\0"
|
|
if (*p == _T(':')){*p = _T('\0');}
|
|
p = _tcsinc(p);
|
|
}
|
|
|
|
err = InetCreateService(csServiceName,
|
|
(LPCTSTR)csDisplayName,
|
|
(LPCTSTR)csBinPath,
|
|
SERVICE_AUTO_START,
|
|
strDependencies2.QueryStr());
|
|
|
|
if ( err != NERR_Success )
|
|
{
|
|
// check if the error is because the service already exists...
|
|
if (err == ERROR_SERVICE_EXISTS)
|
|
{
|
|
// Since the service should exist by the time we get here,
|
|
// let's make sure it has the dependency we want it to have.
|
|
err = InetConfigService(csServiceName, (LPCTSTR)csDisplayName, (LPCTSTR)csBinPath, strDependencies2.QueryStr());
|
|
if (err != NERR_Success)
|
|
{
|
|
SetLastError(err);
|
|
goto MyCreateService_Exit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetLastError(err);
|
|
goto MyCreateService_Exit;
|
|
}
|
|
|
|
}
|
|
|
|
// Use newer api to add the description field.
|
|
err = InetConfigService2(csServiceName, (LPCTSTR)csDescription);
|
|
if (err != NERR_Success)
|
|
{
|
|
SetLastError(err);
|
|
goto MyCreateService_Exit;
|
|
}
|
|
|
|
// there was no error in the InetCreateService call.
|
|
// so everything is hunky dory
|
|
iReturn = ERROR_SUCCESS;
|
|
|
|
MyCreateService_Exit:
|
|
return iReturn;
|
|
}
|
|
|
|
|
|
DWORD CreateService_wrap(CString csServiceName, CString csDisplayName, CString csBinPath, CString csDependencies, CString csDescription, BOOL bDisplayMsgOnErrFlag)
|
|
{
|
|
int bFinishedFlag = FALSE;
|
|
UINT iMsg = NULL;
|
|
DWORD dwReturn = ERROR_SUCCESS;
|
|
|
|
do
|
|
{
|
|
dwReturn = MyCreateService(csServiceName, csDisplayName, csBinPath, csDependencies, csDescription);
|
|
if (dwReturn == ERROR_SUCCESS)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if (bDisplayMsgOnErrFlag == TRUE)
|
|
{
|
|
iMsg = MyMessageBox( NULL, IDS_RETRY, MB_ABORTRETRYIGNORE | MB_SETFOREGROUND );
|
|
switch ( iMsg )
|
|
{
|
|
case IDIGNORE:
|
|
dwReturn = ERROR_SUCCESS;
|
|
goto CreateService_wrap_Exit;
|
|
case IDABORT:
|
|
dwReturn = ERROR_OPERATION_ABORTED;
|
|
goto CreateService_wrap_Exit;
|
|
case IDRETRY:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// return whatever err happened
|
|
goto CreateService_wrap_Exit;
|
|
}
|
|
|
|
}
|
|
} while (dwReturn != ERROR_SUCCESS);
|
|
|
|
CreateService_wrap_Exit:
|
|
return dwReturn;
|
|
}
|
|
|
|
// function: ChangeServiceDepenedency
|
|
//
|
|
// Change the dependency of a particular service, to either add or remove another service name
|
|
// from it
|
|
//
|
|
// ex. ChangeServiceDependency( W3SSL, TRUE, IISADMIN ) - Would make W3SSL dependant on IISADMIN
|
|
//
|
|
// Parameters:
|
|
// szServiceName - The service to modify
|
|
// bAddDependency - Add or remove dependency
|
|
// szDependantService - The service that you wand to add as the depenedency
|
|
//
|
|
BOOL
|
|
ChangeServiceDependency(LPTSTR szServiceName, BOOL bAddDependency, LPTSTR szDependantService)
|
|
{
|
|
SC_HANDLE hService;
|
|
SC_HANDLE hSCManager;
|
|
BOOL bRet = FALSE;
|
|
BOOL bChange = FALSE;
|
|
BUFFER buffConfig;
|
|
DWORD dwSizeRequired;
|
|
TSTR_MSZ mszDependencies;
|
|
|
|
hSCManager = OpenSCManager( NULL, NULL, SC_MANAGER_CONNECT | GENERIC_READ );
|
|
|
|
if ( hSCManager == NULL )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
hService = OpenService( hSCManager, szServiceName, SERVICE_QUERY_CONFIG | SERVICE_CHANGE_CONFIG );
|
|
|
|
if ( hService == NULL )
|
|
{
|
|
CloseServiceHandle( hSCManager );
|
|
return FALSE;
|
|
}
|
|
|
|
if ( !QueryServiceConfig( hService, NULL, 0, &dwSizeRequired ) &&
|
|
( GetLastError() == ERROR_INSUFFICIENT_BUFFER ) &&
|
|
buffConfig.Resize( dwSizeRequired ) &&
|
|
QueryServiceConfig( hService, (LPQUERY_SERVICE_CONFIG) buffConfig.QueryPtr(), buffConfig.QuerySize(), &dwSizeRequired )
|
|
)
|
|
{
|
|
// We have successfully retrieved the service info, so lets modify it
|
|
if ( mszDependencies.Copy( ((LPQUERY_SERVICE_CONFIG) buffConfig.QueryPtr())->lpDependencies ) )
|
|
{
|
|
if ( bAddDependency )
|
|
{
|
|
if ( !mszDependencies.IsPresent(szDependantService, FALSE) )
|
|
{
|
|
bRet = mszDependencies.Add( szDependantService );
|
|
bChange = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// It is already present, so we don't need to add again
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( mszDependencies.IsPresent(szDependantService, FALSE) )
|
|
{
|
|
bRet = mszDependencies.Remove( szDependantService, FALSE );
|
|
bChange = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// Since it is not there, lets not worry about it
|
|
bRet = TRUE;
|
|
}
|
|
}
|
|
|
|
if ( bRet && bChange )
|
|
{
|
|
bRet = ChangeServiceConfig( hService, // Service Handle
|
|
SERVICE_NO_CHANGE, // Service Type
|
|
SERVICE_NO_CHANGE, // Startup Type
|
|
SERVICE_NO_CHANGE, // Error Control
|
|
NULL, // Binary Path
|
|
NULL, // Load Order Group
|
|
NULL, // TagID
|
|
mszDependencies.QueryMultiSz(), // Dependencies
|
|
NULL, // Service Start Name
|
|
NULL, // Password
|
|
NULL ); // Display Name
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseServiceHandle( hSCManager );
|
|
CloseServiceHandle( hService );
|
|
|
|
return bRet;
|
|
}
|