You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
846 lines
22 KiB
846 lines
22 KiB
/******************************************************************
|
|
|
|
QuotaSettings.CPP -- WMI provider class implementation
|
|
|
|
|
|
|
|
Description: Quota Settings class implementation. Quota settings
|
|
|
|
are available only on those volumes that support
|
|
|
|
Disk Quotas. It is supported only on Win2k.
|
|
|
|
|
|
|
|
Copyright (c) 2000-2001 Microsoft Corporation, All Rights Reserved
|
|
|
|
******************************************************************/
|
|
#include "precomp.h"
|
|
#include "QuotaSettings.h"
|
|
|
|
CQuotaSettings MyQuotaSettings (
|
|
|
|
IDS_DiskVolumeClass ,
|
|
NameSpace
|
|
) ;
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::CQuotaSettings
|
|
*
|
|
* DESCRIPTION : Constructor
|
|
*
|
|
* COMMENTS : Calls the Provider constructor.
|
|
*
|
|
*****************************************************************************/
|
|
CQuotaSettings :: CQuotaSettings (
|
|
|
|
LPCWSTR lpwszName,
|
|
LPCWSTR lpwszNameSpace
|
|
|
|
) : Provider ( lpwszName , lpwszNameSpace )
|
|
{
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::~CQuotaSettings
|
|
*
|
|
* DESCRIPTION : Destructor
|
|
*
|
|
* COMMENTS :
|
|
*
|
|
*****************************************************************************/
|
|
CQuotaSettings :: ~CQuotaSettings ()
|
|
{
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::EnumerateInstances
|
|
*
|
|
* DESCRIPTION : Returns all the instances of this class.
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: EnumerateInstances (
|
|
|
|
MethodContext *pMethodContext,
|
|
long lFlags
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
DWORD dwPropertiesReq;
|
|
|
|
dwPropertiesReq = QUOTASETTINGS_ALL_PROPS;
|
|
|
|
// This method enumerates all volumes on the
|
|
hRes = EnumerateAllVolumes ( pMethodContext, dwPropertiesReq );
|
|
|
|
return hRes;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::GetObject
|
|
*
|
|
* DESCRIPTION : Find a single instance based on the key properties for the
|
|
* class.
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: GetObject (
|
|
|
|
CInstance *pInstance,
|
|
long lFlags ,
|
|
CFrameworkQuery &Query
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
CHString t_Key ; // VolumePath;
|
|
|
|
if ( pInstance->GetCHString ( IDS_VolumePath , t_Key ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED ;
|
|
}
|
|
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
// verify this logical drives actually exists
|
|
CHString t_DriveStrings1;
|
|
CHString t_DriveStrings2;
|
|
|
|
LPWSTR lpDriveStrings = t_DriveStrings1.GetBuffer ( MAX_PATH + 1 );
|
|
|
|
DWORD dwDLength = GetLogicalDriveStrings ( MAX_PATH, lpDriveStrings );
|
|
|
|
if ( dwDLength > MAX_PATH )
|
|
{
|
|
lpDriveStrings = t_DriveStrings2.GetBuffer ( dwDLength + 1 );
|
|
dwDLength = GetLogicalDriveStrings ( dwDLength, lpDriveStrings );
|
|
}
|
|
|
|
hRes = m_CommonRoutine.SearchLogicalDisk ( t_Key.GetAt ( 0 ) , lpDriveStrings );
|
|
if ( hRes == WBEM_E_NOT_FOUND)
|
|
{
|
|
//
|
|
// I need to assume that VolumePath property already contains
|
|
// volume path rather than logical disk drive
|
|
//
|
|
|
|
CHString t_VolumeName;
|
|
|
|
hRes = m_CommonRoutine.VolumeSupportsDiskQuota ( t_Key, t_VolumeName );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
DWORD dwPropertiesReq;
|
|
|
|
if ( Query.AllPropertiesAreRequired() )
|
|
{
|
|
dwPropertiesReq = QUOTASETTINGS_ALL_PROPS;
|
|
}
|
|
else
|
|
{
|
|
SetRequiredProperties ( &Query, dwPropertiesReq );
|
|
}
|
|
// put the instance with the requested properties only as in Query.
|
|
// Get the Properties of the requested volume
|
|
hRes = LoadDiskQuotaVolumeProperties ( t_Key, L"", dwPropertiesReq, pInstance );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
WCHAR t_VolumePathName[MAX_PATH + 1];
|
|
|
|
if ( GetVolumeNameForVolumeMountPoint(
|
|
t_Key,
|
|
t_VolumePathName,
|
|
MAX_PATH
|
|
) )
|
|
{
|
|
CHString t_VolumeName;
|
|
|
|
hRes = m_CommonRoutine.VolumeSupportsDiskQuota ( t_VolumePathName, t_VolumeName );
|
|
{
|
|
DWORD dwPropertiesReq;
|
|
|
|
if ( Query.AllPropertiesAreRequired() )
|
|
{
|
|
dwPropertiesReq = QUOTASETTINGS_ALL_PROPS;
|
|
}
|
|
else
|
|
{
|
|
SetRequiredProperties ( &Query, dwPropertiesReq );
|
|
}
|
|
// put the instance with the requested properties only as in Query.
|
|
// Get the Properties of the requested volume
|
|
hRes = LoadDiskQuotaVolumeProperties ( t_VolumePathName, t_Key, dwPropertiesReq, pInstance );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::ExecQuery
|
|
*
|
|
* DESCRIPTION : Optimization of Queries involving only the key attribute
|
|
* is supported.
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: ExecQuery (
|
|
|
|
MethodContext *pMethodContext,
|
|
CFrameworkQuery &Query,
|
|
long lFlags
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
DWORD dwPropertiesReq;
|
|
CHStringArray t_Values;
|
|
|
|
hRes = Query.GetValuesForProp(
|
|
IDS_VolumePath,
|
|
t_Values
|
|
);
|
|
|
|
if ( t_Values.GetSize() == 0 )
|
|
{
|
|
hRes = Query.GetValuesForProp(
|
|
IDS_Caption,
|
|
t_Values
|
|
);
|
|
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
DWORD dwSize = t_Values.GetSize();
|
|
for (DWORD x = 0; x < dwSize; x++)
|
|
{
|
|
t_Values[x] += L'\\';
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( Query.AllPropertiesAreRequired() )
|
|
{
|
|
dwPropertiesReq = QUOTASETTINGS_ALL_PROPS;
|
|
}
|
|
else
|
|
{
|
|
SetRequiredProperties ( &Query, dwPropertiesReq );
|
|
}
|
|
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
if ( t_Values.GetSize() == 0 )
|
|
{
|
|
// This method is called when there is no where clause just to filter
|
|
// the required properties
|
|
hRes = EnumerateAllVolumes ( pMethodContext, dwPropertiesReq );
|
|
}
|
|
else
|
|
{
|
|
// Only Volume in VolumePath properties are needed to be enumerated
|
|
WCHAR t_VolumePathName[MAX_PATH + 1];
|
|
CHString t_VolumeName;
|
|
|
|
int iSize = t_Values.GetSize ();
|
|
|
|
for ( int i = 0; i < iSize; i++ )
|
|
{
|
|
if ( GetVolumeNameForVolumeMountPoint(
|
|
t_Values[i],
|
|
t_VolumePathName,
|
|
MAX_PATH ) )
|
|
{
|
|
hRes = m_CommonRoutine.VolumeSupportsDiskQuota ( t_VolumePathName, t_VolumeName );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
// Get and Set the Properties of the requested volume
|
|
hRes = PutVolumeDetails ( t_VolumePathName,
|
|
pMethodContext,
|
|
dwPropertiesReq );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings::PutInstance
|
|
*
|
|
* DESCRIPTION : PutInstance should be used in provider classes that can
|
|
* write instance information back to the hardware or
|
|
* software. For example: Win32_Environment will allow a
|
|
* PutInstance to create or update an environment variable.
|
|
* However, a class like MotherboardDevice will not allow
|
|
* editing of the number of slots, since it is difficult for
|
|
* a provider to affect that number.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
HRESULT CQuotaSettings :: PutInstance (
|
|
|
|
const CInstance &Instance,
|
|
long lFlags
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR ;
|
|
CHString t_Key;
|
|
|
|
if ( Instance.GetCHString ( IDS_VolumePath , t_Key ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
WCHAR t_VolumePathName[MAX_PATH + 1];
|
|
|
|
if ( GetVolumeNameForVolumeMountPoint(
|
|
t_Key,
|
|
t_VolumePathName,
|
|
MAX_PATH ) )
|
|
{
|
|
// Only changing certain properties of volumes is allowed and not adding a new DIskQuota Volume.
|
|
// Hence creating a new instance is not supported, but changing instance properties is supported.
|
|
switch ( lFlags & 3)
|
|
{
|
|
case WBEM_FLAG_CREATE_OR_UPDATE:
|
|
case WBEM_FLAG_UPDATE_ONLY:
|
|
{
|
|
hRes = CheckParameters ( Instance);
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
CHString t_VolumePathName2;
|
|
hRes = m_CommonRoutine.VolumeSupportsDiskQuota ( t_Key, t_VolumePathName2 );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
// Get the QuotaInterface Pointer
|
|
IDiskQuotaControlPtr pIQuotaControl = NULL;
|
|
|
|
if ( SUCCEEDED ( CoCreateInstance(
|
|
CLSID_DiskQuotaControl,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IDiskQuotaControl,
|
|
(void **)&pIQuotaControl ) ) )
|
|
{
|
|
hRes = m_CommonRoutine.InitializeInterfacePointer ( pIQuotaControl, t_Key );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
hRes = SetDiskQuotaVolumeProperties ( Instance, pIQuotaControl );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
break ;
|
|
}
|
|
default:
|
|
{
|
|
hRes = WBEM_E_PROVIDER_NOT_CAPABLE ;
|
|
}
|
|
break ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_NOT_FOUND;
|
|
}
|
|
}
|
|
return hRes ;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: EnumerateAllVolumes
|
|
*
|
|
* DESCRIPTION : This method Enumerates all the volumes by making use of Disk
|
|
* Quotas Interfaces, gets all the required properties and deliveres
|
|
* the instances to WMI, which will be postfiltered by WMI
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: EnumerateAllVolumes (
|
|
|
|
MethodContext *pMethodContext,
|
|
DWORD &a_PropertiesReq
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
BOOL bNextVol = TRUE;
|
|
WCHAR t_VolumeName[MAX_PATH + 1];
|
|
|
|
// Initializing and getting the first volume on the computer
|
|
SmartCloseVolumeHandle hVol;
|
|
|
|
hVol = FindFirstVolume(
|
|
t_VolumeName,
|
|
MAX_PATH // size of output buffer
|
|
);
|
|
|
|
if ( hVol != INVALID_HANDLE_VALUE )
|
|
{
|
|
while ( bNextVol )
|
|
{
|
|
hRes = PutVolumeDetails ( t_VolumeName, pMethodContext, a_PropertiesReq );
|
|
// Continue for next volume, even if the retval for this volume is false;
|
|
bNextVol = FindNextVolume(
|
|
hVol, // volume search handle
|
|
t_VolumeName, // output buffer
|
|
MAX_PATH // size of output buffer
|
|
);
|
|
if ( bNextVol == FALSE )
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
hRes = WBEM_E_FAILED;
|
|
|
|
return hRes;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: LoadDiskQuotaVolumeProperties
|
|
*
|
|
* DESCRIPTION : This method checks if the volume enumerated supports Disk Quotas
|
|
* If the Volume Supposrts DIskQuotas, it fills up all the properties
|
|
* of the volume and returns otherwise it just returns FALSE
|
|
* indicating properties of this volume were not filled. and hence
|
|
* intsnace should not be delivered to WMI
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: LoadDiskQuotaVolumeProperties (
|
|
|
|
LPCWSTR a_VolumeName,
|
|
LPCWSTR a_Caption,
|
|
DWORD dwPropertiesReq,
|
|
CInstancePtr pInstance
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
DWORD dwLogFlags;
|
|
DWORD dwQuotaState;
|
|
CHString t_Temp;
|
|
|
|
// checks to see if the volume supports Disk Quotas
|
|
hRes = m_CommonRoutine.VolumeSupportsDiskQuota ( a_VolumeName, t_Temp );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_Caption ) )
|
|
{
|
|
t_Temp = a_Caption;
|
|
pInstance->SetCHString(IDS_Caption, t_Temp.Left(2));
|
|
}
|
|
|
|
IDiskQuotaControlPtr pIQuotaControl;
|
|
|
|
if ( SUCCEEDED ( CoCreateInstance(
|
|
CLSID_DiskQuotaControl,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER,
|
|
IID_IDiskQuotaControl,
|
|
(void **)&pIQuotaControl ) ) )
|
|
{
|
|
// Initializing the QuotaCOntrol Interface pointer for this Volume
|
|
hRes = m_CommonRoutine.InitializeInterfacePointer ( pIQuotaControl, a_VolumeName );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
// Get all the Volume Properties
|
|
LONGLONG lQuotaLimit = 0;
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_DefaultLimit ) )
|
|
{
|
|
if ( SUCCEEDED ( pIQuotaControl->GetDefaultQuotaLimit( &lQuotaLimit ) ) )
|
|
{
|
|
if ( pInstance->SetWBEMINT64 ( IDS_QuotasDefaultLimit, (ULONGLONG)lQuotaLimit ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_DefaultWarningLimit ) )
|
|
{
|
|
if ( SUCCEEDED ( pIQuotaControl->GetDefaultQuotaThreshold ( &lQuotaLimit ) ) )
|
|
{
|
|
if ( pInstance->SetWBEMINT64 ( IDS_QuotasDefaultWarningLimit, (ULONGLONG)lQuotaLimit ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( ( ( dwPropertiesReq & QUOTASETTINGS_PROP_QuotaExceededNotification ) )
|
|
|| ( ( dwPropertiesReq & QUOTASETTINGS_PROP_WarningExceededNotification ) ) )
|
|
|
|
{
|
|
if ( SUCCEEDED ( pIQuotaControl->GetQuotaLogFlags( &dwLogFlags ) ) )
|
|
{
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_QuotaExceededNotification ) )
|
|
{
|
|
if ( pInstance->Setbool ( IDS_QuotaExceededNotification, DISKQUOTA_IS_LOGGED_USER_LIMIT ( dwLogFlags ) ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_WarningExceededNotification ) )
|
|
{
|
|
if ( pInstance->Setbool ( IDS_QuotasWarningExceededNotification, DISKQUOTA_IS_LOGGED_USER_THRESHOLD ( dwLogFlags) ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if ( ( dwPropertiesReq & QUOTASETTINGS_PROP_State ) )
|
|
{
|
|
if ( SUCCEEDED (pIQuotaControl->GetQuotaState( &dwQuotaState ) ) )
|
|
{
|
|
DWORD State = 0;
|
|
|
|
if ( DISKQUOTA_IS_DISABLED ( dwQuotaState ) )
|
|
State = 0;
|
|
else
|
|
if ( DISKQUOTA_IS_ENFORCED ( dwQuotaState) )
|
|
State = 2;
|
|
else
|
|
if ( DISKQUOTA_IS_TRACKED ( dwQuotaState) )
|
|
State = 1;
|
|
|
|
pInstance->SetDWORD ( IDS_QuotaState, State );
|
|
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: SetDiskQuotaVolumeProperties
|
|
*
|
|
* DESCRIPTION : This method Sets the DskQuota Volume Properties
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: SetDiskQuotaVolumeProperties (
|
|
|
|
const CInstance &Instance,
|
|
IDiskQuotaControlPtr pIQuotaControl
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
DWORD dwLogFlags = 0;
|
|
DWORD dwQuotaState = 0;
|
|
bool bExceededNotn = false;
|
|
bool bWarningNotn = false;
|
|
DWORD dwState = 0;
|
|
UINT64 ullDefaultLimit = 0;
|
|
UINT64 ullWarningLimit = 0;
|
|
bool bSetState = false;
|
|
|
|
if (Instance.Getbool ( IDS_QuotaExceededNotification, bExceededNotn ))
|
|
{
|
|
if ( bExceededNotn )
|
|
DISKQUOTA_SET_LOG_USER_LIMIT ( dwLogFlags, TRUE );
|
|
else
|
|
DISKQUOTA_SET_LOG_USER_LIMIT ( dwLogFlags, FALSE );
|
|
|
|
bSetState = true;
|
|
}
|
|
|
|
if (Instance.Getbool ( IDS_QuotasWarningExceededNotification, bWarningNotn ))
|
|
{
|
|
if ( bWarningNotn )
|
|
DISKQUOTA_SET_LOG_USER_THRESHOLD ( dwLogFlags, TRUE );
|
|
else
|
|
DISKQUOTA_SET_LOG_USER_THRESHOLD ( dwLogFlags, FALSE );
|
|
|
|
bSetState = true;
|
|
}
|
|
|
|
if (bSetState)
|
|
{
|
|
if ( FAILED ( pIQuotaControl->SetQuotaLogFlags ( dwLogFlags ) ) )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if (Instance.GetWBEMINT64 ( IDS_QuotasDefaultLimit, ullDefaultLimit ))
|
|
{
|
|
if ( FAILED ( pIQuotaControl->SetDefaultQuotaLimit ( ullDefaultLimit ) ) )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if (Instance.GetWBEMINT64 ( IDS_QuotasDefaultWarningLimit, ullWarningLimit ))
|
|
{
|
|
if ( FAILED ( pIQuotaControl->SetDefaultQuotaThreshold ( ullWarningLimit ) ) )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
if (Instance.GetDWORD ( IDS_QuotaState, dwState ))
|
|
{
|
|
if ( dwState == 0 )
|
|
DISKQUOTA_SET_DISABLED ( dwQuotaState );
|
|
|
|
if ( dwState == 1 )
|
|
DISKQUOTA_SET_TRACKED ( dwQuotaState );
|
|
|
|
if ( dwState == 2 )
|
|
DISKQUOTA_SET_ENFORCED ( dwQuotaState );
|
|
|
|
if ( FAILED ( pIQuotaControl->SetQuotaState( dwQuotaState ) ) )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
|
|
return hRes;
|
|
}
|
|
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: CheckParameters
|
|
*
|
|
* DESCRIPTION : Checks for the validity of the input parameters while
|
|
* Updating an instance
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: CheckParameters (
|
|
|
|
const CInstance &a_Instance
|
|
)
|
|
{
|
|
// Getall the Properties from the Instance to Verify
|
|
HRESULT hRes = WBEM_S_NO_ERROR ;
|
|
bool t_Exists ;
|
|
VARTYPE t_Type ;
|
|
|
|
if ( a_Instance.GetStatus ( IDS_QuotaState, t_Exists , t_Type ) )
|
|
{
|
|
DWORD t_State;
|
|
if ( t_Exists && ( t_Type == VT_I4 ) )
|
|
{
|
|
if ( a_Instance.GetDWORD ( IDS_QuotaState , t_State ) )
|
|
{
|
|
if ( ( t_State != 1 ) && ( t_State != 0 ) && ( t_State != 2 ))
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
|
|
if ( a_Instance.GetStatus ( IDS_QuotaExceededNotification, t_Exists , t_Type ) )
|
|
{
|
|
if ( t_Exists && ( t_Type == VT_BOOL ) )
|
|
{
|
|
bool bQuotaState;
|
|
|
|
if ( a_Instance.Getbool ( IDS_QuotaExceededNotification , bQuotaState ) == false )
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
|
|
if ( a_Instance.GetStatus ( IDS_QuotasWarningExceededNotification, t_Exists , t_Type ) )
|
|
{
|
|
if ( t_Exists && ( t_Type == VT_BOOL ) )
|
|
{
|
|
bool bQuotaState;
|
|
|
|
if ( a_Instance.Getbool ( IDS_QuotasWarningExceededNotification , bQuotaState ) == false )
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
|
|
if ( a_Instance.GetStatus ( IDS_QuotasDefaultLimit, t_Exists , t_Type ) )
|
|
{
|
|
if ( t_Exists && ( t_Type == VT_BSTR ) )
|
|
{
|
|
LONGLONG lDefaultLimit;
|
|
if ( a_Instance.GetWBEMINT64 ( IDS_QuotasDefaultLimit , lDefaultLimit ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
|
|
if ( a_Instance.GetStatus ( IDS_QuotasDefaultWarningLimit, t_Exists , t_Type ) )
|
|
{
|
|
if ( t_Exists && ( t_Type == VT_BSTR ) )
|
|
{
|
|
LONGLONG lDefaultWarningLimit;
|
|
|
|
if ( a_Instance.GetWBEMINT64 ( IDS_QuotasDefaultWarningLimit , lDefaultWarningLimit ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hRes = WBEM_E_INVALID_PARAMETER ;
|
|
}
|
|
}
|
|
return hRes ;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: SetRequiredProperties
|
|
*
|
|
* DESCRIPTION : This method sets the required properties for the instances
|
|
* requested by the user
|
|
*
|
|
*****************************************************************************/
|
|
void CQuotaSettings :: SetRequiredProperties (
|
|
|
|
CFrameworkQuery *Query,
|
|
DWORD &a_PropertiesReq
|
|
)
|
|
{
|
|
a_PropertiesReq = 0;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_VolumePath ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_VolumePath;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_QuotasDefaultLimit ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_DefaultLimit;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_Caption ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_Caption;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_QuotasDefaultWarningLimit ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_DefaultWarningLimit;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_QuotaExceededNotification ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_QuotaExceededNotification;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_QuotasWarningExceededNotification ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_WarningExceededNotification;
|
|
|
|
if ( Query->IsPropertyRequired ( IDS_QuotaState ) )
|
|
a_PropertiesReq |= QUOTASETTINGS_PROP_State;
|
|
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* FUNCTION : CQuotaSettings:: PutVolumeDetails
|
|
*
|
|
* DESCRIPTION : Putting the volume properties
|
|
*
|
|
*****************************************************************************/
|
|
HRESULT CQuotaSettings :: PutVolumeDetails (
|
|
|
|
LPCWSTR a_VolumeName,
|
|
MethodContext *pMethodContext,
|
|
DWORD a_PropertiesReq
|
|
)
|
|
{
|
|
HRESULT hRes = WBEM_S_NO_ERROR;
|
|
CHString t_DriveName ;
|
|
// verify this logical drives actually exists
|
|
CHString t_DriveStrings1;
|
|
CHString t_DriveStrings2;
|
|
|
|
LPWSTR lpDriveStrings = t_DriveStrings1.GetBuffer ( MAX_PATH + 1 );
|
|
DWORD dwDLength = GetLogicalDriveStrings ( MAX_PATH, lpDriveStrings );
|
|
if ( dwDLength > MAX_PATH )
|
|
{
|
|
lpDriveStrings = t_DriveStrings2.GetBuffer ( dwDLength + 1 );
|
|
dwDLength = GetLogicalDriveStrings ( dwDLength, lpDriveStrings );
|
|
}
|
|
|
|
CInstancePtr pInstance(CreateNewInstance ( pMethodContext ), false) ;
|
|
|
|
m_CommonRoutine.GetVolumeDrive ( a_VolumeName, lpDriveStrings, t_DriveName );
|
|
|
|
hRes = LoadDiskQuotaVolumeProperties ( a_VolumeName, t_DriveName, a_PropertiesReq, pInstance );
|
|
if ( SUCCEEDED ( hRes ) )
|
|
{
|
|
|
|
if ( ( a_PropertiesReq & QUOTASETTINGS_PROP_VolumePath ) )
|
|
{
|
|
if ( t_DriveName.IsEmpty() )
|
|
{
|
|
if ( pInstance->SetCHString ( IDS_VolumePath, a_VolumeName ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( pInstance->SetCHString ( IDS_VolumePath, t_DriveName ) == FALSE )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( FAILED ( pInstance->Commit() ) )
|
|
{
|
|
hRes = WBEM_E_FAILED;
|
|
}
|
|
}
|
|
return hRes;
|
|
}
|