在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;
}