在Win32环境中修改Lenovo笔记本引导设备启动顺序、恢复BIOS默认设置。

Changing BIOS settings

To change a BIOS setting, complete the following steps:

1. Identify the BIOS setting you want to change using the Lenovo_BiosSetting class

2. Identify the value to which the setting will be changed.

3. Change the BIOS setting to the desired value using the Lenovo_SetBiosSetting class, then use the Lenovo_SaveBiosSetting

class to save the settings

Note: BIOS settings and values are case sensitive. After making changes to the BIOS settings,

you must reboot the computer before the changes will take effect.

Changing the boot order

To change the boot order, complete the following steps:

1. Determine the current setting for "BootOrder" by using the Lenovo_BiosSetting class.

2. To set a new boot order, use the Lenovo_SetBiosSetting class, then use the Lenovo_SaveBiosSetting

class to save the settings, Specify a new boot order by listing the boot devices in order,

separated by colons. Devices that are not specified are excluded from the boot order.

In the following example, the CD drive 0 is the first boot device and hard disk

drive 0 is the second startup device. AHCI_CD:AHCI_HDD

Restoring default settings

To restore default BIOS settings, use the Lenovo_LoadDefaultSettings class,

and then use the Lenovo_SaveBiosSettings class to save the BIOS changes

/* lenovoEfi.cpp
*
* Source file for implementation of lenovo WMI,
*
* Authors: perry <ppsoft268@gmail.com>
*
* Date   : April 04, 2011
*
*/

#include "stdafx.h"
#include "wmiobj.h"

#pragma comment(lib, "wbemuuid.lib")
#pragma warning(disable:4996)

CEfiBios::CEfiBios(void) throw(CException) :
m_WbemLoc(NULL),
m_WbemSvr(NULL)
{
objLog->Info("CEfiBios", "CEfiBios() ==> OK");

// create a new WMI locator.
if ( FAILED(::CoCreateInstance(CLSID_WbemLocator,
0, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_FROM_DEFAULT_CONTEXT,
IID_IWbemLocator,
(LPVOID *)&m_WbemLoc)) )
throw new CException();

objLog->Info("CEfiBios", "CoCreateInstance ==> OK");

BSTR bsLoc = ::SysAllocString(L"\\\\.\\ROOT\\WMI");

// connect to "root\WMI" namespace.
if ( FAILED(m_WbemLoc->ConnectServer(bsLoc,
NULL, NULL,
NULL, 0,
NULL, NULL,
&m_WbemSvr)) )
{
::SysFreeString(bsLoc);
throw new CException();
}

objLog->Info("CEfiBios", "ConnectServer ==> OK");

// free the bstr.
::SysFreeString(bsLoc);

if ( FAILED(::CoSetProxyBlanket(m_WbemSvr,
RPC_C_AUTHN_WINNT,
RPC_C_AUTHZ_NONE,
NULL,
RPC_C_AUTHN_LEVEL_CALL,
RPC_C_IMP_LEVEL_IMPERSONATE,
NULL,
EOAC_NONE)) )
throw new CException();

objLog->Info("CEfiBios", "CoSetProxyBlanket ==> OK");
}

CEfiBios::~CEfiBios(void)
{
// release COM objects;
if ( m_WbemLoc )
m_WbemLoc->Release();

if ( m_WbemSvr )
m_WbemSvr->Release();

objLog->Info("CEfiBios", "~CEfiBios ==> OK");
}

bool CEfiBios::LoadDefault(void)
{
TCHAR
szOutput[MAX_RETURN_SIZE];

// call method LoadDefaultSettings on class Lenovo_LoadDefaultSettings.
if ( !Invoke(TEXT("LoadDefaultSettings"), TEXT(""), szOutput) )
{
objLog->Crit("CEfiBios", "LoadDefault::Invoke() ==> FAIL");
return false;
}

objLog->Info(TEXT("CEfiBios"), TEXT("LoadDefault{%s} ==> OK"), szOutput);

// compare the execute result.
if ( lstrcmp(TEXT("Success"), szOutput) )
{
objLog->Crit(TEXT("CEfiBios"), TEXT("LoadDefault::Invoke(%s) ==> FAIL"), szOutput);
return false;
}

return true;
}

