able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/ds/adsi/winnt/cserv.cxx

1942 lines
47 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1995
//
// File: cserv.cxx
//
// Contents: Contains methods for the following objects
// CWinNTService,
//
// History: 12/11/95 ramv (Ram Viswanathan) Created.
//
//----------------------------------------------------------------------------
#include "winnt.hxx"
#pragma hdrstop
#define INITGUID
//
// class CWinNTService methods
//
DEFINE_IDispatch_ExtMgr_Implementation(CWinNTService);
DEFINE_IADsExtension_ExtMgr_Implementation(CWinNTService);
DEFINE_IADs_TempImplementation(CWinNTService);
DEFINE_IADs_PutGetImplementation(CWinNTService,ServiceClass,gdwServiceTableSize);
DEFINE_IADsPropertyList_Implementation(CWinNTService, ServiceClass,gdwServiceTableSize)
CWinNTService::CWinNTService()
{
_pDispMgr = NULL;
_pExtMgr = NULL;
_pPropertyCache = NULL;
_pszServiceName = NULL;
_pszServerName = NULL;
_pszPath = NULL;
_schSCManager = NULL;
_schService = NULL;
_dwWaitHint = 0;
_dwCheckPoint = 0;
_fValidHandle = FALSE;
ENLIST_TRACKING(CWinNTService);
}
CWinNTService::~CWinNTService()
{
if(_fValidHandle){
//
// an open handle exists, blow it away
//
WinNTCloseService();
_fValidHandle = FALSE;
}
if(_pszServiceName){
FreeADsStr(_pszServiceName);
}
if(_pszServerName){
FreeADsStr(_pszServerName);
}
if(_pszPath){
FreeADsStr(_pszPath);
}
delete _pExtMgr; // created last, destroyed first
delete _pDispMgr;
delete _pPropertyCache;
return;
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::Create
//
// Synopsis: Static function used to create a Service object. This
// will be called by BindToObject
//
// Arguments: [ppWinNTService] -- Ptr to a ptr to a new Service object.
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 12-11-95 RamV Created.
//
//----------------------------------------------------------------------------
HRESULT
CWinNTService::Create(LPTSTR pszADsParent,
LPTSTR pszDomainName,
LPTSTR pszServerName,
LPTSTR pszServiceName,
DWORD dwObjectState,
REFIID riid,
CWinNTCredentials& Credentials,
LPVOID * ppvoid
)
{
CWinNTService FAR * pCWinNTService = NULL;
HRESULT hr;
//
// Create the Service Object
//
hr = AllocateServiceObject(pszServerName,
pszServiceName,
&pCWinNTService);
BAIL_ON_FAILURE(hr);
ADsAssert(pCWinNTService->_pDispMgr);
hr = pCWinNTService->InitializeCoreObject(pszADsParent,
pszServiceName,
SERVICE_CLASS_NAME,
SERVICE_SCHEMA_NAME,
CLSID_WinNTService,
dwObjectState);
BAIL_ON_FAILURE(hr);
hr = SetLPTSTRPropertyInCache(pCWinNTService->_pPropertyCache,
TEXT("HostComputer"),
pCWinNTService->_Parent,
TRUE
);
BAIL_ON_FAILURE(hr);
pCWinNTService->_Credentials = Credentials;
hr = pCWinNTService->_Credentials.RefServer(pszServerName);
BAIL_ON_FAILURE(hr);
//
// Load ext mgr and extensions
//
hr = ADSILoadExtensionManager(
SERVICE_CLASS_NAME,
(IADsService *) pCWinNTService,
pCWinNTService->_pDispMgr,
Credentials,
&pCWinNTService->_pExtMgr
);
BAIL_ON_FAILURE(hr);
ADsAssert(pCWinNTService->_pExtMgr);
// check if the call is from UMI
if(Credentials.GetFlags() & ADS_AUTH_RESERVED) {
//
// we do not pass riid to InitUmiObject below. This is because UMI object
// does not support IDispatch. There are several places in ADSI code where
// riid passed into this function is defaulted to IID_IDispatch -
// IADsContainer::Create for example. To handle these cases, we always
// request IID_IUnknown from the UMI object. Subsequent code within UMI
// will QI for the appropriate interface.
//
if(3 == pCWinNTService->_dwNumComponents) {
pCWinNTService->_CompClasses[0] = L"Domain";
pCWinNTService->_CompClasses[1] = L"Computer";
pCWinNTService->_CompClasses[2] = L"Service";
}
else if(2 == pCWinNTService->_dwNumComponents) {
// no workstation services
pCWinNTService->_CompClasses[0] = L"Computer";
pCWinNTService->_CompClasses[1] = L"Service";
}
else
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
hr = pCWinNTService->InitUmiObject(
pCWinNTService->_Credentials,
ServiceClass,
gdwServiceTableSize,
pCWinNTService->_pPropertyCache,
(IUnknown *)(INonDelegatingUnknown *) pCWinNTService,
pCWinNTService->_pExtMgr,
IID_IUnknown,
ppvoid
);
BAIL_ON_FAILURE(hr);
//
// UMI object was created and the interface was obtained successfully.
// UMI object now has a reference to the inner unknown of IADs, since
// the call to Release() below is not going to be made in this case.
//
RRETURN(hr);
}
hr = pCWinNTService->QueryInterface(riid, (void **)ppvoid);
BAIL_ON_FAILURE(hr);
pCWinNTService->Release();
RRETURN(hr);
error:
delete pCWinNTService;
RRETURN_EXP_IF_ERR(hr);
}
HRESULT
CWinNTService::AllocateServiceObject(
LPTSTR pszServerName,
LPTSTR pszServiceName,
CWinNTService ** ppService
)
{
CWinNTService FAR * pService = NULL;
HRESULT hr = S_OK;
pService = new CWinNTService();
if (pService == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
pService->_pDispMgr = new CAggregatorDispMgr;
if (pService->_pDispMgr == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
pService->_pszServerName =
AllocADsStr(pszServerName);
if(!(pService->_pszServerName)){
hr = E_OUTOFMEMORY;
goto error;
}
pService->_pszServiceName =
AllocADsStr(pszServiceName);
if(!(pService->_pszServiceName)){
hr = E_OUTOFMEMORY;
goto error;
}
hr = LoadTypeInfoEntry(pService->_pDispMgr,
LIBID_ADs,
IID_IADsService,
(IADsService *)pService,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(pService->_pDispMgr,
LIBID_ADs,
IID_IADsServiceOperations,
(IADsServiceOperations *)pService,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
hr = CPropertyCache::createpropertycache(
ServiceClass,
gdwServiceTableSize,
(CCoreADsObject *)pService,
&(pService->_pPropertyCache)
);
BAIL_ON_FAILURE(hr);
(pService->_pDispMgr)->RegisterPropertyCache(
pService->_pPropertyCache
);
*ppService = pService;
RRETURN(hr);
error:
//
// direct memeber assignement assignement at pt of creation, so
// do NOT delete _pPropertyCache or _pDisMgr here to avoid attempt
// of deletion again in pPrintJob destructor and AV
//
delete pService;
RRETURN(hr);
}
/* IUnknown methods for service object */
//----------------------------------------------------------------------------
// Function: QueryInterface
//
// Synopsis: If this object is aggregated within another object, then
// all calls will delegate to the outer object. Otherwise, the
// non-delegating QI is called
//
// Arguments:
//
// iid interface requested
// ppInterface Returns pointer to interface requested. NULL if interface
// is not supported.
//
// Returns: S_OK on success. Error code otherwise.
//
// Modifies: *ppInterface to return interface pointer
//
//----------------------------------------------------------------------------
STDMETHODIMP CWinNTService::QueryInterface(
REFIID iid,
LPVOID *ppInterface
)
{
if(_pUnkOuter != NULL)
RRETURN(_pUnkOuter->QueryInterface(
iid,
ppInterface
));
RRETURN(NonDelegatingQueryInterface(
iid,
ppInterface
));
}
//----------------------------------------------------------------------------
// Function: AddRef
//
// Synopsis: IUnknown::AddRef. If this object is aggregated within
// another, all calls will delegate to the outer object.
// Otherwise, the non-delegating AddRef is called
//
// Arguments:
//
// None
//
// Returns: New reference count
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CWinNTService::AddRef(void)
{
if(_pUnkOuter != NULL)
RRETURN(_pUnkOuter->AddRef());
RRETURN(NonDelegatingAddRef());
}
//----------------------------------------------------------------------------
// Function: Release
//
// Synopsis: IUnknown::Release. If this object is aggregated within
// another, all calls will delegate to the outer object.
// Otherwise, the non-delegating Release is called
//
// Arguments:
//
// None
//
// Returns: New reference count
//
// Modifies: Nothing
//
//----------------------------------------------------------------------------
STDMETHODIMP_(ULONG) CWinNTService::Release(void)
{
if(_pUnkOuter != NULL)
RRETURN(_pUnkOuter->Release());
RRETURN(NonDelegatingRelease());
}
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::NonDelegatingQueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
HRESULT hr = S_OK;
if(!ppvObj){
RRETURN(E_POINTER);
}
if (IsEqualIID(riid, IID_IUnknown))
{
*ppvObj = (IADsService *)this;
}
else if (IsEqualIID(riid, IID_IDispatch))
{
*ppvObj = (IADsService *)this;
}
else if (IsEqualIID(riid, IID_ISupportErrorInfo))
{
*ppvObj = (ISupportErrorInfo FAR *)this;
}
else if (IsEqualIID(riid, IID_IADsPropertyList))
{
*ppvObj = (IADsPropertyList *)this;
}
else if (IsEqualIID(riid, IID_IADs))
{
*ppvObj = (IADsService FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsService))
{
*ppvObj = (IADsService FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsServiceOperations))
{
*ppvObj = (IADsServiceOperations FAR *) this;
}
else if( (_pDispatch != NULL) &&
IsEqualIID(riid, IID_IADsExtension) )
{
*ppvObj = (IADsExtension *) this;
}
else if (_pExtMgr)
{
RRETURN( _pExtMgr->QueryInterface(riid, ppvObj));
}
else
{
*ppvObj = NULL;
RRETURN(E_NOINTERFACE);
}
((LPUNKNOWN)*ppvObj)->AddRef();
RRETURN(S_OK);
}
/* ISupportErrorInfo method */
STDMETHODIMP
CWinNTService::InterfaceSupportsErrorInfo(
THIS_ REFIID riid
)
{
if (IsEqualIID(riid, IID_IADs) ||
IsEqualIID(riid, IID_IADsService) ||
IsEqualIID(riid, IID_IADsServiceOperations) ||
IsEqualIID(riid, IID_IADsPropertyList)) {
RRETURN(S_OK);
} else {
RRETURN(S_FALSE);
}
}
//+---------------------------------------------------------------------------
//
// Function: SetInfo
//
// Synopsis:
//
// Arguments: void
//
// Returns: HRESULT.
//
// Modifies:
//
// History: RamV Created
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::SetInfo(THIS)
{
HRESULT hr = S_OK;
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
LPTSTR pszPath = NULL;
LPTSTR pszLoadOrderGroup = NULL;
LPTSTR pszServiceStartName = NULL;
LPTSTR pszDependencies = NULL;
LPTSTR pszDisplayName = NULL;
SC_LOCK sclLock = NULL;
BOOL fRetval = FALSE;
LPQUERY_SERVICE_CONFIG lpqServiceConfig = NULL;
if (GetObjectState() == ADS_OBJECT_UNBOUND) {
hr = WinNTAddService();
BAIL_IF_ERROR(hr);
SetObjectState(ADS_OBJECT_BOUND);
}
hr = WinNTOpenService(SC_MANAGER_ALL_ACCESS,
SERVICE_ALL_ACCESS);
BAIL_IF_ERROR(hr);
hr = GetServiceConfigInfo(&lpqServiceConfig);
BAIL_IF_ERROR(hr);
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("Path"),
&pszPath
);
if(SUCCEEDED(hr)){
lpqServiceConfig->lpBinaryPathName = pszPath;
}
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("LoadOrderGroup"),
&pszLoadOrderGroup
);
if(SUCCEEDED(hr)){
lpqServiceConfig->lpLoadOrderGroup = pszLoadOrderGroup;
}
hr = GetNulledStringPropertyFromCache(
_pPropertyCache,
TEXT("Dependencies"),
&pszDependencies
);
if(SUCCEEDED(hr)){
lpqServiceConfig->lpDependencies = pszDependencies;
}
//
// Issue: Service Account Name property has been disabled from being a
// writeable property because ChangeServiceConfig AVs services.exe
// on the server machine when this property is changed
// RamV - Aug-11-96.
/*
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("ServiceAccountName"),
&pszServiceStartName
);
if(SUCCEEDED(hr)){
lpqServiceConfig->lpServiceStartName = pszServiceStartName;
}
*/
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("DisplayName"),
&pszDisplayName
);
if(SUCCEEDED(hr)){
lpqServiceConfig->lpDisplayName = pszDisplayName;
}
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("ServiceType"),
&dwServiceType
);
if(SUCCEEDED(hr)){
lpqServiceConfig->dwServiceType = dwServiceType;
}
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("StartType"),
&dwStartType
);
if(SUCCEEDED(hr)){
lpqServiceConfig->dwStartType = dwStartType;
}
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("ErrorControl"),
&dwErrorControl
);
if(SUCCEEDED(hr)){
lpqServiceConfig->dwErrorControl = dwErrorControl;
}
//
// set hr to S_OK. why? we dont care about the errors we hit so far
//
hr = S_OK;
//
// put a lock on the database corresponding to this service
//
sclLock = LockServiceDatabase(_schSCManager);
if(sclLock == NULL){
//
// Exit if database cannot be locked
//
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
//
// change the service configuration. Pass in all the changed parameters.
// Since there is but one info level for services, use the
// internal values as parameters.
//
fRetval = ChangeServiceConfig(_schService,
lpqServiceConfig->dwServiceType,
lpqServiceConfig->dwStartType,
lpqServiceConfig->dwErrorControl,
lpqServiceConfig->lpBinaryPathName,
lpqServiceConfig->lpLoadOrderGroup,
NULL,
lpqServiceConfig->lpDependencies,
lpqServiceConfig->lpServiceStartName,
NULL,
lpqServiceConfig->lpDisplayName
);
if (fRetval == FALSE) {
hr = HRESULT_FROM_WIN32(GetLastError());
}
if(SUCCEEDED(hr))
_pPropertyCache->ClearModifiedFlags();
cleanup:
if(lpqServiceConfig){
FreeADsMem(lpqServiceConfig);
}
if(sclLock){
UnlockServiceDatabase(sclLock);
}
WinNTCloseService();
if(pszPath){
FreeADsStr(pszPath);
}
if(pszLoadOrderGroup){
FreeADsStr(pszLoadOrderGroup);
}
if(pszServiceStartName){
FreeADsStr(pszServiceStartName);
}
if(pszDependencies){
FreeADsStr(pszDependencies);
}
if(pszDisplayName){
FreeADsStr(pszDisplayName);
}
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: GetInfo
//
// Synopsis: Currently implemented
//
// Arguments: void
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 12/11/95 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::GetInfo(THIS)
{
RRETURN (GetInfo(1, TRUE));
}
STDMETHODIMP
CWinNTService::ImplicitGetInfo(THIS)
{
RRETURN (GetInfo(1, FALSE));
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::GetInfo
//
// Synopsis: Binds to real Service as specified in _ServiceName and
// attempts to refresh the Service object from the real Service.
//
// Arguments: dwApiLevel (ignored), fExplicit (ignored)
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 01/08/96 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::GetInfo(THIS_ DWORD dwApiLevel, BOOL fExplicit)
{
HRESULT hr;
LPQUERY_SERVICE_CONFIG pMem = NULL;
BYTE FastConfigInfo[256];
SERVICE_STATUS ssStatusInfo;
DWORD dwBufAllocated = 256;
DWORD dwBufNeeded;
DWORD dwLastError;
BOOL fRetval;
//
// GETTING NT SERVICE INFO
//
// Getting information about an NT service requires three calls.
// One to get configuration information, and one to get current
// status information, and one to get security information.
//
//
// Open the service
//
hr = WinNTOpenService(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS,
GENERIC_READ );
if (FAILED(hr)) {
RRETURN_EXP_IF_ERR(hr);
}
//
// Query for Service Status first.
//
fRetval = QueryServiceStatus(_schService,
&ssStatusInfo );
if (fRetval == FALSE) {
hr = HRESULT_FROM_WIN32(GetLastError());
WinNTCloseService();
goto cleanup;
}
fRetval = QueryServiceConfig(_schService,
(LPQUERY_SERVICE_CONFIG)(&FastConfigInfo),
dwBufAllocated,
&dwBufNeeded
);
if (fRetval == FALSE) {
dwLastError = GetLastError();
switch (dwLastError) {
case ERROR_INSUFFICIENT_BUFFER:
//
// Allocate more memory and try again.
//
dwBufAllocated = dwBufNeeded;
pMem = (LPQUERY_SERVICE_CONFIG)AllocADsMem(dwBufAllocated);
if (pMem == NULL) {
hr = E_OUTOFMEMORY;
break;
}
fRetval = QueryServiceConfig(_schService,
pMem,
dwBufAllocated,
&dwBufNeeded
);
if (fRetval == FALSE) {
WinNTCloseService();
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
break;
default:
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
if(FAILED(hr)){
WinNTCloseService();
goto cleanup;
}
}
WinNTCloseService();
//
// clear all properties from cache first if explicit GetInfo
//
if (fExplicit) {
_pPropertyCache->flushpropcache();
}
if(pMem){
hr = UnMarshall(pMem, fExplicit);
BAIL_IF_ERROR(hr);
}else{
hr = UnMarshall((LPQUERY_SERVICE_CONFIG) FastConfigInfo, fExplicit);
BAIL_IF_ERROR(hr);
}
cleanup:
if(pMem)
FreeADsMem(pMem);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTService::UnMarshall(THIS_ LPQUERY_SERVICE_CONFIG lpConfigInfo,
BOOL fExplicit)
{
DWORD dwADsServiceType;
DWORD dwADsStartType;
DWORD dwADsErrorControl;
HRESULT hr;
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("Path"),
lpConfigInfo->lpBinaryPathName,
fExplicit
);
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("LoadOrderGroup"),
lpConfigInfo->lpLoadOrderGroup,
fExplicit
);
hr = SetNulledStringPropertyInCache(_pPropertyCache,
TEXT("Dependencies"),
lpConfigInfo->lpDependencies,
fExplicit
);
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("ServiceAccountName"),
lpConfigInfo->lpServiceStartName,
fExplicit
);
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("DisplayName"),
lpConfigInfo->lpDisplayName,
fExplicit
);
//
// 0x133 is the bit mask for valid values of ADs ServiceTypes
//
dwADsServiceType = lpConfigInfo->dwServiceType & 0x133;
hr = SetDWORDPropertyInCache(_pPropertyCache,
TEXT("ServiceType"),
dwADsServiceType ,
fExplicit
);
hr = SetDWORDPropertyInCache(_pPropertyCache,
TEXT("StartType"),
lpConfigInfo->dwStartType,
fExplicit
);
hr = SetDWORDPropertyInCache(_pPropertyCache,
TEXT("ErrorControl"),
lpConfigInfo->dwErrorControl,
fExplicit
);
hr = SetLPTSTRPropertyInCache(
_pPropertyCache,
TEXT("Name"),
_Name,
fExplicit
);
RRETURN_EXP_IF_ERR(hr);
}
//
// helper function WinNTAddService
//
HRESULT
CWinNTService::WinNTAddService(void)
{
HRESULT hr = S_OK;
SC_HANDLE schService = NULL;
SC_HANDLE schSCManager = NULL;
TCHAR szServerName[MAX_PATH];
BOOL fRetval;
LPTSTR pszDisplayName = NULL;
LPTSTR pszPath = NULL;
LPTSTR pszLoadOrderGroup = NULL;
DWORD dwServiceType;
DWORD dwStartType;
DWORD dwErrorControl;
hr = GetServerFromPath(_ADsPath,szServerName);
BAIL_IF_ERROR(hr);
//
// open the SCM for this server
//
schSCManager = OpenSCManager(szServerName,
NULL,
SC_MANAGER_ALL_ACCESS);
if(schSCManager == NULL){
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("DisplayName"),
&pszDisplayName
);
BAIL_IF_ERROR(hr);
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("ServiceType"),
&dwServiceType
);
BAIL_IF_ERROR(hr);
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("StartType"),
&dwStartType
);
BAIL_IF_ERROR(hr);
hr = GetDWORDPropertyFromCache(
_pPropertyCache,
TEXT("ErrorControl"),
&dwErrorControl
);
BAIL_IF_ERROR(hr);
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("Path"),
&pszPath
);
BAIL_IF_ERROR(hr);
schService = CreateService(schSCManager,
_pszServiceName,
pszDisplayName,
SERVICE_ALL_ACCESS,
dwServiceType,
dwStartType,
dwErrorControl,
pszPath,
NULL,
NULL,
NULL,
NULL,
NULL );
if(schService == NULL){
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
cleanup:
if(schSCManager){
fRetval = CloseServiceHandle(schSCManager);
if(!fRetval && SUCCEEDED(hr)){
RRETURN(HRESULT_FROM_WIN32(GetLastError()));
}
}
if(schService){
fRetval = CloseServiceHandle(schService);
if(!fRetval && SUCCEEDED(hr)){
RRETURN(HRESULT_FROM_WIN32(GetLastError()));
}
}
if(pszDisplayName){
FreeADsStr(pszDisplayName);
}
if(pszPath){
FreeADsStr(pszPath);
}
if(pszLoadOrderGroup){
FreeADsStr(pszLoadOrderGroup);
}
RRETURN(hr);
}
STDMETHODIMP
CWinNTService::get_HostComputer(THIS_ BSTR FAR* retval)
{
HRESULT hr;
if(!retval){
RRETURN_EXP_IF_ERR(E_ADS_BAD_PARAMETER);
}
hr = ADsAllocString(_Parent, retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTService::put_HostComputer(THIS_ BSTR bstrHostComputer)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTService::get_DisplayName(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, DisplayName);
}
STDMETHODIMP
CWinNTService::put_DisplayName(THIS_ BSTR bstrDisplayName)
{
PUT_PROPERTY_BSTR((IADsService *)this, DisplayName);
}
STDMETHODIMP
CWinNTService::get_Version(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, Version);
}
STDMETHODIMP
CWinNTService::put_Version(THIS_ BSTR bstrVersion)
{
PUT_PROPERTY_BSTR((IADsService *)this, Version);
}
STDMETHODIMP
CWinNTService::get_ServiceType(THIS_ long FAR* retval)
{
GET_PROPERTY_LONG((IADsService *)this, ServiceType);
}
STDMETHODIMP
CWinNTService::put_ServiceType(THIS_ long lServiceType)
{
PUT_PROPERTY_LONG((IADsService *)this, ServiceType);
}
STDMETHODIMP
CWinNTService::get_StartType(THIS_ LONG FAR* retval)
{
GET_PROPERTY_LONG((IADsService *)this, StartType);
}
STDMETHODIMP
CWinNTService::put_StartType(THIS_ LONG lStartType)
{
PUT_PROPERTY_LONG((IADsService *)this, StartType);
}
STDMETHODIMP
CWinNTService::get_Path(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, Path);
}
STDMETHODIMP
CWinNTService::put_Path(THIS_ BSTR bstrPath)
{
PUT_PROPERTY_BSTR((IADsService *)this, Path);
}
STDMETHODIMP
CWinNTService::get_StartupParameters(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, StartupParameters);
}
STDMETHODIMP
CWinNTService::put_StartupParameters(THIS_ BSTR bstrStartupParameters) {
PUT_PROPERTY_BSTR((IADsService *)this, StartupParameters);
}
STDMETHODIMP
CWinNTService::get_ErrorControl(THIS_ LONG FAR* retval)
{
GET_PROPERTY_LONG((IADsService *)this, ErrorControl);
}
STDMETHODIMP
CWinNTService::put_ErrorControl(THIS_ LONG lErrorControl)
{
PUT_PROPERTY_LONG((IADsService *)this, ErrorControl);
}
STDMETHODIMP
CWinNTService::get_LoadOrderGroup(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, LoadOrderGroup);
}
STDMETHODIMP
CWinNTService::put_LoadOrderGroup(THIS_ BSTR bstrLoadOrderGroup)
{
PUT_PROPERTY_BSTR((IADsService *)this, LoadOrderGroup);
}
STDMETHODIMP
CWinNTService::get_ServiceAccountName(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsService *)this, ServiceAccountName);
}
STDMETHODIMP
CWinNTService::put_ServiceAccountName(THIS_ BSTR bstrServiceAccountName)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTService::get_ServiceAccountPath(THIS_ BSTR FAR* retval)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTService::put_ServiceAccountPath(THIS_ BSTR bstrServiceAccountName)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTService::get_Dependencies(THIS_ VARIANT FAR* retval)
{
GET_PROPERTY_VARIANT((IADsService *)this, Dependencies);
}
STDMETHODIMP
CWinNTService::put_Dependencies(THIS_ VARIANT vDependencies)
{
PUT_PROPERTY_VARIANT((IADsService *)this, Dependencies);
}
STDMETHODIMP
CWinNTService::SetPassword(THIS_ BSTR bstrNewPassword)
{
//
// This routine should merely change password. Even if any other
// properties are set in the configuration functional set then they
// will not be touched.
// Therefore we do a QueryServiceConfig and get all the configuration
// related information, merely change the password and send it back.
// For this reason, it is not possible to reuse GetInfo or SetInfo
// because they change service config properties.
//
BOOL fRetval;
LPQUERY_SERVICE_CONFIG pMem = NULL;
HRESULT hr;
hr = WinNTOpenService(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS,
SERVICE_ALL_ACCESS);
BAIL_IF_ERROR(hr);
hr = GetServiceConfigInfo(&pMem);
BAIL_IF_ERROR(hr);
//
// just change the field corresponding to password.
//
fRetval = ChangeServiceConfig(_schService,
pMem->dwServiceType,
pMem->dwStartType,
pMem->dwErrorControl,
pMem->lpBinaryPathName,
pMem->lpLoadOrderGroup,
NULL,
pMem->lpDependencies,
pMem->lpServiceStartName,
(LPTSTR)bstrNewPassword,
pMem->lpDisplayName
);
if(!fRetval){
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
cleanup:
if(pMem){
FreeADsMem(pMem);
}
WinNTCloseService();
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::Start
//
// Synopsis: Attempts to start the service specified in _bstrServiceName on
// the server named in _bstrPath.
//
// Arguments:
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 01/04/96 RamV Created
//
// Notes:
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::Start(THIS)
{
HRESULT hr;
hr = WinNTControlService(WINNT_START_SERVICE);
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::Stop
//
// Synopsis: Attempts to stop the service specified in _bstrServiceName on
// the server named in _bstrPath.
//
// Arguments:
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 01/04/96 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::Stop(THIS)
{
HRESULT hr;
hr = WinNTControlService(WINNT_STOP_SERVICE);
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::Pause
//
// Synopsis: Attempts to pause the service named _bstrServiceName on the
// server named in _bstrPath.
//
// Arguments:
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 01-04-96 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::Pause(THIS)
{
HRESULT hr;
hr = WinNTControlService(WINNT_PAUSE_SERVICE);
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::Continue
//
// Synopsis: Attempts to "unpause" the service specified in _bstrServiceName
// on the server named in _bstrPath.
//
// Arguments:
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 01/04/96 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTService::Continue(THIS)
{
HRESULT hr;
hr = WinNTControlService(WINNT_CONTINUE_SERVICE);
RRETURN_EXP_IF_ERR(hr);
}
//
// Helper Functions
//
HRESULT
CWinNTService::GetServiceConfigInfo(LPQUERY_SERVICE_CONFIG *ppMem)
{
//
//gets the service configuration information into ppMem
//
BOOL fRetval;
DWORD dwBufAllocated = 0;
DWORD dwBufNeeded = 0;
DWORD dwLastError;
HRESULT hr = S_OK;
ADsAssert(ppMem);
*ppMem = (LPQUERY_SERVICE_CONFIG)AllocADsMem(dwBufAllocated);
if (*ppMem == NULL){
hr = E_OUTOFMEMORY;
goto cleanup;
}
ADsAssert(_schService);
fRetval = QueryServiceConfig(_schService,
(LPQUERY_SERVICE_CONFIG)(*ppMem),
dwBufAllocated,
&dwBufNeeded);
if (fRetval == FALSE) {
dwLastError = GetLastError();
switch (dwLastError) {
case ERROR_INSUFFICIENT_BUFFER:
//
// Allocate more memory and try again.
//
FreeADsMem(*ppMem);
*ppMem = NULL;
dwBufAllocated = dwBufNeeded;
*ppMem = (LPQUERY_SERVICE_CONFIG)AllocADsMem(dwBufAllocated);
if (*ppMem == NULL) {
BAIL_IF_ERROR(hr = E_OUTOFMEMORY);
}
fRetval = QueryServiceConfig(_schService,
*ppMem,
dwBufAllocated,
&dwBufNeeded);
if (fRetval == FALSE) {
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
break;
default:
hr = HRESULT_FROM_WIN32(GetLastError());
break;
}
BAIL_IF_ERROR(hr);
}
if(*ppMem){
RRETURN(S_OK);
}
cleanup:
RRETURN(hr);
}
HRESULT
CWinNTService::WinNTControlService( DWORD dwControl)
{
//
// abstracts out the common code of Start,Stop,Pause and Resume
//
HRESULT hr =S_OK, hrclose=S_OK, hrcontrol=S_OK;
SERVICE_STATUS ssStatusInfo;
BOOL fRetval;
if(_fValidHandle){
//
// an open handle exists, blow it away
//
hrclose = WinNTCloseService();
BAIL_ON_FAILURE(hrclose);
_fValidHandle = FALSE;
}
hr = WinNTOpenService(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS,
GENERIC_EXECUTE| SERVICE_INTERROGATE
);
BAIL_ON_FAILURE(hr);
_fValidHandle = TRUE;
switch(dwControl){
case WINNT_START_SERVICE:
fRetval = StartService(_schService,
0,
NULL );
if(!fRetval){
hrcontrol = HRESULT_FROM_WIN32(GetLastError());
goto error;
}
_dwOpPending = PENDING_START;
break;
case WINNT_STOP_SERVICE:
fRetval = ControlService(_schService,
SERVICE_CONTROL_STOP,
&ssStatusInfo);
if(!fRetval){
hrcontrol = HRESULT_FROM_WIN32(GetLastError());
goto error;
}
_dwOpPending = PENDING_STOP;
break;
case WINNT_PAUSE_SERVICE:
fRetval = ControlService(_schService,
SERVICE_CONTROL_PAUSE,
&ssStatusInfo);
if(!fRetval){
hrcontrol = HRESULT_FROM_WIN32(GetLastError());
goto error;
}
_dwOpPending = PENDING_PAUSE;
break;
case WINNT_CONTINUE_SERVICE:
fRetval = ControlService(_schService,
SERVICE_CONTROL_CONTINUE,
&ssStatusInfo);
if(!fRetval){
hrcontrol = HRESULT_FROM_WIN32(GetLastError());
goto error;
}
_dwOpPending = PENDING_CONTINUE;
break;
default:
hrcontrol = E_FAIL;
goto error;
}
_dwTimeStarted = GetTickCount();
_dwWaitHint = 10000; //10 seconds
_dwCheckPoint = 0;
RRETURN(S_OK);
error:
if(FAILED(hrcontrol)){
_fValidHandle = FALSE;
RRETURN(hrcontrol);
}
else if(FAILED(hrclose)){
RRETURN(hrclose);
}
else{
RRETURN(hr);
}
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::WinNTOpenService
//
// Synopsis: Opens the Service Control Manager on the machine specified in
// _bstrPath, then opens the Service specified in _bstrServiceName.
// The handle to the SCM is placed in _schSCManager, and the
// handle to the service is placed in _schService.
//
// Arguments: [dwSCMDesiredAccess] -- type of SCM access needed
// [dwSvrDesiredAccess] -- type of Service access required
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 03-17-95 t-skwan Created
// 01/04/96 RamV Modified
//
//----------------------------------------------------------------------------
HRESULT
CWinNTService::WinNTOpenService(
DWORD dwSCMDesiredAccess,
DWORD dwSvrDesiredAccess
)
{
HRESULT hr;
DWORD dwLastError;
//
// Open the Service Control Manager.
//
//
// OpenSCManager(
// LPCTSTR lpszMachineName,
// LPCTSTR lpszDatabaseName.
// DWORD fdwDesiredAccess)
//
_schSCManager = OpenSCManager(_pszServerName,
NULL,
dwSCMDesiredAccess);
if (_schSCManager == NULL) {
dwLastError = GetLastError();
hr = HRESULT_FROM_WIN32(dwLastError);
RRETURN(hr);
}
//
// Get a handle to the specified service.
//
_schService = OpenService(_schSCManager,
_pszServiceName,
dwSvrDesiredAccess);
if(_schService == NULL) {
hr = HRESULT_FROM_WIN32(GetLastError());
CloseServiceHandle(_schSCManager);
_schSCManager = NULL;
RRETURN(hr);
}
RRETURN(S_OK);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTService::WinNTCloseService
//
// Synopsis: Closes the Service handle and the Service Control Manager
// handle.
//
// Arguments:
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 03-17-95 t-skwan Created
// 01/04/96 RamV Modified
//
//----------------------------------------------------------------------------
HRESULT
CWinNTService::WinNTCloseService()
{
BOOL fRetval = TRUE;
//
// Close the Service handle.
//
if(_schService){
fRetval = CloseServiceHandle(_schService);
_schService = NULL;
}
if (!fRetval) {
//
// Ack. What do we do if there is an error closing a service?
//
RRETURN(HRESULT_FROM_WIN32(GetLastError()));
}
//
// Close the Service Control Manager.
//
if(_schSCManager){
fRetval = CloseServiceHandle(_schSCManager);
_schSCManager = NULL;
}
if (!fRetval) {
//
// Ack. What do we do if there is an error closing an SCM?
//
RRETURN(HRESULT_FROM_WIN32(GetLastError()));
}
RRETURN(S_OK);
}
STDMETHODIMP
CWinNTService::get_Status(THIS_ long FAR* plStatusCode)
{
HRESULT hr = S_OK;
BOOL fRetval = FALSE, found = FALSE;
SERVICE_STATUS Status;
DWORD dwStatus = 0;
if(plStatusCode == NULL){
RRETURN_EXP_IF_ERR(E_POINTER);
}
*plStatusCode = -1; //-1 is an invalid code
if(!(_fValidHandle)){
//
// currently not waiting on any service
//
hr = WinNTOpenService(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS,
GENERIC_EXECUTE|SERVICE_INTERROGATE);
BAIL_IF_ERROR(hr);
fRetval = ControlService(_schService,
SERVICE_CONTROL_INTERROGATE,
&Status);
if(!fRetval){
hr = HRESULT_FROM_WIN32(GetLastError());
if(hr == HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE)){
dwStatus = SERVICE_STOPPED;
hr = S_OK;
}
goto cleanup;
}
dwStatus = Status.dwCurrentState;
hr = WinNTCloseService();
goto cleanup;
}
//
// if you are here
// you are waiting for a service to complete
//
//
// NOTE: QueryServiceStatus queries the SCM rather than
// the service directly so to get a more upto date answer
// we need to use control service with interrogate option
//
hr = WinNTOpenService(SC_MANAGER_CONNECT | SC_MANAGER_ENUMERATE_SERVICE | SC_MANAGER_QUERY_LOCK_STATUS,
GENERIC_EXECUTE|SERVICE_INTERROGATE);
BAIL_IF_ERROR(hr);
fRetval = ControlService(_schService,
SERVICE_CONTROL_INTERROGATE,
&Status);
if(!fRetval){
hr = HRESULT_FROM_WIN32(GetLastError());
if(hr == HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE)){
dwStatus = SERVICE_STOPPED;
hr = S_OK;
}
goto cleanup;
}
hr = EvalPendingOperation(PENDING_START,
SERVICE_RUNNING,
SERVICE_START_PENDING,
&Status,
&dwStatus
);
BAIL_IF_ERROR(hr);
if(dwStatus != 0){
//
// the correct scenario was found
//
goto cleanup;
}
hr = EvalPendingOperation(PENDING_STOP,
SERVICE_STOPPED,
SERVICE_STOP_PENDING,
&Status,
&dwStatus
);
BAIL_IF_ERROR(hr);
if(dwStatus != 0){
//
// the correct scenario was found
//
goto cleanup;
}
hr = EvalPendingOperation(PENDING_PAUSE,
SERVICE_PAUSED,
SERVICE_PAUSE_PENDING,
&Status,
&dwStatus
);
BAIL_IF_ERROR(hr);
if(dwStatus != 0){
//
// the correct scenario was found
//
goto cleanup;
}
hr = EvalPendingOperation(PENDING_CONTINUE,
SERVICE_RUNNING,
SERVICE_CONTINUE_PENDING,
&Status,
&dwStatus
);
BAIL_IF_ERROR(hr);
ADsAssert(dwStatus != 0); //we must find the appropriate scenario
cleanup:
if(SUCCEEDED(hr)){
//
// instead of a conversion routine, we return WinNT Status Code
//
*plStatusCode = dwStatus;
}
RRETURN_EXP_IF_ERR(hr);
}
HRESULT
CWinNTService::EvalPendingOperation(
THIS_ DWORD dwOpPending,
DWORD dwStatusDone,
DWORD dwStatusPending,
LPSERVICE_STATUS pStatus,
DWORD *pdwRetval
)
{
DWORD dwCurrentStatus;
BOOL fRetval;
HRESULT hr =S_OK;
DWORD dwNow;
dwCurrentStatus = pStatus->dwCurrentState;
if(_dwOpPending == dwOpPending){
if(dwCurrentStatus == dwStatusDone){
//
//was pending, is now completed
//
_dwOpPending = NOTPENDING;
*pdwRetval = dwStatusDone;
hr = WinNTCloseService();
BAIL_ON_FAILURE(hr);
_fValidHandle = FALSE;
RRETURN(S_OK);
}
else if(dwCurrentStatus = dwStatusPending){
//
//see if progress has been made since the last time we checked
//
if(pStatus->dwCheckPoint !=_dwCheckPoint){
//
// progress was made
//
*pdwRetval = dwStatusPending;
_dwCheckPoint = pStatus->dwCheckPoint;
_dwWaitHint = pStatus->dwWaitHint;
_dwTimeStarted = GetTickCount();
RRETURN(S_OK);
}
dwNow = GetTickCount();
if(2*_dwWaitHint < TickCountDiff(dwNow,_dwTimeStarted)){
//
// you can still wait
//
*pdwRetval = dwStatusPending;
RRETURN(S_OK);
}
else{
//
// took too long without signs of progress
//
*pdwRetval = SERVICE_ERROR;
_dwOpPending = NOTPENDING;
hr = WinNTCloseService();
BAIL_ON_FAILURE(hr);
_fValidHandle = FALSE;
RRETURN(S_OK);
}
}
else{
//
// an operation is pending but we arent going anywhere
// recover gracefully
//
_dwOpPending = NOTPENDING;
hr = WinNTCloseService();
BAIL_ON_FAILURE(hr);
_fValidHandle = FALSE;
*pdwRetval = SERVICE_ERROR;
RRETURN(S_OK);
}
}
error:
RRETURN(hr);
}
Reference in a new issue Copy permalink