自学教程：C++ BAIL_ON_LSA_ERROR函数代码示例

DWORDNtlmClientExportSecurityContext(    IN PNTLM_CONTEXT_HANDLE phContext,    IN DWORD fFlags,    OUT PSecBuffer pPackedContext    ){    DWORD dwError = LW_ERROR_SUCCESS;    BAIL_ON_INVALID_POINTER(phContext);    dwError = NtlmTransactExportSecurityContext(        *phContext,        fFlags,        pPackedContext);    BAIL_ON_LSA_ERROR(dwError);error:    return(dwError);}

DWORDLocalCheckForModifyAccess(    HANDLE hProvider    ){    DWORD dwError = 0;    BOOLEAN bIsAdmin = FALSE;    dwError = LocalCheckIsAdministrator(hProvider, &bIsAdmin);    BAIL_ON_LSA_ERROR(dwError);    if (!bIsAdmin)    {        dwError = LW_ERROR_ACCESS_DENIED;    }error:    return dwError;}

staticDWORDParseArgs(    int argc,    char *argv[],    PSTR *ppszSid    ){    DWORD dwError = 0;    PSTR pszSid = NULL;    if (argc < 2) {        dwError = LW_ERROR_INVALID_PARAMETER;        ShowUsage();        exit(1);    }    if (strcmp(argv[1], "--help") == 0 ||        strcmp(argv[1], "-h") == 0)    {        ShowUsage();        exit(0);    }    dwError = LwAllocateString(argv[1], &pszSid);    BAIL_ON_LSA_ERROR(dwError);    *ppszSid = pszSid;cleanup:    return dwError;error:    if (pszSid) {        LW_SAFE_FREE_STRING(pszSid);    }    *ppszSid = NULL;    goto cleanup;}

DWORDLsaTraceUnsetFlag(    DWORD dwTraceFlag    ){    DWORD dwError = 0;    if (!gpTraceFlags)    {        dwError = LW_ERROR_TRACE_NOT_INITIALIZED;        BAIL_ON_LSA_ERROR(dwError);    }    dwError = LsaBitVectorUnsetBit(                    gpTraceFlags,                    dwTraceFlag);error:    return dwError;}

staticDWORDParseTraceFlag(    PCSTR  pszArg,    PDWORD pdwTraceFlag    ){    DWORD dwError = 0;    DWORD dwTraceFlag = 0;    if (!strcasecmp(pszArg, LSA_TRACE_FLAG_USER_GROUP_QUERIES_TEXT))    {       dwTraceFlag = LSA_TRACE_FLAG_USER_GROUP_QUERIES;    }    else if (!strcasecmp(pszArg, LSA_TRACE_FLAG_AUTHENTICATION_TEXT))    {       dwTraceFlag = LSA_TRACE_FLAG_AUTHENTICATION;    }    else if (!strcasecmp(pszArg, LSA_TRACE_FLAG_USER_GROUP_ADMINISTRATION_TEXT))    {       dwTraceFlag = LSA_TRACE_FLAG_USER_GROUP_ADMINISTRATION;    }    else    {       dwError = LW_ERROR_INVALID_PARAMETER;       BAIL_ON_LSA_ERROR(dwError);    }    *pdwTraceFlag = dwTraceFlag;cleanup:    return dwError;error:    *pdwTraceFlag = 0;    goto cleanup;}

