windows-xp/Source/XPSP1/NT/net/layer2svc/wlstore/api.c

//----------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 2001.
//
//  File:       api.c
//
//  Contents:   APIs exported to snapin to manage WIFI policy objects on AD
//
//
//  History:    TaroonM
//              10/30/01
//  
//  Remarks: Wireless Network Policy Management Currently doesnt support Registry based(local) policies. However we are 
//  keeping the Registry based code, for possible use later.
//----------------------------------------------------------------------------

#include "precomp.h"


DWORD
WirelessEnumPolicyData(
                       HANDLE hPolicyStore,
                       PWIRELESS_POLICY_DATA ** pppWirelessPolicyData,
                       PDWORD pdwNumPolicyObjects
                       )
{
    DWORD dwError = 0;
    DWORD dwProvider = 0;
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    IWbemServices *pWbemServices = NULL;
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)hPolicyStore;
    
    switch (pPolicyStore->dwProvider) {
        
    case WIRELESS_REGISTRY_PROVIDER:
         break;
        
    case WIRELESS_DIRECTORY_PROVIDER:
        dwError = DirEnumWirelessPolicyData(
            (pPolicyStore->hLdapBindHandle),
            pPolicyStore->pszWirelessRootContainer,
            pppWirelessPolicyData,
            pdwNumPolicyObjects
            );
        break;
        
        
    case WIRELESS_WMI_PROVIDER:
        dwError = CreateIWbemServices(
            pPolicyStore->pszLocationName,
            &pWbemServices
            );
        
        if(dwError == ERROR_SUCCESS) {
            dwError = WMIEnumPolicyDataEx(
                pWbemServices,
                pppWirelessPolicyData,
                pdwNumPolicyObjects
                );
            
            IWbemServices_Release(pWbemServices);
        }
        break;
        
        
    default:
        dwError = ERROR_INVALID_PARAMETER;
        break;
        
        
    }
    
    return(dwError);
}



DWORD
WirelessSetPolicyData(
                      HANDLE hPolicyStore,
                      PWIRELESS_POLICY_DATA pWirelessPolicyData
                      )
{
    DWORD dwError = 0;
    DWORD dwProvider = 0;
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    
    
    dwError = ValidateWirelessPolicyData(
        pWirelessPolicyData
        );
    BAIL_ON_WIN32_ERROR(dwError);
    
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)hPolicyStore;
    
    switch (pPolicyStore->dwProvider) {
    case WIRELESS_REGISTRY_PROVIDER:
        break;
        
    case WIRELESS_DIRECTORY_PROVIDER:
        dwError = DirSetWirelessPolicyData(
            (pPolicyStore->hLdapBindHandle),
            pPolicyStore->pszWirelessRootContainer,
            pWirelessPolicyData
            );
        break;
        
        
    case WIRELESS_WMI_PROVIDER:
        dwError = ERROR_NOT_SUPPORTED;
        break;
        
    default:
        dwError = ERROR_INVALID_PARAMETER;
        break;
        
    }

error:
   	
    return(dwError);
}



DWORD
WirelessCreatePolicyData(
                         HANDLE hPolicyStore,
                         PWIRELESS_POLICY_DATA pWirelessPolicyData
                         )
{
    
    DWORD dwError = 0;
    DWORD dwProvider = 0;
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    
    dwError = ValidateWirelessPolicyData(
        pWirelessPolicyData
    );
    
    BAIL_ON_WIN32_ERROR(dwError);
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)hPolicyStore;
    
    switch (pPolicyStore->dwProvider) {
    case WIRELESS_REGISTRY_PROVIDER:
    /*
    dwError = RegCreatePolicyData(
    (pPolicyStore->hRegistryKey),
    pPolicyStore->pszWirelessRootContainer,
    pWirelessPolicyData
    );
        */
        break;
        
    case WIRELESS_DIRECTORY_PROVIDER:
        dwError = DirCreateWirelessPolicyData(
            (pPolicyStore->hLdapBindHandle),
            pPolicyStore->pszWirelessRootContainer,
            pWirelessPolicyData
            );
        break;
        
        
    case WIRELESS_WMI_PROVIDER:
        dwError = ERROR_NOT_SUPPORTED;
        break;
        
        
    default:
        dwError = ERROR_INVALID_PARAMETER;
        break;
        
    }
    
