1511 lines
35 KiB
C++
1511 lines
35 KiB
C++
//---------------------------------------------------------------------------
|
|
//
|
|
// 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);
|
|
}
|
|
|