DWORDADNonSchemaKeywordGetString(    PSTR *ppszValues,    DWORD dwNumValues,    PCSTR pszAttributeName,    PSTR *ppszResult    ){    DWORD dwError = 0;    size_t i;    size_t sNameLen = strlen(pszAttributeName);    PSTR pszResult = NULL;    for (i = 0; i < dwNumValues; i++)    {        PCSTR pszValue = ppszValues[i];        // Look for ldap values which are in the form <attributename>=<value>        if (!strncasecmp(pszValue, pszAttributeName, sNameLen) &&                pszValue[sNameLen] == '=')        {            dwError = LwAllocateString(                        pszValue + sNameLen + 1,                        &pszResult);            BAIL_ON_LSA_ERROR(dwError);            break;        }    }    *ppszResult = pszResult;cleanup:    return dwError;error:    *ppszResult = NULL;    LW_SAFE_FREE_STRING(pszResult);    goto cleanup;}

staticDWORDSetQueryType(    LSA_QUERY_TYPE type    ){    DWORD dwError = 0;    if (gState.QueryType != LSA_QUERY_TYPE_UNDEFINED)    {        dwError = LW_ERROR_INVALID_PARAMETER;        BAIL_ON_LSA_ERROR(dwError);    }    else    {        gState.QueryType = type;    }error:    return dwError;}

DWORDLsaDataBlobCopy(    PLSA_DATA_BLOB *ppDst,    PLSA_DATA_BLOB pSrc    ){    DWORD dwError = LW_ERROR_INTERNAL;    BAIL_ON_INVALID_POINTER(ppDst);    BAIL_ON_INVALID_POINTER(pSrc);    dwError = LsaDataBlobStore(ppDst,                               pSrc->dwLen,                               pSrc->pData);    BAIL_ON_LSA_ERROR(dwError);cleanup:    return dwError;    error:    goto cleanup;    }

staticDWORDLocalCfgSetDefaultLoginShell(    PLOCAL_CONFIG pConfig,    PCSTR          pszName,    PCSTR          pszValue    ){    DWORD dwError = 0;    PSTR pszLoginShell = NULL;    if (LW_IS_NULL_OR_EMPTY_STR(pszValue))    {        goto error;    }    if (access(pszValue, X_OK) != 0)    {        LSA_LOG_ERROR("Invalid login shell [%s]", pszValue);        goto error;    }    dwError = LwAllocateString(pszValue, &pszLoginShell);    BAIL_ON_LSA_ERROR(dwError);    LW_SAFE_FREE_STRING(pConfig->pszLoginShell);    pConfig->pszLoginShell = pszLoginShell;    pszLoginShell = NULL;cleanup:    return dwError;error:    LW_SAFE_FREE_STRING(pszLoginShell);    goto cleanup;}

NTSTATUSLsaSrvAddPrivilegesToAccount(    /* [in] */ handle_t hBinding,    /* [in] */ LSAR_ACCOUNT_HANDLE hAccount,    /* [in] */ PPRIVILEGE_SET pPrivileges    ){    NTSTATUS ntStatus = STATUS_SUCCESS;    DWORD err = ERROR_SUCCESS;    PLSAR_ACCOUNT_CONTEXT pAccountCtx = (PLSAR_ACCOUNT_CONTEXT)hAccount;    PPOLICY_CONTEXT pPolicyCtx = NULL;    BAIL_ON_INVALID_PTR(hAccount);    BAIL_ON_INVALID_PTR(pPrivileges);    if (pAccountCtx->Type != LsaContextAccount)    {        ntStatus = STATUS_INVALID_HANDLE;        BAIL_ON_NT_STATUS(ntStatus);    }    pPolicyCtx = pAccountCtx->pPolicyCtx;    err = LsaSrvPrivsAddPrivilegesToAccount(                        NULL,                        pPolicyCtx->pUserToken,                        pAccountCtx->pAccountContext,                        pPrivileges);    BAIL_ON_LSA_ERROR(err);error:    if (ntStatus == STATUS_SUCCESS &&        err != ERROR_SUCCESS)    {        ntStatus = LwWin32ErrorToNtStatus(err);    }    return ntStatus;}

DWORDLsaValidateGroupName(    PCSTR pszName    ){    DWORD dwError = 0;    size_t sNameLen = 0;    sNameLen = strlen(pszName);    if (sNameLen > LSA_MAX_GROUP_NAME_LENGTH || sNameLen == 0)    {        dwError = LW_ERROR_INVALID_GROUP_NAME;        BAIL_ON_LSA_ERROR(dwError);    }cleanup:    return dwError;error:    goto cleanup;}

DWORDSamDbBuildDirectoryContext(    PSAMDB_OBJECTCLASS_TO_ATTR_MAP_INFO pObjectClassAttrMaps,    DWORD                               dwNumObjectClassAttrMaps,    PSAM_DB_ATTR_LOOKUP                 pAttrLookup,    PSAM_DIRECTORY_CONTEXT*             ppDirContext    ){    DWORD dwError = 0;    PSAM_DIRECTORY_CONTEXT pDirContext = NULL;    dwError = DirectoryAllocateMemory(                    sizeof(SAM_DIRECTORY_CONTEXT),                    (PVOID*)&pDirContext);    BAIL_ON_SAMDB_ERROR(dwError);    pDirContext->pObjectClassAttrMaps = pObjectClassAttrMaps;    pDirContext->dwNumObjectClassAttrMaps = dwNumObjectClassAttrMaps;    pDirContext->pAttrLookup = pAttrLookup;    dwError = SamDbAcquireDbContext(&pDirContext->pDbContext);    BAIL_ON_LSA_ERROR(dwError);    *ppDirContext = pDirContext;cleanup:    return dwError;error:    if (pDirContext)    {        SamDbFreeDirectoryContext(pDirContext);    }    *ppDirContext = NULL;    goto cleanup;}

staticDWORDLsaAdBatchMarshalGroupInfo(    IN PAD_PROVIDER_DATA pProviderData,    IN OUT PLSA_AD_BATCH_ITEM_GROUP_INFO pGroupInfo,    OUT PLSA_SECURITY_OBJECT_GROUP_INFO pObjectGroupInfo,    IN PCSTR pszDnsDomainName,    IN PCSTR pszNetbiosDomainName,    IN PCSTR pszSamAccountName,    IN PCSTR pszSid    ){    DWORD dwError = 0;    if (LsaAdBatchIsUnprovisionedMode(pProviderData))    {        dwError = LsaAdBatchMarshalUnprovisionedGroup(                        pProviderData,                        pGroupInfo,                        pszDnsDomainName,                        pszNetbiosDomainName,                        pszSamAccountName,                        pszSid);        BAIL_ON_LSA_ERROR(dwError);    }    pObjectGroupInfo->gid = pGroupInfo->gid;    LSA_XFER_STRING(pGroupInfo->pszAlias, pObjectGroupInfo->pszAliasName);    LSA_XFER_STRING(pGroupInfo->pszPasswd, pObjectGroupInfo->pszPasswd);cleanup:    return dwError;error:    goto cleanup;}

DWORDADGetDomainQualifiedString(    PCSTR pszNetBIOSDomainName,    PCSTR pszName,    PSTR* ppszQualifiedName    ){    DWORD dwError = 0;    PSTR  pszQualifiedName = NULL;    dwError = LwAllocateStringPrintf(                    &pszQualifiedName,                    "%s%c%s",                    pszNetBIOSDomainName,                    LsaSrvDomainSeparator(),                    pszName);    BAIL_ON_LSA_ERROR(dwError);    LwStrnToUpper(pszQualifiedName, strlen(pszNetBIOSDomainName));    LwStrToLower(pszQualifiedName + strlen(pszNetBIOSDomainName) + 1);    *ppszQualifiedName = pszQualifiedName;cleanup:    return dwError;error:    *ppszQualifiedName = NULL;    LW_SAFE_FREE_STRING(pszQualifiedName);    goto cleanup;}

DWORDLsaDataBlobStore(    PLSA_DATA_BLOB *ppBlob,    DWORD dwSize,    const PBYTE pBuffer    ){    DWORD dwError = LW_ERROR_INTERNAL;    BAIL_ON_INVALID_POINTER(ppBlob);    dwError = LsaDataBlobAllocate(ppBlob, dwSize);    BAIL_ON_LSA_ERROR(dwError);    if (dwSize > 0) {                memcpy((*ppBlob)->pData, pBuffer, dwSize);    }    cleanup:    return dwError;    error:    goto cleanup;    }

DWORDLsaPcacheGetMachinePasswordInfoW(    IN LSA_MACHINEPWD_CACHE_HANDLE pPcache,    OUT PLSA_MACHINE_PASSWORD_INFO_W* ppPasswordInfo    ){    DWORD dwError = 0;    BOOLEAN bInLock = FALSE;    PLSA_MACHINE_PASSWORD_INFO_W pPasswordInfo = NULL;    dwError = LsaPcachepEnsurePasswordInfoAndLock(pPcache);    BAIL_ON_LSA_ERROR(dwError);    bInLock = TRUE;    pPasswordInfo = &pPcache->pEntry->PasswordInfoW;    LwInterlockedIncrement(&pPcache->pEntry->RefCount);error:    if (bInLock)    {        PTHREAD_CALL_MUST_SUCCEED(pthread_rwlock_unlock(pPcache->pStateLock));    }    if (dwError)    {        if (pPasswordInfo)        {            LsaPcacheReleaseMachinePasswordInfoW(pPasswordInfo);            pPasswordInfo = NULL;        }    }    *ppPasswordInfo = pPasswordInfo;    return dwError;}

staticDWORDValidateParameters(    PCSTR pszName    ){    DWORD dwError = 0;    BAIL_ON_INVALID_STRING(pszName);    if (strlen(pszName) > 15)    {        fprintf(stdout, "Machine name can have up to 15 characters/n");        dwError = LW_ERROR_INVALID_PARAMETER;        BAIL_ON_LSA_ERROR(dwError);    }cleanup:    return dwError;error:    goto cleanup;}

staticDWORDLsaSrvAuthProviderAllocateProviderList(    PLSA_AUTH_PROVIDER *ppProviderList    ){    DWORD dwError = 0;    PSTR pszLoadOrder = NULL; // Multistring    PCSTR pszProvider = NULL;    PSTR pszProviderKey = NULL;    PLSA_AUTH_PROVIDER pProvider = NULL;    PLSA_AUTH_PROVIDER pProviderList = NULL;    dwError = LsaSrvAuthProviderRegGetLoadOrder(&pszLoadOrder);    BAIL_ON_LSA_ERROR(dwError);    if (!pszLoadOrder)    {        /* We should only get here if there is some problem with the         * registry -- can't access it, the key isn't there, ...         * -- so we will try a default set of providers.         */        LSA_LOG_ERROR("Problem accessing provider configuration in registry. Trying compiled defaults [ActiveDirectory, Local].");        dwError = LsaSrvAllocateProvider(                    LSA_PROVIDER_TAG_AD,                    LSA_PROVIDER_PATH_AD,                    &pProvider);        BAIL_ON_LSA_ERROR(dwError);        if (pProvider)        {            LsaSrvAppendAuthProviderList(&pProviderList, pProvider);            pProvider = NULL;        }        dwError = LsaSrvAllocateProvider(                    LSA_PROVIDER_TAG_LOCAL,                    LSA_PROVIDER_PATH_LOCAL,                    &pProvider);        BAIL_ON_LSA_ERROR(dwError);        if (pProvider)        {            LsaSrvAppendAuthProviderList(&pProviderList, pProvider);            pProvider = NULL;        }    }    else    {        pszProvider = pszLoadOrder;        while ( pszProvider != NULL && *pszProvider != '/0' )        {            dwError = LwAllocateStringPrintf(                        &pszProviderKey,                        "Services//lsass//Parameters//Providers//%s",                        pszProvider);            BAIL_ON_LSA_ERROR(dwError);            dwError = LsaSrvAuthLoadProvider(                        pszProvider,                        pszProviderKey,                        &pProvider);            BAIL_ON_LSA_ERROR(dwError);            if (pProvider)            {                LsaSrvAppendAuthProviderList(&pProviderList, pProvider);                pProvider = NULL;            }            LW_SAFE_FREE_STRING(pszProviderKey);            pszProvider = pszProvider + strlen(pszProvider) + 1;        }    }cleanup:    *ppProviderList = pProviderList;    LW_SAFE_FREE_MEMORY(pszLoadOrder);    LW_SAFE_FREE_STRING(pszProviderKey);    return dwError;error:    LsaSrvFreeAuthProviderList(pProviderList);    pProviderList = NULL;    goto cleanup;}

DWORDLsaSrvInitAuthProviders(    IN OPTIONAL PLSA_STATIC_PROVIDER pStaticProviders    ){    DWORD dwError = 0;    PLSA_AUTH_PROVIDER pUninitializedProviderList = NULL;    PLSA_AUTH_PROVIDER pProviderList = NULL;    PLSA_AUTH_PROVIDER pProvider = NULL;    BOOLEAN bInLock = FALSE;    dwError = LsaSrvAuthProviderAllocateProviderList(                &pUninitializedProviderList);    BAIL_ON_LSA_ERROR(dwError);    while(pUninitializedProviderList)    {        pProvider = pUninitializedProviderList;        pUninitializedProviderList = pUninitializedProviderList->pNext;        pProvider->pNext = NULL;        dwError = LsaSrvInitAuthProvider(pProvider, pStaticProviders);        if (dwError)        {            LSA_LOG_ERROR("Failed to load provider '%s' from '%s' - error %u (%s)",                LSA_SAFE_LOG_STRING(pProvider->pszId),                LSA_SAFE_LOG_STRING(pProvider->pszProviderLibpath),                dwError,                LwWin32ExtErrorToName(dwError));            LsaSrvFreeAuthProvider(pProvider);            pProvider = NULL;            dwError = 0;        }        else        {            LsaSrvAppendAuthProviderList(&pProviderList, pProvider);            pProvider = NULL;        }    }    ENTER_AUTH_PROVIDER_LIST_WRITER_LOCK(bInLock);    LsaSrvFreeAuthProviderList(gpAuthProviderList);    gpAuthProviderList = pProviderList;    pProviderList = NULL;    LEAVE_AUTH_PROVIDER_LIST_WRITER_LOCK(bInLock);cleanup:    if (pUninitializedProviderList)    {        LsaSrvFreeAuthProviderList(pUninitializedProviderList);    }    return dwError;error:    if (pProviderList) {        LsaSrvFreeAuthProviderList(pProviderList);    }    goto cleanup;}

staticDWORDLsaSrvAuthLoadProvider(    PCSTR   pszProviderName,    PCSTR   pszProviderKey,    PLSA_AUTH_PROVIDER *ppProvider    ){    DWORD dwError = 0;    PSTR pszId = NULL;    PSTR pszPath = NULL;    PLSA_AUTH_PROVIDER pProvider = NULL;    LWREG_CONFIG_ITEM Config[] =    {        {           "Id",           FALSE,           LwRegTypeString,           0,           MAXDWORD,           NULL,           &pszId,           NULL        },        {           "Path",           FALSE,           LwRegTypeString,           0,           MAXDWORD,           NULL,           &pszPath,           NULL        },    };    dwError = RegProcessConfig(                pszProviderKey,                pszProviderKey,                Config,                sizeof(Config)/sizeof(Config[0]));    BAIL_ON_LSA_ERROR(dwError);    if (LW_IS_NULL_OR_EMPTY_STR(pszId))    {        goto error;    }    if (LW_IS_NULL_OR_EMPTY_STR(pszPath))    {        goto error;    }    dwError = LsaSrvAllocateProvider(pszId, pszPath, &pProvider);    BAIL_ON_LSA_ERROR(dwError);cleanup:    *ppProvider = pProvider;    LW_SAFE_FREE_STRING(pszId);    LW_SAFE_FREE_STRING(pszPath);    return dwError;error:    if (pProvider)    {        LsaSrvFreeAuthProvider(pProvider);        pProvider = NULL;    }    goto cleanup;}

intset_machine_sid_main(    int argc,    char* argv[]    ){    DWORD dwError = 0;    PSTR pszMachineSid = NULL;    size_t dwErrorBufferSize = 0;    BOOLEAN bPrintOrigError = TRUE;    if (geteuid() != 0) {        fprintf(stderr, "This program requires super-user privileges./n");        dwError = LW_ERROR_ACCESS_DENIED;        BAIL_ON_LSA_ERROR(dwError);    }    dwError = ParseArgs(argc, argv,                        &pszMachineSid);    BAIL_ON_LSA_ERROR(dwError);    dwError = ValidateParameters(pszMachineSid);    BAIL_ON_LSA_ERROR(dwError);    dwError = SetMachineSid(pszMachineSid);    BAIL_ON_LSA_ERROR(dwError);cleanup:    if (pszMachineSid) {        LW_SAFE_FREE_STRING(pszMachineSid);    }    return dwError;error:    dwError = MapErrorCode(dwError);    dwErrorBufferSize = LwGetErrorString(dwError, NULL, 0);    if (dwErrorBufferSize > 0)    {        DWORD dwError2 = 0;        PSTR  pszErrorBuffer = NULL;        dwError2 = LwAllocateMemory(                     dwErrorBufferSize,                     (PVOID*)&pszErrorBuffer);        if (!dwError2)        {            DWORD dwLen = 0;            dwLen = LwGetErrorString(dwError,                                      pszErrorBuffer,                                      dwErrorBufferSize);            if ((dwLen == dwErrorBufferSize) &&                !LW_IS_NULL_OR_EMPTY_STR(pszErrorBuffer))            {                fprintf(stderr,                        "Failed to modify SID.  Error code %u (%s)./n%s/n",                        dwError,                        LW_PRINTF_STRING(LwWin32ExtErrorToName(dwError)),                        pszErrorBuffer);                bPrintOrigError = FALSE;            }        }        LW_SAFE_FREE_STRING(pszErrorBuffer);    }    if (bPrintOrigError)    {        fprintf(stderr,                "Failed to modify SID.  Error code %u (%s)./n",                dwError,                LW_PRINTF_STRING(LwWin32ExtErrorToName(dwError)));    }    goto cleanup;}

DWORDLsaSrvInitAuthProvider(    IN PLSA_AUTH_PROVIDER pProvider,    IN OPTIONAL PLSA_STATIC_PROVIDER pStaticProviders    ){    DWORD dwError = 0;    PFNINITIALIZEPROVIDER pfnInitProvider = NULL;    PCSTR pszError = NULL;    PSTR pszProviderLibpath = NULL;    int i = 0;    if (pStaticProviders)    {        /* First look for a static provider entry with the given name */        for (i = 0; pStaticProviders[i].pszId; i++)        {            if (!strcmp(pStaticProviders[i].pszId, pProvider->pszId))            {                pfnInitProvider = pStaticProviders[i].pInitialize;                LSA_LOG_DEBUG("Provider %s loaded from static list", pProvider->pszId);                break;            }        }    }    if (!pfnInitProvider)    {        /* Try to load the provider dynamically */        if (LW_IS_NULL_OR_EMPTY_STR(pProvider->pszProviderLibpath))        {            dwError = LW_ERROR_INVALID_AUTH_PROVIDER;            BAIL_ON_LSA_ERROR(dwError);        }        pszProviderLibpath = pProvider->pszProviderLibpath;        dlerror();        pProvider->pLibHandle = dlopen(pszProviderLibpath, RTLD_NOW | RTLD_LOCAL);        if (!pProvider->pLibHandle)        {            LSA_LOG_ERROR("Failed to open auth provider at path '%s'", pszProviderLibpath);            pszError = dlerror();            if (!LW_IS_NULL_OR_EMPTY_STR(pszError))            {                LSA_LOG_ERROR("%s", pszError);            }            dwError = LW_ERROR_INVALID_AUTH_PROVIDER;            BAIL_ON_LSA_ERROR(dwError);        }        dlerror();        pfnInitProvider = (PFNINITIALIZEPROVIDER) dlsym(            pProvider->pLibHandle,            LSA_SYMBOL_NAME_INITIALIZE_PROVIDER);        if (!pfnInitProvider)        {            LSA_LOG_ERROR("Ignoring invalid auth provider at path '%s'", pszProviderLibpath);            pszError = dlerror();            if (!LW_IS_NULL_OR_EMPTY_STR(pszError))            {                LSA_LOG_ERROR("%s", pszError);            }            dwError = LW_ERROR_INVALID_AUTH_PROVIDER;            BAIL_ON_LSA_ERROR(dwError);        }    }    dwError = pfnInitProvider(                    &pProvider->pszName,                    &pProvider->pFnTable);    BAIL_ON_LSA_ERROR(dwError);    dwError = LsaSrvValidateProvider(pProvider);    BAIL_ON_LSA_ERROR(dwError);cleanup:    return dwError;error:    goto cleanup;}

//.........这里部分代码省略.........            &pszSmartCardPromptGecos,            &dwSmartCardPromptGecosSize        },        {            "ActiveDirectoryPasswordPrompt",            TRUE,            LwRegTypeString,            0,            0,            NULL,            &PamConfig.pszActiveDirectoryPasswordPrompt,            NULL        },        {                        "LocalPasswordPrompt",            TRUE,            LwRegTypeString,            0,            0,            NULL,            &PamConfig.pszLocalPasswordPrompt,            NULL                                                                    },          {                        "OtherPasswordPrompt",            TRUE,            LwRegTypeString,            0,            0,            NULL,            &PamConfig.pszOtherPasswordPrompt,            NULL                                                                    },            };    dwError = LwAllocateMemory(                sizeof(LSA_PAM_CONFIG),                OUT_PPVOID(&pPamConfig));    BAIL_ON_LSA_ERROR(dwError);    dwError = LsaUtilInitializePamConfig(&PamConfig);    BAIL_ON_LSA_ERROR(dwError);    dwError = RegProcessConfig(                "Services//lsass//Parameters//PAM",                "Policy//Services//lsass//Parameters//PAM",                ConfigDescription,                sizeof(ConfigDescription)/sizeof(ConfigDescription[0]));    BAIL_ON_LSA_ERROR(dwError);    dwError = RegByteArrayToMultiStrsA(            (PBYTE) pszSmartCardServices,            dwSmartCardServicesSize,            &PamConfig.ppszSmartCardServices);    BAIL_ON_LSA_ERROR(dwError);    dwCount = 0;    while (PamConfig.ppszSmartCardServices[dwCount] != NULL)    {         ++dwCount;    }    PamConfig.dwNumSmartCardServices = dwCount;    dwError = RegByteArrayToMultiStrsA(            (PBYTE) pszSmartCardPromptGecos,            dwSmartCardPromptGecosSize,            &PamConfig.ppszSmartCardPromptGecos);    BAIL_ON_LSA_ERROR(dwError);    dwCount = 0;    while (PamConfig.ppszSmartCardPromptGecos[dwCount] != NULL)    {         ++dwCount;    }    PamConfig.dwNumSmartCardPromptGecos = dwCount;    *pPamConfig = PamConfig;    memset(&PamConfig, 0, sizeof(LSA_PAM_CONFIG));cleanup:    LW_SAFE_FREE_STRING(pszSmartCardServices);    LW_SAFE_FREE_STRING(pszSmartCardPromptGecos);    *ppPamConfig = pPamConfig;    return dwError;error:    if (pPamConfig)    {        LsaUtilFreePamConfigContents(pPamConfig);        LW_SAFE_FREE_MEMORY(pPamConfig);    }    LsaUtilFreePamConfigContents(&PamConfig);    goto cleanup;}