error:
    
    return(dwError);
}


DWORD
WirelessDeletePolicyData(
                         HANDLE hPolicyStore,
                         PWIRELESS_POLICY_DATA pWirelessPolicyData
                         )
{
    DWORD dwError = 0;
    DWORD dwProvider = 0;
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)hPolicyStore;
    
    switch (pPolicyStore->dwProvider) {
    case WIRELESS_REGISTRY_PROVIDER:
        break;

    case WIRELESS_DIRECTORY_PROVIDER:
        dwError = DirDeleteWirelessPolicyData(
            (pPolicyStore->hLdapBindHandle),
            pPolicyStore->pszWirelessRootContainer,
            pWirelessPolicyData
            );
        break;
        
        
    case WIRELESS_WMI_PROVIDER:
        dwError = ERROR_NOT_SUPPORTED;
        break;
        
        
    default:
        dwError = ERROR_INVALID_PARAMETER;
        break;
        
    }
    
    return(dwError);
}
/*

pszGPO name contains the LDAP path of the GPO whose extesnion 
snapin is making this call.

*/



DWORD
WirelessGPOOpenPolicyStore(
                        LPWSTR pszMachineName,
                        DWORD dwTypeOfStore,
                        LPWSTR pszGPOName,
                        LPWSTR pszFileName,
                        HANDLE * phPolicyStore
                        )
{
    DWORD dwError = 0;
    
    
    switch (dwTypeOfStore) {
        
    case WIRELESS_REGISTRY_PROVIDER:
        break;
        
    case WIRELESS_DIRECTORY_PROVIDER:
        
        dwError = DirGPOOpenPolicyStore(
            pszMachineName,
            pszGPOName,
            phPolicyStore
            );
        break;
        
    case WIRELESS_FILE_PROVIDER:
        break;
        
        
        
    case WIRELESS_WMI_PROVIDER:
        
        dwError = WMIOpenPolicyStore(
            pszMachineName,
            phPolicyStore
            );
        break;
        
        
        
    default:
        
        dwError = ERROR_INVALID_PARAMETER;
        break;
        
    }
    
    return (dwError);
}


DWORD
DirGPOOpenPolicyStore(
                   LPWSTR pszMachineName,
                   LPWSTR pszGPOName,
                   HANDLE * phPolicyStore
                   )
{
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    DWORD dwError = 0;
    LPWSTR pszWirelessRootContainer = NULL;
    HLDAP hLdapBindHandle = NULL;
    LPWSTR pszDefaultDirectory = NULL;
    
    
    if (!pszMachineName || !*pszMachineName) {
        
        dwError = ComputeDefaultDirectory(
            &pszDefaultDirectory
            );
        BAIL_ON_WIN32_ERROR(dwError);
        
        dwError = OpenDirectoryServerHandle(
            pszDefaultDirectory,
            389,
            &hLdapBindHandle
            );
        BAIL_ON_WIN32_ERROR(dwError);
        
        dwError = ComputeGPODirLocationName(
            pszGPOName,
            &pszWirelessRootContainer
            );
        BAIL_ON_WIN32_ERROR(dwError);
        
    }
    else {
        
        dwError = OpenDirectoryServerHandle(
            pszMachineName,
            389,
            &hLdapBindHandle
            );
        BAIL_ON_WIN32_ERROR(dwError);
        
        dwError = ComputeGPODirLocationName(
            pszGPOName,
            &pszWirelessRootContainer
            );
        BAIL_ON_WIN32_ERROR(dwError);
        
    }
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)AllocPolMem(
        sizeof(WIRELESS_POLICY_STORE)
        );
    if (!pPolicyStore) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    pPolicyStore->dwProvider = WIRELESS_DIRECTORY_PROVIDER;
    pPolicyStore->hParentRegistryKey = NULL;
    pPolicyStore->hRegistryKey = NULL;
    pPolicyStore->pszLocationName = NULL;
    pPolicyStore->hLdapBindHandle = hLdapBindHandle;
    pPolicyStore->pszWirelessRootContainer = pszWirelessRootContainer;
    pPolicyStore->pszFileName = NULL;
    
    *phPolicyStore = pPolicyStore;
    
