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

1511 lines
35 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: cfserv.cxx
//
// Contents: Contains methods for the following objects
// CWinNTFileService and CWinNTFileServiceGeneralInfo.
//
//
// History: 12/11/95 ramv (Ram Viswanathan) Created.
//
//----------------------------------------------------------------------------
#include "winnt.hxx"
#pragma hdrstop
#define INITGUID
//
// class CWinNTFileService methods
//
DEFINE_IDispatch_ExtMgr_Implementation(CWinNTFileService);
DEFINE_IADsExtension_ExtMgr_Implementation(CWinNTFileService);
DEFINE_IADs_TempImplementation(CWinNTFileService);
DEFINE_IADsPropertyList_Implementation(CWinNTFileService, FileServiceClass, gdwFileServiceTableSize)
CWinNTFileService::CWinNTFileService()
{
_pDispMgr = NULL;
_pExtMgr = NULL;
_pService = NULL;
_pServiceOps = NULL;
_pszServerName = NULL;
VariantInit(&_vFilter);
_pPropertyCache = NULL;
ENLIST_TRACKING(CWinNTFileService);
return;
}
CWinNTFileService::~CWinNTFileService()
{
if(_pService){
_pService->Release();
}
if (_pServiceOps) {
_pServiceOps->Release();
}
delete _pExtMgr; // created last, destroyed first
delete _pDispMgr;
if(_pszServerName){
FreeADsStr(_pszServerName);
}
VariantClear(&_vFilter);
delete _pPropertyCache;
return;
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTFileService::CreateFileService
//
// Synopsis: Static function used to create a FileService object. This
// will be called by BindToObject
//
// Arguments: [ppWinNTFileService] -- Ptr to a ptr to a new Service object.
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 12-11-95 RamV Created.
//
//----------------------------------------------------------------------------
HRESULT
CWinNTFileService::CreateFileService(LPTSTR pszADsParent,
DWORD dwParentId,
LPTSTR pszDomainName,
LPTSTR pszServerName,
LPTSTR pszFileServiceName,
DWORD dwObjectState,
REFIID riid,
CWinNTCredentials& Credentials,
LPVOID * ppvoid
)
{
CWinNTFileService FAR * pCWinNTFileService = NULL;
HRESULT hr = S_OK;
//
// Create the FileService Object
//
hr = AllocateFileServiceObject(&pCWinNTFileService);
BAIL_ON_FAILURE(hr);
ADsAssert(pCWinNTFileService->_pDispMgr);
hr = pCWinNTFileService->InitializeCoreObject(pszADsParent,
pszFileServiceName,
FILESERVICE_CLASS_NAME,
FILESERVICE_SCHEMA_NAME,
CLSID_WinNTFileService,
dwObjectState);
BAIL_ON_FAILURE(hr);
pCWinNTFileService->_Credentials = Credentials;
hr = pCWinNTFileService->_Credentials.Ref(pszServerName,
pszDomainName, dwParentId);
BAIL_ON_FAILURE(hr);
hr = CWinNTService::Create(pszADsParent,
pszDomainName,
pszServerName,
pszFileServiceName,
dwObjectState,
IID_IADsService,
pCWinNTFileService->_Credentials,
(void **)(&(pCWinNTFileService->_pService)));
BAIL_ON_FAILURE(hr);
hr = (pCWinNTFileService->_pService)->QueryInterface(
IID_IADsServiceOperations,
(void **)&(pCWinNTFileService->_pServiceOps));
BAIL_ON_FAILURE(hr);
pCWinNTFileService->_pszServerName =
AllocADsStr(pszServerName);
if(!(pCWinNTFileService->_pszServerName)){
hr = E_OUTOFMEMORY;
goto error;
}
//
// Load ext mgr and extensions
//
hr = ADSILoadExtensionManager(
FILESERVICE_CLASS_NAME,
(IADsFileService *) pCWinNTFileService,
pCWinNTFileService->_pDispMgr,
Credentials,
&pCWinNTFileService->_pExtMgr
);
BAIL_ON_FAILURE(hr);
ADsAssert(pCWinNTFileService->_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 == pCWinNTFileService->_dwNumComponents) {
pCWinNTFileService->_CompClasses[0] = L"Domain";
pCWinNTFileService->_CompClasses[1] = L"Computer";
pCWinNTFileService->_CompClasses[2] = L"FileService";
}
else
BAIL_ON_FAILURE(hr = UMI_E_FAIL);
hr = pCWinNTFileService->InitUmiObject(
pCWinNTFileService->_Credentials,
FileServiceClass,
gdwFileServiceTableSize,
pCWinNTFileService->_pPropertyCache,
(IUnknown *) (INonDelegatingUnknown *) pCWinNTFileService,
pCWinNTFileService->_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 = pCWinNTFileService->QueryInterface(riid,
(void **)ppvoid);
BAIL_ON_FAILURE(hr);
pCWinNTFileService->Release();
RRETURN(hr);
error:
delete pCWinNTFileService;
RRETURN_EXP_IF_ERR(hr);
}
HRESULT
CWinNTFileService::AllocateFileServiceObject(
CWinNTFileService ** ppFileService
)
{
CWinNTFileService FAR * pFileService = NULL;
HRESULT hr = S_OK;
pFileService = new CWinNTFileService();
if (pFileService == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
pFileService->_pDispMgr = new CAggregatorDispMgr;
if (pFileService->_pDispMgr == NULL) {
hr = E_OUTOFMEMORY;
}
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(pFileService->_pDispMgr,
LIBID_ADs,
IID_IADsFileService,
(IADsFileService *)pFileService,
DISPID_REGULAR);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(pFileService->_pDispMgr,
LIBID_ADs,
IID_IADsContainer,
(IADsContainer *)pFileService,
DISPID_NEWENUM);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(
pFileService->_pDispMgr,
LIBID_ADs,
IID_IADsFileServiceOperations,
(IADsFileServiceOperations *)pFileService,
DISPID_REGULAR
);
BAIL_ON_FAILURE(hr);
hr = LoadTypeInfoEntry(
pFileService->_pDispMgr,
LIBID_ADs,
IID_IADsPropertyList,
(IADsPropertyList *)pFileService,
DISPID_VALUE
);
BAIL_ON_FAILURE(hr);
hr = CPropertyCache::createpropertycache(
FileServiceClass,
gdwFileServiceTableSize,
(CCoreADsObject *)pFileService,
&(pFileService->_pPropertyCache)
);
BAIL_ON_FAILURE(hr);
(pFileService->_pDispMgr)->RegisterPropertyCache(
pFileService->_pPropertyCache
);
*ppFileService = pFileService;
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 pFileService;
RRETURN(hr);
}
/* IUnknown methods for file 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 CWinNTFileService::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) CWinNTFileService::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) CWinNTFileService::Release(void)
{
if(_pUnkOuter != NULL)
RRETURN(_pUnkOuter->Release());
RRETURN(NonDelegatingRelease());
}
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTFileService::NonDelegatingQueryInterface(REFIID riid, LPVOID FAR* ppvObj)
{
HRESULT hr = S_OK;
if(!ppvObj){
RRETURN(E_POINTER);
}
if (IsEqualIID(riid, IID_IUnknown))
{
*ppvObj = (IADsFileService*)this;
}
else if (IsEqualIID(riid, IID_IDispatch))
{
*ppvObj = (IADsFileService *)this;
}
else if (IsEqualIID(riid, IID_ISupportErrorInfo))
{
*ppvObj = (ISupportErrorInfo FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsFileServiceOperations))
{
*ppvObj = (IADsFileServiceOperations *)this;
}
else if (IsEqualIID(riid, IID_IADsServiceOperations))
{
*ppvObj = (IADsFileServiceOperations *)this;
}
else if (IsEqualIID(riid, IID_IADs))
{
*ppvObj = (IADsFileService FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsFileService))
{
*ppvObj = (IADsFileService FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsPropertyList))
{
*ppvObj = (IADsPropertyList FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsService))
{
*ppvObj = (IADsService FAR *) this;
}
else if (IsEqualIID(riid, IID_IADsContainer))
{
*ppvObj = (IADsContainer 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
CWinNTFileService::InterfaceSupportsErrorInfo(
THIS_ REFIID riid
)
{
if (IsEqualIID(riid, IID_IADs) ||
IsEqualIID(riid, IID_IADsService) ||
IsEqualIID(riid, IID_IADsFileService) ||
IsEqualIID(riid, IID_IADsServiceOperations) ||
IsEqualIID(riid, IID_IADsFileServiceOperations) ||
IsEqualIID(riid, IID_IADsContainer) ||
IsEqualIID(riid, IID_IADsPropertyList)) {
RRETURN(S_OK);
} else {
RRETURN(S_FALSE);
}
}
//+---------------------------------------------------------------------------
//
// Function: SetInfo
//
// Synopsis:
//
// Arguments: void
//
// Returns: HRESULT.
//
// Modifies:
//
// History: RamV Created
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTFileService::SetInfo(THIS)
{
HRESULT hr;
IADsService * pADsService = NULL;
ADsAssert(_pService);
hr = _pService->SetInfo();
BAIL_IF_ERROR(hr);
hr = SetLevel1005Info();
if(SUCCEEDED(hr))
_pPropertyCache->ClearModifiedFlags();
cleanup:
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: GetInfo
//
// Synopsis:
//
// Arguments: void
//
// Returns: HRESULT.
//
// Modifies:
//
// History: 12/11/95 RamV Created
//
//----------------------------------------------------------------------------
STDMETHODIMP
CWinNTFileService::GetInfo(THIS)
{
HRESULT hr =S_OK;
hr = GetInfo(1, TRUE);
if(FAILED(hr))
RRETURN_EXP_IF_ERR(hr);
hr = GetInfo(2,TRUE);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::ImplicitGetInfo(THIS)
{
HRESULT hr =S_OK;
hr = GetInfo(1, FALSE);
if(FAILED(hr))
RRETURN_EXP_IF_ERR(hr);
hr = GetInfo(2,FALSE);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::GetInfo(THIS_ DWORD dwApiLevel, BOOL fExplicit)
{
HRESULT hr =S_OK;
switch(dwApiLevel){
case 1:
ADsAssert(_pService);
hr = _pService->GetInfo();
BAIL_IF_ERROR(hr);
break;
case 2:
hr = GetLevel101Info(fExplicit);
BAIL_IF_ERROR(hr);
break;
default:
ADsAssert(FALSE);
break;
}
cleanup:
RRETURN (hr);
}
STDMETHODIMP
CWinNTFileService::SetLevel1005Info(THIS)
{
SERVER_INFO_1005 ServerInfo;
NET_API_STATUS nasStatus;
HRESULT hr = S_OK;
LPTSTR pszDescription = NULL;
memset(&ServerInfo, 0, sizeof(ServerInfo));
hr = GetLPTSTRPropertyFromCache(
_pPropertyCache,
TEXT("Description"),
&pszDescription
);
if(SUCCEEDED(hr)){
ServerInfo.sv1005_comment = pszDescription;
}
nasStatus = NetServerSetInfo(_pszServerName,
1005,
(LPBYTE)(&ServerInfo),
NULL
);
hr = HRESULT_FROM_WIN32(nasStatus);
if(pszDescription){
FreeADsStr(pszDescription);
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::GetLevel101Info(THIS_ BOOL fExplicit)
{
//
// here we do a NetServerGetInfo on level101 and then unmarshall the
// comment field into description
//
NET_API_STATUS nasStatus;
LPSERVER_INFO_101 lpServerInfo =NULL;
HRESULT hr;
//
// level 101 is available with user permissions,
// Level 1005 is preferable but exists only in LanMan 2.0
//
nasStatus = NetServerGetInfo(_pszServerName,
101,
(LPBYTE *)&lpServerInfo
);
hr = HRESULT_FROM_WIN32(nasStatus);
BAIL_IF_ERROR(hr);
//
// unmarshall the info into the Description field
//
ADsAssert(lpServerInfo);
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("Description"),
lpServerInfo->sv101_comment,
fExplicit
);
hr = SetLPTSTRPropertyInCache(_pPropertyCache,
TEXT("HostComputer"),
_Parent,
fExplicit
);
hr = SetDWORDPropertyInCache(_pPropertyCache,
TEXT("MaxUserCount"),
(DWORD)-1,
fExplicit
);
hr = SetLPTSTRPropertyInCache(
_pPropertyCache,
TEXT("Name"),
_Name,
fExplicit
);
hr = S_OK;
cleanup:
if(lpServerInfo)
NetApiBufferFree(lpServerInfo);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::Get(
THIS_ BSTR bstrName,
VARIANT FAR* pvProp
)
{
HRESULT hr = S_OK;
hr= _pService->Get(bstrName, pvProp );
if(FAILED(hr)){
hr = GenericGetPropertyManager(
_pPropertyCache,
bstrName,
pvProp
);
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::Put(
THIS_ BSTR bstrName,
VARIANT vProp
)
{
HRESULT hr = S_OK;
hr= _pService->Put(bstrName, vProp );
if(FAILED(hr)){
hr = GenericPutPropertyManager(_pPropertyCache,
FileServiceClass,
gdwFileServiceTableSize,
bstrName,
vProp);
}
RRETURN_EXP_IF_ERR(hr);
}
//
// IADsService Methods
//
/* IADsContainer methods */
STDMETHODIMP
CWinNTFileService::get_Count(long FAR* retval)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTFileService::get_Filter(THIS_ VARIANT FAR* pVar)
{
HRESULT hr;
VariantInit(pVar);
hr = VariantCopy(pVar, &_vFilter);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_Filter(THIS_ VARIANT Var)
{
HRESULT hr;
RRETURN(VariantCopy(&_vFilter, &Var));
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::GetObject(THIS_ BSTR ClassName,
BSTR RelativeName,
IDispatch * FAR* ppObject
)
{
HRESULT hr;
DWORD dwObjectType;
POBJECTINFO pObjectInfo = NULL;
hr = GetObjectType(gpFilters,
gdwMaxFilters,
ClassName,
(PDWORD)&dwObjectType
);
BAIL_IF_ERROR(hr);
if(dwObjectType != WINNT_FILESHARE_ID){
//
// trying to create an invalid object at this level
//
hr = E_FAIL;
goto error;
}
hr = BuildObjectInfo(_ADsPath,
RelativeName,
&pObjectInfo
);
BAIL_ON_FAILURE(hr);
hr = ValidateObject(dwObjectType,
pObjectInfo,
_Credentials
);
BAIL_ON_FAILURE(hr);
//
// The only object that has a file service as a container is
// a file share object
//
hr = CWinNTFileShare::Create(_ADsPath,
pObjectInfo->ComponentArray[1],
pObjectInfo->ComponentArray[2],
RelativeName,
ADS_OBJECT_UNBOUND,
IID_IDispatch,
_Credentials,
(void**)ppObject
);
BAIL_ON_FAILURE(hr);
error:
cleanup:
FreeObjectInfo(pObjectInfo);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get__NewEnum(THIS_ IUnknown * FAR* retval)
{
HRESULT hr = S_OK;
CWinNTFileSharesEnumVar *pCFileSharesEnumVar = NULL;
if(!retval){
RRETURN_EXP_IF_ERR(E_POINTER);
}
*retval = NULL;
hr = CWinNTFileSharesEnumVar::Create(_pszServerName,
_ADsPath,
&pCFileSharesEnumVar,
_vFilter,
_Credentials);
BAIL_ON_FAILURE(hr);
ADsAssert(pCFileSharesEnumVar);
hr = pCFileSharesEnumVar->QueryInterface(IID_IUnknown,
(void **)retval);
BAIL_ON_FAILURE(hr);
pCFileSharesEnumVar->Release();
RRETURN(hr);
error:
delete pCFileSharesEnumVar;
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::Create(THIS_ BSTR ClassName,
BSTR RelativeName,
IDispatch * FAR* ppObject
)
{
DWORD dwObjectType = 0;
HRESULT hr = S_OK;
POBJECTINFO pObjectInfo = NULL;
hr = GetObjectType(gpFilters,
gdwMaxFilters,
ClassName,
(PDWORD)&dwObjectType
);
BAIL_IF_ERROR(hr);
if(dwObjectType != WINNT_FILESHARE_ID){
//
// trying to create an invalid object at this level
//
hr = E_FAIL;
goto error;
}
hr = BuildObjectInfo(_ADsPath,
RelativeName,
&pObjectInfo
);
BAIL_ON_FAILURE(hr);
hr = ValidateObject(dwObjectType,
pObjectInfo,
_Credentials
);
if(SUCCEEDED(hr)){
hr = E_ADS_OBJECT_EXISTS;
goto error;
}
//
// The only object that has a file service as a container is
// a file share object
hr = CWinNTFileShare::Create(_ADsPath,
pObjectInfo->ComponentArray[1],
pObjectInfo->ComponentArray[2],
RelativeName,
ADS_OBJECT_UNBOUND,
IID_IDispatch,
_Credentials,
(void**)ppObject
);
BAIL_ON_FAILURE(hr);
error:
cleanup:
FreeObjectInfo(pObjectInfo);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::Delete(THIS_ BSTR Type,
BSTR SourceName
)
{
HRESULT hr;
DWORD dwObjectType = 0;
POBJECTINFO pObjectInfo = NULL;
// Make sure the input parameters are valid
if (Type == NULL || SourceName == NULL) {
RRETURN_EXP_IF_ERR(hr = E_ADS_BAD_PARAMETER);
}
hr = GetObjectType(gpFilters,
gdwMaxFilters,
Type,
(PDWORD)&dwObjectType
);
BAIL_IF_ERROR(hr);
if(dwObjectType != WINNT_FILESHARE_ID){
//
// trying to delete an invalid object at this level
//
hr = E_FAIL;
goto cleanup;
}
hr = BuildObjectInfo(_ADsPath,
SourceName,
&pObjectInfo
);
BAIL_IF_ERROR(hr);
hr = WinNTDeleteFileShare(pObjectInfo);
cleanup:
FreeObjectInfo(pObjectInfo);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_Hints(THIS_ VARIANT Var)
{
RRETURN_EXP_IF_ERR( E_NOTIMPL);
}
STDMETHODIMP
CWinNTFileService::get_Hints(THIS_ VARIANT FAR* pVar)
{
RRETURN_EXP_IF_ERR(E_NOTIMPL);
}
STDMETHODIMP
CWinNTFileService::CopyHere(THIS_ BSTR SourceName,
BSTR NewName,
IDispatch * FAR* ppObject
)
{
RRETURN_EXP_IF_ERR(E_NOTIMPL);
}
STDMETHODIMP
CWinNTFileService::MoveHere(THIS_ BSTR SourceName,
BSTR NewName,
IDispatch * FAR* ppObject
)
{
RRETURN_EXP_IF_ERR(E_NOTIMPL);
}
STDMETHODIMP
CWinNTFileService::get_Description(THIS_ BSTR FAR* retval)
{
GET_PROPERTY_BSTR((IADsFileService *)this, Description);
}
STDMETHODIMP
CWinNTFileService::put_Description(THIS_ BSTR bstrDescription)
{
PUT_PROPERTY_BSTR((IADsFileService *)this, Description);
}
STDMETHODIMP
CWinNTFileService::get_MaxUserCount(THIS_ long FAR* retval)
{
//
// here -1 signifies no limit
//
if(!retval){
RRETURN_EXP_IF_ERR(E_POINTER);
}
*retval = -1;
RRETURN(S_OK);
}
STDMETHODIMP CWinNTFileService::put_MaxUserCount(THIS_ long lnMaxUserCount)
{
RRETURN_EXP_IF_ERR(E_ADS_PROPERTY_NOT_SUPPORTED);
}
STDMETHODIMP
CWinNTFileService::Sessions(THIS_ IADsCollection FAR* FAR* ppSessions)
{
//
// The session collection object is created and it is passed the server
// name. It uses this to create the session object
//
HRESULT hr = S_OK;
CWinNTSessionsCollection * pSessionsCollection = NULL;
if(!ppSessions){
RRETURN_EXP_IF_ERR(E_POINTER);
}
hr = CWinNTSessionsCollection::Create(_ADsPath,
NULL,
NULL,
_Credentials,
&pSessionsCollection
);
BAIL_IF_ERROR(hr);
hr = pSessionsCollection->QueryInterface(IID_IADsCollection,
(void **) ppSessions);
BAIL_IF_ERROR(hr);
pSessionsCollection->Release();
cleanup:
if(FAILED(hr)){
delete pSessionsCollection;
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::Resources(THIS_ IADsCollection FAR* FAR* ppResources)
{
//
// The resource collection object is created and it is passed the server
// name. It uses this to create the resource object
//
HRESULT hr = S_OK;
CWinNTResourcesCollection * pResourcesCollection = NULL;
if(!ppResources){
RRETURN_EXP_IF_ERR(E_POINTER);
}
hr = CWinNTResourcesCollection::Create(_ADsPath,
NULL,
NULL,
_Credentials,
&pResourcesCollection
);
BAIL_IF_ERROR(hr);
hr = pResourcesCollection->QueryInterface(IID_IADsCollection,
(void **) ppResources
);
BAIL_IF_ERROR(hr);
pResourcesCollection->Release();
cleanup:
if(FAILED(hr)){
delete pResourcesCollection;
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_HostComputer(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_HostComputer(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_HostComputer(THIS_ BSTR bstrHostComputer)
{
HRESULT hr;
hr = _pService->put_HostComputer(bstrHostComputer);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_DisplayName(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_DisplayName(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_DisplayName(THIS_ BSTR bstrDisplayName)
{
HRESULT hr;
hr = _pService->put_DisplayName(bstrDisplayName);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_Version(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_Version(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_Version(THIS_ BSTR bstrVersion)
{
HRESULT hr;
hr = _pService->put_Version(bstrVersion);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_ServiceType(THIS_ long FAR* retval)
{
HRESULT hr;
hr = _pService->get_ServiceType(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_ServiceType(THIS_ long lServiceType)
{
HRESULT hr;
hr = _pService->put_ServiceType(lServiceType);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_StartType(THIS_ LONG FAR* retval)
{
HRESULT hr;
hr = _pService->get_StartType(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_StartType(THIS_ LONG lStartType)
{
HRESULT hr;
hr = _pService->put_StartType(lStartType);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_Path(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_Path(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_Path(THIS_ BSTR bstrPath)
{
HRESULT hr;
hr = _pService->put_Path(bstrPath);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_StartupParameters(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_StartupParameters(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_StartupParameters(THIS_ BSTR bstrStartupParameters)
{
HRESULT hr;
hr = _pService->put_StartupParameters(bstrStartupParameters);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_ErrorControl(THIS_ LONG FAR* retval)
{
HRESULT hr;
hr = _pService->get_ErrorControl(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_ErrorControl(THIS_ LONG lErrorControl)
{
HRESULT hr;
hr = _pService->put_ErrorControl(lErrorControl);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_LoadOrderGroup(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_LoadOrderGroup(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_LoadOrderGroup(THIS_ BSTR bstrLoadOrderGroup)
{
HRESULT hr;
hr = _pService->put_LoadOrderGroup(bstrLoadOrderGroup);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_ServiceAccountName(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_ServiceAccountName(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_ServiceAccountName(THIS_ BSTR bstrServiceAccountName)
{
HRESULT hr;
hr = _pService->put_ServiceAccountName(bstrServiceAccountName);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_ServiceAccountPath(THIS_ BSTR FAR* retval)
{
HRESULT hr;
hr = _pService->get_ServiceAccountPath(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_ServiceAccountPath(THIS_ BSTR bstrServiceAccountName)
{
HRESULT hr;
hr = _pService->put_ServiceAccountPath(bstrServiceAccountName);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_Dependencies(THIS_ VARIANT FAR* retval)
{
HRESULT hr;
hr = _pService->get_Dependencies(retval);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::put_Dependencies(THIS_ VARIANT vDependencies)
{
HRESULT hr;
hr = _pService->put_Dependencies(vDependencies);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::SetPassword(THIS_ BSTR bstrNewPassword)
{
HRESULT hr;
hr = _pServiceOps->SetPassword(bstrNewPassword);
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTFileService::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
CWinNTFileService::Start(THIS)
{
HRESULT hr;
hr = _pServiceOps->Start();
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTFileService::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
CWinNTFileService::Stop(THIS)
{
HRESULT hr;
hr = _pServiceOps->Stop();
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTFileService::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
CWinNTFileService::Pause(THIS)
{
HRESULT hr;
hr = _pServiceOps->Pause();
RRETURN_EXP_IF_ERR(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CWinNTFileService::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
CWinNTFileService::Continue(THIS)
{
HRESULT hr;
hr = _pServiceOps->Continue();
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::get_Status(THIS_ long FAR* plStatusCode)
{
HRESULT hr;
hr = _pServiceOps->get_Status(plStatusCode);
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::GetEx(
THIS_ BSTR bstrName,
VARIANT FAR* pvProp
)
{
HRESULT hr = S_OK;
hr = GenericGetExPropertyManager(
ADS_OBJECT_BOUND,
_pPropertyCache,
bstrName,
pvProp
);
if(FAILED(hr)){
hr= _pService->GetEx(bstrName, pvProp );
}
RRETURN_EXP_IF_ERR(hr);
}
STDMETHODIMP
CWinNTFileService::PutEx(
THIS_ long lnControlCode,
BSTR bstrName,
VARIANT vProp
)
{
HRESULT hr = S_OK;
hr = GenericPutExPropertyManager(
_pPropertyCache,
FileServiceClass,
gdwFileServiceTableSize,
bstrName,
vProp
);
if(FAILED(hr)){
hr= _pService->PutEx(lnControlCode, bstrName, vProp );
}
RRETURN_EXP_IF_ERR(hr);
}
Reference in a new issue Copy permalink