bool CEfiBios::GetSetting(LPCTSTR name, LPTSTR value, int cbSize)
{
assert(m_WbemSvr != NULL);
assert(name != NULL);
assert(value != NULL);

if ( !m_WbemSvr )
return false;

bool bRet = false;

IEnumWbemClassObject
* pEnum = NULL;

IWbemClassObject
* pObj = NULL;

BSTR
bsQuery = NULL;

__try
{
*value = L'\0';

if ( !m_WbemSvr )
__leave;

bsQuery = ::SysAllocString(L"Lenovo_BiosSetting");
if ( !bsQuery )
{
objLog->Crit("CEfiBios", "GetSetting::SysAllocString(bsQuery) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "GetSetting::SysAllocString(bsQuery) ==> OK");

// execute query.
if ( FAILED(m_WbemSvr->CreateInstanceEnum(bsQuery,
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnum)) )
{
objLog->Crit("CEfiBios", "GetSetting::CreateInstanceEnum ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "GetSetting::CreateInstanceEnum ==> OK");

ULONG
uReturn = 0;

while ( pEnum )
{
if ( FAILED(pEnum->Next(5000, 1, &pObj, &uReturn)) )
continue;
objLog->Info("CEfiBios", "GetSetting::pEnum->Next(uReturn = %d) ==> OK", uReturn);
if ( !uReturn )
break;

VARIANT
vtProp;

::VariantInit(&vtProp);
objLog->Info("CEfiBios", "GetSetting::VariantInit(&vtProp) ==> OK", uReturn);

// read the setting value.
if ( SUCCEEDED(pObj->Get(L"CurrentSetting", 0, &vtProp, NULL, NULL)) )
{
TCHAR
outname[MAX_NAME_SIZE],
outval[MAX_PROPERTY_SIZE];

objLog->Info(TEXT("CEfiBios"), TEXT("GetSetting::pObj->Get(\"CurrentSetting\") ==> OK"));
// the format for CurrentSetting is "Item,Value"
// obtained the names and values after parsing
if ( ParseSetting(vtProp.bstrVal, outname, outval) )
{
objLog->Info(TEXT("CEfiBios"), TEXT("GetSetting::ParseSetting(\"%s\",\"%s\") ==> OK"), outname, outval);
// compare name.
if ( lstrcmpi(name, outname) == 0 )
{
objLog->Info(TEXT("CEfiBios"), TEXT("GetSetting::lstrcmpi(\"%s\", \"%s\") ==> OK"), name, outname);
if ( lstrlen(outval) > cbSize )
lstrcpyn(value, outval, cbSize);
else
lstrcpy(value, outval);

bRet = true;

::VariantClear(&vtProp);
objLog->Info("CEfiBios", "GetSetting::VariantClear(&vtProp) ==> OK");

pObj->Release();
objLog->Info("CEfiBios", "GetSetting::pObj->Release() ==> OK");

// exit the loop.
break;
}
}
}

::VariantClear(&vtProp);
objLog->Info("CEfiBios", "GetSetting::VariantClear(&vtProp) ==> OK");

pObj->Release();
objLog->Info("CEfiBios", "GetSetting::pObj->Release() ==> OK");
}
}
__finally
{
if ( pEnum )
{
objLog->Info("CEfiBios", "GetSetting::pEnum->Release() ==> OK");
pEnum->Release();
}

if ( bsQuery )
{
objLog->Info("CEfiBios", "GetSetting::SysFreeString(bsQuery) ==> OK");
::SysFreeString(bsQuery);
}
}

return bRet;
}

bool CEfiBios::SetSetting(LPCTSTR name, LPCTSTR value)
{
TCHAR
szOutput[MAX_RETURN_SIZE],
szInput[MAX_PROPERTY_SIZE];

::wsprintf(szInput, TEXT("%s,%s"), name, value);

if ( !Invoke(TEXT("SetBiosSetting"), szInput, szOutput) )
{
objLog->Crit("CEfiBios", "SetSetting::Invoke() ==> FAIL");
return false;
}

objLog->Info(TEXT("CEfiBios"), TEXT("SetSetting(%s,%s){%s} ==> OK"), name, value, szOutput);

// compare the execute result.
if ( lstrcmp(TEXT("Success"), szOutput) )
{
objLog->Crit(TEXT("CEfiBios"), TEXT("SetSetting::Invoke(%s) ==> FAIL"), szOutput);
return false;
}

return true;
}

bool CEfiBios::SetBootOrder(LPCTSTR device)
{
assert(m_WbemSvr != NULL);
assert(device != NULL);

TCHAR
buffer[MAX_PROPERTY_SIZE],
szDevices[MAX_PROPERTY_SIZE],
szParam[MAX_PROPERTY_SIZE];

if ( !lstrlen(device) )
return false;

if ( !GetSetting(TEXT("BootOrder"), buffer, MAX_PROPERTY_SIZE) )
{
objLog->Crit("CEfiBios", "SetBootOrder::GetSetting() ==> FAIL");
return false;
}

objLog->Info(TEXT("CEfiBios"), TEXT("SetBootOrder(%s){%s} ==> OK"), device, buffer);

lstrcpy(szDevices, device);

LPCTSTR
psz = _tcstok(szDevices, TEXT(":"));

szParam[0] = L'\0';

while ( psz )
{
if ( _tcsstr(buffer, psz) )
{
lstrcat(szParam, psz);
lstrcat(szParam, TEXT(":"));
}
psz = _tcstok(NULL, TEXT(":"));
}

psz = _tcstok(buffer, TEXT(":"));

while ( psz )
{
if ( !_tcsstr(szParam, psz) )
{
lstrcat(szParam, psz);
lstrcat(szParam, TEXT(":"));
}
psz = _tcstok(NULL, TEXT(":"));
}

if ( !_tcschr(szParam, L':') )
return false;

if ( szParam[lstrlen(szParam) - 1] == L':' )
szParam[lstrlen(szParam) - 1] = L'\0';

objLog->Info(TEXT("CEfiBios"), TEXT("SetBootOrder(%s){%s} ==> OK"), device, szParam);

return SetSetting(TEXT("BootOrder"), szParam);
}

bool CEfiBios::IsSuported(void)
{
assert(m_WbemSvr != NULL);

if ( !m_WbemSvr )
return false;

IEnumWbemClassObject
* pEnum = NULL;

IWbemClassObject
* pClass = NULL;

BSTR
bsSuperClass = ::SysAllocString(L"Lenovo_BIOSElement");

__try
{
// obtain the class object.
if ( FAILED(m_WbemSvr->GetObject(bsSuperClass, 0, NULL, &pClass, NULL)) )
{
objLog->Crit("CEfiBios", "IsSuported::GetObject() ==> FAIL");
return false;
}

if ( pClass )
pClass->Release();

if ( FAILED(m_WbemSvr->CreateClassEnum(bsSuperClass,
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnum)) )
{
objLog->Alert("CEfiBios", "IsSuported::CreateClassEnum() ==> FAIL");
return false;
}
}
__finally
{
::SysFreeString(bsSuperClass);
}

IWbemClassObject
* pObj = NULL;

ULONG
uReturn = 0,
uCount = 1;

while ( pEnum )
{
if ( FAILED(pEnum->Next(1000, 1, &pObj, &uReturn)) )
continue;
if ( !uReturn )
break;

//VARIANT vtProp;
//BSTR bsText;

//pObj->Get(L"Name", 0, &vtProp, 0, 0);
//pObj->GetObjectText(0, &bsText);
pObj->Release();

//::MessageBox(NULL, bsText, TEXT("Lenovo UEFI"), 0);
//::MessageBox(NULL, vtProp.bstrVal, TEXT("Lenovo UEFI"), 0);
//::SysFreeString(bsText);
//VariantClear(&vtProp);
uCount++;
}

pEnum->Release();

return uCount > 0;
}

bool CEfiBios::SaveSetting(void)
{
TCHAR
szOutput[MAX_RETURN_SIZE];

if ( !Invoke(TEXT("SaveBiosSettings"), TEXT(""), szOutput) )
{
objLog->Crit(TEXT("CEfiBios"), TEXT("SaveSetting(){%s} ==> FAIL"), szOutput);
return false;
}

objLog->Info(TEXT("CEfiBios"), TEXT("SaveSetting(){%s} ==> OK"), szOutput);

// compare the execute result.
if ( lstrcmp(TEXT("Success"), szOutput) )
return false;

return true;
}

bool CEfiBios::DiscardSetting(void)
{
TCHAR
szOutput[MAX_RETURN_SIZE];

if ( !Invoke(TEXT("DiscardBiosSettings"), TEXT(""), szOutput) )
{
objLog->Crit(TEXT("CEfiBios"), TEXT("DiscardSetting(){%s} ==> FAIL"), szOutput);
return false;
}

objLog->Info(TEXT("CEfiBios"), TEXT("DiscardSetting(){%s} ==> OK"), szOutput);

// compare the execute result.
if ( lstrcmp(TEXT("Success"), szOutput) )
{
objLog->Crit(TEXT("CEfiBios"), TEXT("szOutput equ %s ==> FAIL"), szOutput);
return false;
}

return true;
}

bool CEfiBios::ParseSetting(const BSTR in, LPTSTR nameOut, LPTSTR valueOut)
{
assert(in != NULL);
assert(nameOut != NULL);
assert(valueOut != NULL);

LPTSTR
p;

*nameOut = *valueOut = L'\0';

if ( lstrlen(in) == 0 )
return false;

lstrcpy(nameOut, in);
if ( p = _tcschr(nameOut, L',') )
{
*p = L'\0';
lstrcpy(valueOut, ++p);
}

return true;
}

bool CEfiBios::Invoke(LPCTSTR method, LPCTSTR param, LPTSTR out)
{
assert(m_WbemSvr != NULL);
assert(method != NULL);
assert(param != NULL);
assert(out != NULL);

bool
bRet = false;

IEnumWbemClassObject
* pEnum = NULL;

IWbemClassObject
* pClass = NULL,
* pObj = NULL,
* pIncc = NULL,
* pIn = NULL;

BSTR
bsClass = NULL,
bsInput = NULL,
bsMethod = NULL;

VARIANT
var1;

TCHAR
szClass[MAX_NAME_SIZE];

__try
{
::VariantInit(&var1);
*out = L'\0';

if ( !m_WbemSvr )
__leave;

::wsprintf(szClass, TEXT("Lenovo_%s"), method);

bsClass = ::SysAllocString(szClass);
if ( !bsClass )
{
objLog->Crit("CEfiBios", "Invoke::SysAllocString(bsClass) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::SysAllocString(bsClass) ==> OK");

bsMethod = ::SysAllocString(method);
if ( !bsMethod )
{
objLog->Crit("CEfiBios", "Invoke::SysAllocString(bsMethod) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::SysAllocString(bsMethod) ==> OK");

// obtain the class object.
if ( FAILED(m_WbemSvr->GetObject(bsClass, 0, NULL, &pClass, NULL)) )
{
objLog->Crit("CEfiBios", "Invoke::GetObject() ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::GetObject() ==> OK");

// obtain the input parameters.
if ( FAILED(pClass->GetMethod(bsMethod, 0, &pIncc, NULL)) )
{
objLog->Crit("CEfiBios", "Invoke::GetMethod ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::GetMethod() ==> OK");

// create an new instance of the input parameter.
if ( FAILED(pIncc->SpawnInstance(0, &pIn)) )
{
objLog->Crit("CEfiBios", "Invoke::SpawnInstance ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::SpawnInstance() ==> OK");

// set value for the input parameter.
bsInput = ::SysAllocString(param);
if ( !bsInput )
{
objLog->Crit("CEfiBios", "Invoke::SysAllocString(bsInput) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::SysAllocString(bsInput) ==> OK");

V_VT(&var1) = VT_BSTR;
V_BSTR(&var1) = bsInput;

// update value to the parameter object.
if ( FAILED(pIn->Put(L"parameter", 0, &var1, 0)) )
{
objLog->Crit("CEfiBios", "Invoke::pIn->Put(L\"parameter\", 0, &var1, 0) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::pIn->Put(L\"parameter\") ==> OK");

if ( FAILED(m_WbemSvr->CreateInstanceEnum(bsClass,
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnum)) )
{
objLog->Crit("CEfiBios", "Invoke::CreateInstanceEnum() ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::CreateInstanceEnum() ==> OK");

ULONG
uReturn = 0;

while ( pEnum )
{
if ( FAILED(pEnum->Next(1000, 1, &pObj, &uReturn)) )
continue;
objLog->Info("CEfiBios", "Invoke::pEnum->Next(uReturn = %d) ==> OK", uReturn);
if ( !uReturn )
break;

IWbemClassObject
* pOut = NULL;

VARIANT
var2,
var3;

__try
{
::VariantInit(&var2);
::VariantInit(&var3);

if ( FAILED(pObj->Get(L"__RELPATH", 0, &var2, NULL, NULL)) )
{
objLog->Crit("CEfiBios", "Invoke::pObj->Get(\"__RELPATH\") ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::pObj->Get(\"__RELPATH\") ==> OK");

// call method.
if ( FAILED(m_WbemSvr->ExecMethod(
V_BSTR(&var2),
bsMethod,
0,
NULL,
pIn,
&pOut,
NULL)) )
{
objLog->Crit("CEfiBios", "Invoke::ExecMethod(\"%s\") ==> FAIL GetLastErro=%08x", V_BSTR(&var1), GetLastError());
__leave;
}

objLog->Info(TEXT("CEfiBios"), TEXT("Invoke::ExecMethod(\"%s\") ==> OK"), V_BSTR(&var1));

if ( !pOut )
{
objLog->Crit("CEfiBios", "Invoke::{pOut equ NULL} ==> FAIL");
__leave;
}

if ( FAILED(pOut->Get(L"return", 0, &var3, NULL, NULL)) )
{
objLog->Crit("CEfiBios", "Invoke::pOut->Get(\"return\") ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "Invoke::pOut->Get(\"return\") ==> OK");

lstrcpy(out, V_BSTR(&var3));

bRet = true;
}
__finally
{
::VariantClear(&var2);
::VariantClear(&var3);

if ( pOut )
{
objLog->Info("CEfiBios", "Invoke::pOut->Release() ==> OK");
pOut->Release();
pOut = NULL;
}

pObj->Release();
pObj = NULL;
objLog->Info("CEfiBios", "Invoke::pObj->Release() ==> OK");
}
}
}
__finally
{
::VariantClear(&var1);
objLog->Info("CEfiBios", "Invoke::VariantClear(var1) ==> OK");

if ( pClass )
{
objLog->Info("CEfiBios", "Invoke::pClass->Release() ==> OK");
pClass->Release();
}

if ( pIncc )
{
objLog->Info("CEfiBios", "Invoke::pClass->Release() ==> OK");
pIncc->Release();
}

if ( pIn )
{
objLog->Info("CEfiBios", "Invoke::pIn->Release() ==> OK");
pIn->Release();
}

if ( bsClass )
{
objLog->Info("CEfiBios", "Invoke::SysFreeString(bsClass) ==> OK");
::SysFreeString(bsClass);
}

if ( bsMethod )
{
objLog->Info("CEfiBios", "Invoke::SysFreeString(bsMethod) ==> OK");
::SysFreeString(bsMethod);
}

if ( bsInput )
{
objLog->Info("CEfiBios", "Invoke::SysFreeString(bsInput) ==> OK");
::SysFreeString(bsInput);
}
}

return bRet;
}

int CEfiBios::EnumBootDevices(ENUM_BOOTDEVICE pCallback, LPARAM lParam)
{
assert(m_WbemSvr != NULL);

TCHAR
buffer[MAX_RETURN_SIZE];

// read boot devices.
if ( !GetSetting(TEXT("BootOrder"), buffer, 256) )
{
objLog->Crit("CEfiBios", "EnumBootDevices::GetSetting(\"BootOrder\") ==> FAIL");
return 0;
}

objLog->Info("CEfiBios", "EnumBootDevices::GetSetting(\"BootOrder\") ==> OK");

int
iCount = 0;

LPCTSTR
psz = _tcstok(buffer, TEXT(":"));

// split the devices string.
while ( psz )
{
iCount++;

// execute the function of callback.
pCallback(psz, lParam);
objLog->Info(TEXT("CEfiBios"), TEXT("EnumBootDevices::pCallback(\"%s\") ==> OK"), psz);

// find next device name.
psz = _tcstok(NULL, TEXT(":"));
}

return iCount;
}

int CEfiBios::EnumSettings(ENUM_SETTING pCallback, LPARAM lParam)
{
assert(m_WbemSvr != NULL);

objLog->Info("CEfiBios", "EnumSettings()");

int iCount = 0;

IEnumWbemClassObject
* pEnum = NULL;

IWbemClassObject
* pObj = NULL;

BSTR
bsQuery = NULL;

__try
{
if ( !m_WbemSvr )
__leave;

bsQuery = ::SysAllocString(L"Lenovo_BiosSetting");
if ( !bsQuery )
{
objLog->Crit("CEfiBios", "EnumSettings::SysAllocString(bsQuery) ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "EnumSettings::SysAllocString(bsQuery) ==> OK");

if ( FAILED(m_WbemSvr->CreateInstanceEnum(bsQuery,
WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
NULL,
&pEnum)) )
{
objLog->Crit("CEfiBios", "EnumSettings::CreateInstanceEnum() ==> FAIL");
__leave;
}

objLog->Info("CEfiBios", "EnumSettings::CreateInstanceEnum() ==> OK");

ULONG
uReturn = 0;

while ( pEnum )
{
if ( FAILED(pEnum->Next(5000, 1, &pObj, &uReturn)) )
continue;
objLog->Info("CEfiBios", "EnumSettings::pEnum->Nex(uReturn = %d) ==> OK", uReturn);
if ( !uReturn )
break;

VARIANT
vtProp;

::VariantInit(&vtProp);
objLog->Info("CEfiBios", "EnumSettings::VariantInit(&vtProp) ==> OK");

// read the setting value.
if ( SUCCEEDED(pObj->Get(L"CurrentSetting", 0, &vtProp, NULL, NULL)) )
{
TCHAR
name[MAX_NAME_SIZE],
value[MAX_PROPERTY_SIZE];

objLog->Info(TEXT("CEfiBios"), TEXT("EnumSettings::pObj->Get(CurrentSetting=%s) ==> OK"), vtProp.bstrVal);

// the format for CurrentSetting is "Item,Value"
// obtained the names and values after parsing
if ( ParseSetting(vtProp.bstrVal, name, value) )
{
objLog->Info(TEXT("CEfiBios"), TEXT("EnumSettings::ParseSetting(\"%s\",\"%s\") ==> OK"), name, value);
// enum callback.
pCallback(name, value, lParam);
iCount++;
}
}
::VariantClear(&vtProp);
objLog->Info("CEfiBios", "EnumSettings::VariantClear(&vtProp) ==> OK");
pObj->Release();
objLog->Info("CEfiBios", "EnumSettings::pObj->Release() ==> OK");
}
}
__finally
{
if ( pEnum )
{
objLog->Info("CEfiBios", "EnumSettings::pEnum->Release() ==> OK");
pEnum->Release();
}

if ( bsQuery )
{
objLog->Info("CEfiBios", "EnumSettings::SysFreeString(bsQuery) ==> OK");
::SysFreeString(bsQuery);
}
}

return iCount;
}

CException::CException(void) :
m_cause(::GetLastError())
{

}

CException::CException(long cause) :
m_cause(cause)
{

}

CException::~CException(void)
{

}

void CException::ShowError(void)
{
TCHAR
szShown[260];

if ( GetErrorText(szShown, 260) )
//#ifdef _WINDOWS
//      ::MessageBox(NULL, szShown, TEXT("WMI Error"), 0);
//#else
_tcprintf(TEXT("%s"), szShown);
//#endif
}

void CException::ShowError(LPCTSTR format)
{
TCHAR
szText[260];

if ( GetErrorText(szText, 260) )
{
TCHAR
szShown[260];

::wsprintf(szShown, format, szText);

//#ifdef _WINDOWS
//    ::MessageBox(NULL, szShown, TEXT("WMI Error"), 0);
//#else
_tcprintf(TEXT("%s"), szShown);
//#endif
}
}

bool CException::GetErrorText(
_Out_z_cap_(nMaxError) LPTSTR lpszError,
_In_ UINT nMaxError) const throw()
{
if ( lpszError == NULL || nMaxError == 0 )
return false;

LPVOID
buff;

if ( ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, m_cause, 0, (LPTSTR)&buff,0, NULL) == 0 )
return false;

if ( (UINT)::lstrlen((LPCTSTR)buff) < nMaxError )
nMaxError = ::lstrlen((LPCTSTR)buff);
lstrcpyn(lpszError, (LPCTSTR)buff, nMaxError);

::LocalFree(buff);

return true;
}