cleanup:
    
    if (pszDefaultDirectory) {
        FreePolStr(pszDefaultDirectory);
    }
    
    return(dwError);
    
error:
    
    if (hLdapBindHandle) {
        CloseDirectoryServerHandle(hLdapBindHandle);
    }
    
    if (pszWirelessRootContainer) {
        FreePolStr(pszWirelessRootContainer);
    }
    
    if (pPolicyStore) {
        FreePolMem(pPolicyStore);
    }
    
    *phPolicyStore = NULL;
    
    goto cleanup;
}

DWORD
WirelessClosePolicyStore(
                         HANDLE hPolicyStore
                         )
{
    DWORD dwError = 0;
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)hPolicyStore;
    
    switch (pPolicyStore->dwProvider) {
        
    case WIRELESS_REGISTRY_PROVIDER:
        
        break;
        
    case WIRELESS_DIRECTORY_PROVIDER:
        
        if (pPolicyStore->hLdapBindHandle) {
            CloseDirectoryServerHandle(
                pPolicyStore->hLdapBindHandle
                );
        }
        
        if (pPolicyStore->pszWirelessRootContainer) {
            FreePolStr(pPolicyStore->pszWirelessRootContainer);
        }
        
        break;
        
    case WIRELESS_FILE_PROVIDER:
        
        break;
        
    default:
        
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_WIN32_ERROR(dwError);
        break;
        
    }
    
    if (pPolicyStore) {
        FreePolMem(pPolicyStore);
    }
    
error:
    
    return(dwError);
}

                                                                

                                                        
DWORD
ComputeGPODirLocationName(
                       LPWSTR pszDirDomainName,
                       LPWSTR * ppszDirFQPathName
                       )
{
    DWORD dwError = 0;
    WCHAR szName[MAX_PATH];
    LPWSTR pszDirFQPathName = NULL;
    DWORD dwDirDomainNameLen = 0;
    DWORD dwDirLocationNameLen = 0;
    DWORD dwTotalLen = 0;
    
    szName[0] = L'\0';
    wcscpy(szName, L"CN=Wireless, CN=Windows,CN=Microsoft,");

    dwDirDomainNameLen = wcslen(pszDirDomainName);
    dwDirLocationNameLen = wcslen(szName);
    dwTotalLen = dwDirDomainNameLen+dwDirLocationNameLen;
    
    pszDirFQPathName = AllocPolMem((dwTotalLen+1) * sizeof(WCHAR));
    if (!pszDirFQPathName) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    wcsncpy(pszDirFQPathName, szName, dwDirLocationNameLen);
    wcsncat(pszDirFQPathName, pszDirDomainName, dwDirDomainNameLen);
    pszDirFQPathName[dwTotalLen] = L'\0';
    
    *ppszDirFQPathName = pszDirFQPathName;
    
    return (dwError);
    
error:
    
    *ppszDirFQPathName = NULL;
    return(dwError);

}

/*
Helper Function: Set PS in a Policy Structure
*/
                                                        
DWORD
WirelessSetPSDataInPolicy(
                          PWIRELESS_POLICY_DATA pWirelessPolicyData,
                          PWIRELESS_PS_DATA pWirelessPSData
                          )
{
    DWORD dwError = 0;
    DWORD dwPSId = -1;
    
    WirelessPolicyPSId(pWirelessPolicyData,
        pWirelessPSData->pszWirelessSSID,
        &dwPSId
        );
    
    if (dwPSId == -1) {
        dwError = ERROR_PS_NOT_PRESENT;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    dwError = ModifyWirelessPSData(
        pWirelessPolicyData->ppWirelessPSData[dwPSId],
        pWirelessPSData
        );
    BAIL_ON_WIN32_ERROR(dwError);
    
    dwError = ERROR_SUCCESS;
    return(dwError);
    
error:
    return(dwError);
}


DWORD
WirelessAddPSToPolicy(
                      PWIRELESS_POLICY_DATA pWirelessPolicyData,
                      PWIRELESS_PS_DATA pWirelessPSData
                      )
{
    DWORD dwNumPreferredSettings = 0;
    DWORD dwError = 0;
    PWIRELESS_PS_DATA *ppWirelessPSData=NULL;
    PWIRELESS_PS_DATA *ppNewWirelessPSData=NULL;
    DWORD i = 0;
    DWORD dwInsertIndex = 0;
    DWORD dwNumAPNetworks = 0;
    
    dwNumPreferredSettings = pWirelessPolicyData->dwNumPreferredSettings;
    dwNumAPNetworks = pWirelessPolicyData->dwNumAPNetworks;
    ppWirelessPSData = pWirelessPolicyData->ppWirelessPSData;
    
    ppNewWirelessPSData = (PWIRELESS_PS_DATA *)
        AllocPolMem(sizeof(PWIRELESS_PS_DATA)*(dwNumPreferredSettings+1));
    
    if(!ppNewWirelessPSData) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    if(pWirelessPSData->dwNetworkType == WIRELESS_NETWORK_TYPE_ADHOC) {
        dwInsertIndex = dwNumPreferredSettings;
    } else
    {
        dwInsertIndex = dwNumAPNetworks;
        pWirelessPolicyData->dwNumAPNetworks = dwNumAPNetworks+1;
    }
    
    
    for (i = 0; i < dwInsertIndex; ++i)
    {
        ppNewWirelessPSData[i] = ppWirelessPSData[i];
    }
    
    ppNewWirelessPSData[dwInsertIndex] = pWirelessPSData;
    pWirelessPSData->dwId = dwInsertIndex;
    
    for (i = dwInsertIndex; i < dwNumPreferredSettings; ++i) {
        ppNewWirelessPSData[i+1] = ppWirelessPSData[i];
        ppNewWirelessPSData[i+1]->dwId = i+1;
    }
    
    
    pWirelessPolicyData->dwNumPreferredSettings = dwNumPreferredSettings+1;
    pWirelessPolicyData->ppWirelessPSData = ppNewWirelessPSData;
    
    FreePolMem(ppWirelessPSData);
    
    return(0);
    
error:
    return(dwError);
    
}

DWORD
WirelessRemovePSFromPolicy(
                           PWIRELESS_POLICY_DATA pWirelessPolicyData,
                           LPCWSTR pszSSID
                           )
{
    DWORD dwNumPreferredSettings = 0;
    DWORD dwError = 0;
    PWIRELESS_PS_DATA *ppWirelessPSData;
    PWIRELESS_PS_DATA *ppNewWirelessPSData;
    DWORD i = 0;
    DWORD dwPSId;
    
    dwNumPreferredSettings = pWirelessPolicyData->dwNumPreferredSettings;
    ppWirelessPSData = pWirelessPolicyData->ppWirelessPSData;
    
    WirelessPolicyPSId(pWirelessPolicyData,pszSSID,&dwPSId);
    
    if(dwPSId == -1)
    {
        dwError = ERROR_PS_NOT_PRESENT;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    ppNewWirelessPSData = (PWIRELESS_PS_DATA *)
        AllocPolMem(sizeof(PWIRELESS_PS_DATA)*(dwNumPreferredSettings-1));
    
    if(!ppNewWirelessPSData) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    
    for(i = 0; i < dwPSId; ++i)
    {
        ppNewWirelessPSData[i] = ppWirelessPSData[i];
    }
    
    for(i = dwPSId; i < dwNumPreferredSettings-1; ++i)
    {
        ppNewWirelessPSData[i] = ppWirelessPSData[i+1];
    }
    
    pWirelessPolicyData->dwNumPreferredSettings = dwNumPreferredSettings-1;
    pWirelessPolicyData->ppWirelessPSData = ppNewWirelessPSData;
    
    FreePolMem(ppWirelessPSData);
    
    return(0);
    
error:
    return(dwError);
    
}

DWORD
WirelessRemovePSFromPolicyId(
                             PWIRELESS_POLICY_DATA pWirelessPolicyData,
                             DWORD dwId
                             )
{
    DWORD dwNumPreferredSettings = 0;
    DWORD dwError = 0;
    PWIRELESS_PS_DATA *ppWirelessPSData;
    PWIRELESS_PS_DATA *ppNewWirelessPSData;
    DWORD i = 0;
    DWORD dwPSId;
    
    dwNumPreferredSettings = pWirelessPolicyData->dwNumPreferredSettings;
    ppWirelessPSData = pWirelessPolicyData->ppWirelessPSData;
    
    
    if(dwId >= dwNumPreferredSettings )
    {
        dwError = ERROR_PS_NOT_PRESENT;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    ppNewWirelessPSData = (PWIRELESS_PS_DATA *)
        AllocPolMem(sizeof(PWIRELESS_PS_DATA)*(dwNumPreferredSettings-1));
    
    if(!ppNewWirelessPSData) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    
    for(i = 0; i < dwId; ++i)
    {
        ppNewWirelessPSData[i] = ppWirelessPSData[i];
    }
    
    if (ppWirelessPSData[dwId]->dwNetworkType == WIRELESS_NETWORK_TYPE_AP) {
        pWirelessPolicyData->dwNumAPNetworks--;
    }
    
    for(i = dwId; i < dwNumPreferredSettings-1; ++i)
    {
        ppNewWirelessPSData[i] = ppWirelessPSData[i+1];
        ppNewWirelessPSData[i]->dwId = i;
    }
    
    pWirelessPolicyData->dwNumPreferredSettings = dwNumPreferredSettings-1;
    pWirelessPolicyData->ppWirelessPSData = ppNewWirelessPSData;
    
    FreePolMem(ppWirelessPSData);
    
    return(0);
    
error:
    return(dwError);
    
}

void
WirelessPolicyPSId(PWIRELESS_POLICY_DATA pWirelessPolicyData, LPCWSTR pszSSID, DWORD *dwId)
{
    
    DWORD dwError=0;
    DWORD dwNumPreferredSettings;
    DWORD dwSSIDLen = 0;
    DWORD i = 0;
    DWORD dwCompare = 1;
    DWORD dwPId = -1;
    PWIRELESS_PS_DATA *ppWirelessPSData;
    PWIRELESS_PS_DATA pWirelessPSData;
    
    
    dwSSIDLen = lstrlenW(pszSSID);
    dwNumPreferredSettings = pWirelessPolicyData->dwNumPreferredSettings;
    ppWirelessPSData = pWirelessPolicyData->ppWirelessPSData;
    
    for(i = 0; i < dwNumPreferredSettings; ++i) {
        pWirelessPSData = ppWirelessPSData[i];
        if(pWirelessPSData->dwWirelessSSIDLen == dwSSIDLen)
        {
            dwCompare = memcmp(pWirelessPSData->pszWirelessSSID,pszSSID,dwSSIDLen*2);
        }
        if (dwCompare == 0) {
            dwPId = i;
            break;
        }
    }
    *dwId = dwPId;
    return;
    
}

void
UpdateWirelessPSData(
                     PWIRELESS_PS_DATA pWirelessPSData
                     )
{
    DWORD dwDescriptionLen = 0;
    DWORD dwEAPDataLen = 0;
    DWORD dwWirelessSSIDLen = 0;
    DWORD dwPSLen = 0;
    
    // may be replace it with actual counting.
    
    dwWirelessSSIDLen  = lstrlenW(pWirelessPSData->pszWirelessSSID);
    dwDescriptionLen = lstrlenW(pWirelessPSData->pszDescription);
    //dwPSLen = 20 * sizeof(DWORD) + 32*2 + 2 * dwDescriptionLen;
    dwEAPDataLen = pWirelessPSData->dwEAPDataLen;
    dwPSLen = (sizeof(WIRELESS_PS_DATA) - sizeof(DWORD) - sizeof(LPWSTR)) + sizeof(WCHAR) * dwDescriptionLen
        - sizeof(LPBYTE) + dwEAPDataLen;
    pWirelessPSData->dwPSLen = dwPSLen;
    pWirelessPSData->dwWirelessSSIDLen = 
        (dwWirelessSSIDLen < 32) ? dwWirelessSSIDLen : 32;
    pWirelessPSData->dwDescriptionLen = dwDescriptionLen;
}





DWORD
WMIOpenPolicyStore(
                   LPWSTR pszMachineName,
                   HANDLE * phPolicyStore
                   )
{
    PWIRELESS_POLICY_STORE pPolicyStore = NULL;
    DWORD dwError = 0;
    
    pPolicyStore = (PWIRELESS_POLICY_STORE)AllocPolMem(
        sizeof(WIRELESS_POLICY_STORE)
        );
    if (!pPolicyStore) {
        dwError = ERROR_OUTOFMEMORY;
        BAIL_ON_WIN32_ERROR(dwError);
    }
    
    pPolicyStore->dwProvider = WIRELESS_WMI_PROVIDER;
    pPolicyStore->hParentRegistryKey = NULL;
    pPolicyStore->hRegistryKey = NULL;
    pPolicyStore->pszLocationName = pszMachineName;
    pPolicyStore->hLdapBindHandle = NULL;
    pPolicyStore->pszWirelessRootContainer = NULL;
    pPolicyStore->pszFileName = NULL;
    
    *phPolicyStore = pPolicyStore;
    
cleanup:
    
    return(dwError);
    
error:
    
    if (pPolicyStore) {
        FreePolMem(pPolicyStore);
    }
    
    *phPolicyStore = NULL;
    
    goto cleanup;
}


HRESULT
WirelessWriteDirectoryPolicyToWMI(
                          LPWSTR pszMachineName,
                          LPWSTR pszPolicyDN,
                          PGPO_INFO pGPOInfo,
                          IWbemServices *pWbemServices
                          )
{
    DWORD dwError = 0;
    HRESULT hr = S_OK;
    PWIRELESS_POLICY_OBJECT pWirelessPolicyObject = NULL;
    BOOL bDeepRead = FALSE;

    if (!pWbemServices
    	|| !pszPolicyDN
    	|| !pGPOInfo
    	)
    {
        hr = E_INVALIDARG;
        BAIL_ON_HRESULT_ERROR(hr);
    }

    
    bDeepRead = (pGPOInfo->uiPrecedence == 1);
    
    hr = ReadPolicyObjectFromDirectoryEx(
        pszMachineName,
        pszPolicyDN,
        bDeepRead,
        &pWirelessPolicyObject
        );
    BAIL_ON_HRESULT_ERROR(hr);
    
    hr = WritePolicyObjectDirectoryToWMI(
        pWbemServices,
        pWirelessPolicyObject,
        pGPOInfo
        );
    BAIL_ON_HRESULT_ERROR(hr);
    
error:

    if (pWirelessPolicyObject) {
    	FreeWirelessPolicyObject(pWirelessPolicyObject);
    	}
    
    return(hr);
}


HRESULT
WirelessClearWMIStore(
    IWbemServices *pWbemServices
    )
{
    HRESULT hr = S_OK;
    
    if (!pWbemServices) {
        hr = E_INVALIDARG;
        BAIL_ON_HRESULT_ERROR(hr);
    }

    hr = DeleteWMIClassObject(
        pWbemServices,
        WIRELESS_RSOP_CLASSNAME
        );
    BAIL_ON_HRESULT_ERROR(hr);

 error:
    return(hr);
}