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

PCSTRSrvPathGetFileName(    PCSTR  pszPath    ){    PCSTR  pszCursor     = pszPath;    size_t sLen          = 0;    CHAR   szBackSlash[] = { '//', 0 };    CHAR   szFwdSlash[]  = { '/',  0 };    if (pszPath && (sLen = strlen(pszPath)))    {        pszCursor = pszPath + sLen - 1;        while (!IsNullOrEmptyString(pszCursor) && (pszCursor != pszPath))        {            if ((*pszCursor == szBackSlash[0]) || (*pszCursor == szFwdSlash[0]))            {                pszCursor++;                break;            }            pszCursor--;        }    }    return pszCursor;}

DWORDVmDirSchemaAttrIdMapGetAttrId(    PVDIR_SCHEMA_ATTR_ID_MAP    pAttrIdMap,    PSTR                        pszAttrName,    USHORT*                     pusAttrId    ){    DWORD   dwError = 0;    uintptr_t   pAttrId = 0;    if (!pAttrIdMap || IsNullOrEmptyString(pszAttrName))    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMDIR_ERROR(dwError);    }    dwError = LwRtlHashMapFindKey(pAttrIdMap->pStoredIds,            (PVOID*)&pAttrId, pszAttrName);    if (dwError)    {        dwError = LwRtlHashMapFindKey(pAttrIdMap->pNewIds,                    (PVOID*)&pAttrId, pszAttrName);    }    BAIL_ON_VMDIR_ERROR(dwError);    if (pusAttrId)    {        *pusAttrId = (USHORT)pAttrId;    }error:    return dwError;}

staticPVDIR_PAGED_SEARCH_RECORDVmDirPagedSearchCacheFind(    PCSTR pszCookie    ){    DWORD dwError = 0;    PLW_HASHTABLE_NODE pNode = NULL;    PVDIR_PAGED_SEARCH_RECORD pSearchRecord = NULL;    BOOLEAN bInLock = FALSE;    if (IsNullOrEmptyString(pszCookie))    {        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);    }    VMDIR_LOCK_MUTEX(bInLock, gPagedSearchCache.mutex);    dwError = LwRtlHashTableFindKey(                    gPagedSearchCache.pHashTbl,                    &pNode,                    (PVOID)pszCookie);    dwError = LwNtStatusToWin32Error(dwError);    BAIL_ON_VMDIR_ERROR(dwError);    pSearchRecord = LW_STRUCT_FROM_FIELD(pNode, VDIR_PAGED_SEARCH_RECORD, Node);    _RefPagedSearchRecord(pSearchRecord);cleanup:    VMDIR_UNLOCK_MUTEX(bInLock, gPagedSearchCache.mutex);    return pSearchRecord;error:    goto cleanup;}

DWORDVmDirSimpleEntryDeleteAttribute(    PCSTR   pszDN,    PCSTR   pszAttr    ){    DWORD   dwError = 0;    size_t  dnlen = 0;    size_t  attrlen = 0;    VDIR_OPERATION  ldapOp = {0};    if (IsNullOrEmptyString(pszDN) || IsNullOrEmptyString(pszAttr))    {        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);    }    dwError = VmDirInitStackOperation(            &ldapOp,            VDIR_OPERATION_TYPE_INTERNAL,            LDAP_REQ_MODIFY,            NULL);    BAIL_ON_VMDIR_ERROR(dwError);    dnlen = VmDirStringLenA(pszDN);    attrlen = VmDirStringLenA(pszAttr);    ldapOp.pBEIF = VmDirBackendSelect(NULL);    ldapOp.reqDn.lberbv_val = (PSTR)pszDN;    ldapOp.reqDn.lberbv_len = dnlen;    ldapOp.request.modifyReq.dn.lberbv_val = ldapOp.reqDn.lberbv_val;    ldapOp.request.modifyReq.dn.lberbv_len = ldapOp.reqDn.lberbv_len;    dwError = VmDirAppendAMod(            &ldapOp, MOD_OP_DELETE, pszAttr, attrlen, NULL, 0);    BAIL_ON_VMDIR_ERROR(dwError);    dwError = VmDirInternalModifyEntry(&ldapOp);    BAIL_ON_VMDIR_ERROR(dwError);cleanup:    VmDirFreeOperationContent(&ldapOp);    return dwError;error:    goto cleanup;}

DWORDADUSMBGetFile(    PSTR  pszDomainName,    PSTR  pszSourcePath,    PSTR  pszDestPath    ){    DWORD   dwError = MAC_AD_ERROR_SUCCESS;    PSTR    pszFQSrcPath = NULL;    PSTR    pszDCHostname = NULL;    if (IsNullOrEmptyString(pszDomainName) ||        IsNullOrEmptyString(pszSourcePath) ||        IsNullOrEmptyString(pszDestPath))    {        dwError = MAC_AD_ERROR_INVALID_PARAMETER;        BAIL_ON_MAC_ERROR(dwError);    }    dwError = GetPreferredDCAddress(                    pszDomainName,                    &pszDCHostname);    BAIL_ON_MAC_ERROR(dwError);    dwError = LwAllocateStringPrintf(                    &pszFQSrcPath,                    "//%s/sysvol/%s",                    pszDCHostname,                    *pszSourcePath == '/' ? pszSourcePath+1 : pszSourcePath);    BAIL_ON_MAC_ERROR(dwError);    LOG("Calling ADUCopyFileFromRemote(Src:%s, Dest:%s)", pszFQSrcPath, pszDestPath);    dwError = ADUCopyFileFromRemote(pszFQSrcPath, pszDestPath);    BAIL_ON_MAC_ERROR(dwError);cleanup:    LW_SAFE_FREE_STRING(pszFQSrcPath);    LW_SAFE_FREE_STRING(pszDCHostname);    return dwError;error:    goto cleanup;}

DWORDVmDirGetKrbMasterKey(    PSTR        pszFQDN, // [in] FQDN    PBYTE*      ppKeyBlob,    DWORD*      pSize){    DWORD       dwError = 0;    PBYTE       pRetMasterKey = NULL;    if (IsNullOrEmptyString(pszFQDN)        || !ppKeyBlob        || !pSize       )    {        dwError = VMDIR_ERROR_INVALID_PARAMETER;        BAIL_ON_VMDIR_ERROR(dwError);    }    // Currently, we only support single krb realm.    // Global cache gVmdirKrbGlobals is initialized during startup stage.    if (VmDirStringCompareA( pszFQDN, VDIR_SAFE_STRING(gVmdirKrbGlobals.pszRealm), FALSE) != 0)    {        dwError = VMDIR_ERROR_INVALID_REALM;        BAIL_ON_VMDIR_ERROR(dwError);    }    dwError = VmDirAllocateMemory(                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len,                    (PVOID*)&pRetMasterKey                    );    BAIL_ON_VMDIR_ERROR(dwError);    dwError = VmDirCopyMemory (                    pRetMasterKey,                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len,                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_val,                    gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len                    );    BAIL_ON_VMDIR_ERROR(dwError);    *ppKeyBlob = pRetMasterKey;    *pSize     = (DWORD) gVmdirKrbGlobals.bervMasterKey.lberbv.bv_len;    pRetMasterKey = NULL;cleanup:    return dwError;error:    VMDIR_LOG_ERROR( LDAP_DEBUG_RPC, "VmDirGetKrbMasterKey failed. (%u)(%s)",                                     dwError, VDIR_SAFE_STRING(pszFQDN));    VMDIR_SAFE_FREE_MEMORY(pRetMasterKey);    goto cleanup;}

DWORDLWNetDnsGetSrvRecordQuestion(    OUT PSTR* ppszQuestion,    IN PCSTR pszDomainName,    IN OPTIONAL PCSTR pszSiteName,    IN DWORD dwDsFlags    ){    DWORD dwError = 0;    PSTR question = NULL;    PCSTR kind = "dc";    PCSTR service = "_ldap";    if (dwDsFlags & DS_PDC_REQUIRED)    {        kind = "pdc";        service = "_ldap";    }    else if (dwDsFlags & DS_GC_SERVER_REQUIRED)    {        kind = "gc";        service = "_ldap";    }    else if (dwDsFlags & DS_KDC_REQUIRED)    {        kind = "dc";        service = "_kerberos";    }    else    {        kind = "dc";        service = "_ldap";    }    if (IsNullOrEmptyString(pszSiteName))    {        dwError = LwAllocateStringPrintf(&question,                                            "%s._tcp.%s._msdcs.%s",                                            service, kind,                                            pszDomainName);        BAIL_ON_LWNET_ERROR(dwError);    }    else    {        dwError = LwAllocateStringPrintf(&question,                                            "%s._tcp.%s._sites.%s._msdcs.%s",                                            service, pszSiteName, kind,                                            pszDomainName);        BAIL_ON_LWNET_ERROR(dwError);    }error:    if (dwError)    {        LWNET_SAFE_FREE_STRING(question);    }    *ppszQuestion = question;    return dwError;}

DWORDLwCALockDN(    PLWCA_POST_HANDLE   pHandle,    PCSTR               pcszDN,    PSTR                *ppszUuid    ){    DWORD               dwError = 0;    PSTR                pszUuid = NULL;    ULONG               currTime = 0;    DWORD               dwAttempt = 0;    struct timespec     ts = {0};    if (IsNullOrEmptyString(pcszDN) || !ppszUuid || !pHandle)    {        dwError = LWCA_ERROR_INVALID_PARAMETER;        BAIL_ON_LWCA_ERROR(dwError);    }    dwError = LwCAUuidGenerate(&pszUuid);    BAIL_ON_LWCA_ERROR(dwError);    ts.tv_nsec = LWCA_LOCK_SLEEP_NS;    while (dwAttempt < LWCA_LOCK_MAX_ATTEMPT)    {        dwError = _LwCAGetCurrentTime(&currTime);        BAIL_ON_LWCA_ERROR(dwError);        dwError = _LwCALockDNImpl(pHandle, pszUuid, currTime, pcszDN);        if (dwError == LWCA_LOCK_APPLY_FAILED)        {            dwAttempt += 1;            nanosleep(&ts, NULL);            continue;        }        BAIL_ON_LWCA_ERROR(dwError);        break;    }    if (dwAttempt >= LWCA_LOCK_MAX_ATTEMPT)    {        dwError = LWCA_LOCK_APPLY_FAILED;        BAIL_ON_LWCA_ERROR(dwError);    }    *ppszUuid = pszUuid;cleanup:    return dwError;error:    LWCA_SAFE_FREE_STRINGA(pszUuid);    if (ppszUuid)    {        *ppszUuid = NULL;    }    goto cleanup;}

NTSTATUSSrvGetTreeRelativePath(    PWSTR  pwszOriginalPath,    PWSTR* ppwszSpecificPath    ){    NTSTATUS ntStatus        = STATUS_SUCCESS;    wchar16_t wszBackSlash[] = { '//', 0 };    wchar16_t wszFwdSlash[]  = { '/',  0 };    if ((*pwszOriginalPath != wszBackSlash[0]) &&         (*pwszOriginalPath != wszFwdSlash[0]))    {        ntStatus = STATUS_INVALID_PARAMETER;        BAIL_ON_NT_STATUS(ntStatus);    }    pwszOriginalPath++;    // Skip the device name    while (!IsNullOrEmptyString(pwszOriginalPath) &&           (*pwszOriginalPath != wszBackSlash[0]) &&           (*pwszOriginalPath != wszFwdSlash[0]))    {        pwszOriginalPath++;    }    if (IsNullOrEmptyString(pwszOriginalPath) ||        ((*pwszOriginalPath != wszBackSlash[0]) &&         (*pwszOriginalPath != wszFwdSlash[0])))    {        ntStatus = STATUS_INVALID_PARAMETER;        BAIL_ON_NT_STATUS(ntStatus);    }    *ppwszSpecificPath = pwszOriginalPath;cleanup:    return ntStatus;error:    *ppwszSpecificPath = NULL;    goto cleanup;}

staticDWORDVmwDeploySetupServerPartner(    PVMW_IC_SETUP_PARAMS pParams    ){    DWORD dwError = 0;    PCSTR ppszServices[]=    {        VMW_DCERPC_SVC_NAME,        VMW_VMDNS_SVC_NAME,        VMW_VMAFD_SVC_NAME,        VMW_DIR_SVC_NAME,        VMW_VMCA_SVC_NAME    };    int iSvc = 0;    VMW_DEPLOY_LOG_INFO("Setting up system as Infrastructure partner node");    dwError = VmwDeployValidateHostname(pParams->pszHostname);    BAIL_ON_DEPLOY_ERROR(dwError);    dwError = VmwDeployValidatePartnerCredentials(                    pParams->pszServer,                    pParams->pszPassword,                    pParams->pszDomainName);    BAIL_ON_DEPLOY_ERROR(dwError);    dwError = VmwDeployValidateSiteName(pParams->pszSite);    BAIL_ON_DEPLOY_ERROR(dwError);    if (!IsNullOrEmptyString(pParams->pszDNSForwarders))    {        dwError = VmwDeployValidateDNSForwarders(pParams->pszDNSForwarders);        BAIL_ON_DEPLOY_ERROR(dwError);    }    for (; iSvc < sizeof(ppszServices)/sizeof(ppszServices[0]); iSvc++)    {        PCSTR pszService = ppszServices[iSvc];        VMW_DEPLOY_LOG_INFO("Starting service [%s]", pszService);        dwError = VmwDeployStartService(pszService);        BAIL_ON_DEPLOY_ERROR(dwError);    }    dwError = VmwDeploySetupServerCommon(pParams);    BAIL_ON_DEPLOY_ERROR(dwError);cleanup:    return dwError;error:    goto cleanup;}

DWORDVmAfWinCfgOpenRootKey(    PVMAF_CFG_CONNECTION pConnection,    PCSTR                pszKeyName,    DWORD                dwOptions,    DWORD                dwAccess,    PVMAF_CFG_KEY*       ppKey    ){    DWORD dwError = 0;    PVMAF_CFG_KEY pKey = NULL;    VMAF_CFG_KEY rootKey = {0};    if (!pConnection || IsNullOrEmptyString(pszKeyName) || !ppKey)    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMAFD_ERROR(dwError);    }    if (!strcmp(pszKeyName, "HKEY_LOCAL_MACHINE"))    {        rootKey.hKey = HKEY_LOCAL_MACHINE;    }    else    {        dwError = ERROR_NOT_SUPPORTED;        BAIL_ON_VMAFD_ERROR(dwError);    }    dwError = VmAfWinCfgOpenKey(                                  pConnection,                                  &rootKey,                                  NULL,                                  dwOptions,                                  dwAccess,                                  &pKey);    BAIL_ON_VMAFD_ERROR(dwError);    *ppKey = pKey;cleanup:    return dwError;error:    if (ppKey)    {        *ppKey = NULL;    }//    if (pKey)//    {//        VmAfWinCfgCloseKey(pKey);//    }    goto cleanup;}

DWORDDJFixLoginConfigFile(    PCSTR pszPath    ){    DWORD ceError = ERROR_SUCCESS;    PCSTR pszFilePath = NULL;    PSTR pszTmpPath = NULL;    PSTR pszFinalPath = NULL;    BOOLEAN bFileExists = FALSE;    FILE* fp = NULL;    FILE* fp_new = NULL;    DynamicArray lines;    PSTR currentSystem = NULL;    memset(&lines, 0, sizeof(lines));    if (IsNullOrEmptyString(pszPath))        pszFilePath = LOGIN_CONFIG_PATH;    else        pszFilePath = pszPath;    GCE(ceError = CTGetFileTempPath(                        pszFilePath,                        &pszFinalPath,                        &pszTmpPath));    GCE(ceError = CTCheckFileExists(pszFinalPath, &bFileExists));    if (!bFileExists)        goto cleanup;    GCE(ceError = CTOpenFile(pszFinalPath, "r", &fp));    GCE(ceError = CTReadLines(fp, &lines));    GCE(ceError = CTSafeCloseFile(&fp));    GCE(ceError = GetAuthType(&lines, &currentSystem));    if(!strcmp(currentSystem, "PAM_AUTH"))        goto cleanup;    GCE(ceError = SetAuthType(&lines, "PAM_AUTH"));    GCE(ceError = CTOpenFile(pszTmpPath, "w", &fp_new));    GCE(ceError = CTWriteLines(fp_new, &lines));    GCE(ceError = CTSafeCloseFile(&fp_new));    GCE(ceError = CTSafeReplaceFile(pszFilePath, pszTmpPath));cleanup:    CTSafeCloseFile(&fp);    CTSafeCloseFile(&fp_new);    CT_SAFE_FREE_STRING(currentSystem);    CT_SAFE_FREE_STRING(pszTmpPath);    CT_SAFE_FREE_STRING(pszFinalPath);    CTFreeLines(&lines);    return ceError;}

DWORDVmwDeployValidatePassword(    PCSTR pszPassword    ){    DWORD dwError = 0;    size_t iCh = 0;    size_t nUpper = 0;    size_t nLower = 0;    size_t nDigit = 0;    size_t nSpecial = 0;    size_t sLen = 0;    VMW_DEPLOY_LOG_DEBUG("Validating password");    if (IsNullOrEmptyString(pszPassword) || (sLen = strlen(pszPassword)) < 8)    {        dwError = ERROR_PASSWORD_RESTRICTION;        BAIL_ON_DEPLOY_ERROR(dwError);    }    // We are looking for at least one upper case, one lower case, one digit and    // one special case character. Added illegal chars check    for (iCh = 0; iCh < sLen; iCh++)    {        int ch = pszPassword[iCh];        if (isdigit(ch))        {            nDigit++;        }        else if (islower(ch))        {            nLower++;        }        else if (isupper(ch))        {            nUpper++;        }        else if (ispunct(ch))        {            nSpecial++;        }    }    if (!nUpper || !nLower || !nDigit || !nSpecial)    {        VMW_DEPLOY_LOG_ERROR("Password complexity requirement not satisfied");        dwError = ERROR_PASSWORD_RESTRICTION;        BAIL_ON_DEPLOY_ERROR(dwError);    }error:    return dwError;}

DWORDVmDirMetaDataCreate(    USN                           localUsn,    UINT64                        version,    PCSTR                         pszOrigInvoId,    PCSTR                         pszOrigTimeStamp,    USN                           origUsn,    PVMDIR_ATTRIBUTE_METADATA*    ppMetaData    ){    DWORD    dwError = 0;    PVMDIR_ATTRIBUTE_METADATA   pMetaData = NULL;    if (!ppMetaData        ||        IsNullOrEmptyString(pszOrigInvoId) ||        IsNullOrEmptyString(pszOrigTimeStamp))    {        BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);    }    dwError = VmDirAllocateMemory(sizeof(VMDIR_ATTRIBUTE_METADATA), (PVOID*) &pMetaData);    BAIL_ON_VMDIR_ERROR(dwError);    pMetaData->localUsn = localUsn;    pMetaData->version = version;    dwError = VmDirAllocateStringA(pszOrigInvoId, &pMetaData->pszOrigInvoId);    BAIL_ON_VMDIR_ERROR(dwError);    dwError = VmDirAllocateStringA(pszOrigTimeStamp, &pMetaData->pszOrigTime);    BAIL_ON_VMDIR_ERROR(dwError);    pMetaData->origUsn = origUsn;    *ppMetaData = pMetaData;cleanup:    return dwError;error:    VmDirFreeMetaData(pMetaData);    VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);    goto cleanup;}

staticDWORDVmDirValidateUserCreateParamsW(    PVMDIR_USER_CREATE_PARAMS_W pCreateParams    ){    DWORD dwError = 0;    if (!pCreateParams ||        IsNullOrEmptyString(pCreateParams->pwszAccount) ||        IsNullOrEmptyString(pCreateParams->pwszFirstname) ||        IsNullOrEmptyString(pCreateParams->pwszLastname) ||        IsNullOrEmptyString(pCreateParams->pwszPassword))    {        dwError = ERROR_INVALID_PARAMETER;    }    return dwError;}

DWORDVmDirConfigSetDefaultSiteandLduGuid(    PCSTR pszDefaultSiteGuid,    PCSTR pszDefaultLduGuid    )#ifndef _WIN32{    DWORD   dwError = 0;    if (IsNullOrEmptyString(pszDefaultSiteGuid) || IsNullOrEmptyString(pszDefaultLduGuid))    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMDIR_ERROR(dwError);    }    dwError = RegUtilSetValue(                NULL,                HKEY_THIS_MACHINE,                VMDIR_CONFIG_PARAMETER_KEY_PATH,                NULL,                VMDIR_REG_KEY_SITE_GUID,                REG_SZ,                (PVOID)pszDefaultSiteGuid,                VmDirStringLenA(pszDefaultSiteGuid)+1);    BAIL_ON_VMDIR_ERROR(dwError);    dwError = RegUtilSetValue(                NULL,                HKEY_THIS_MACHINE,                VMDIR_CONFIG_PARAMETER_KEY_PATH,                NULL,                VMDIR_REG_KEY_LDU_GUID,                REG_SZ,                (PVOID)pszDefaultLduGuid,                VmDirStringLenA(pszDefaultLduGuid)+1);    BAIL_ON_VMDIR_ERROR(dwError);cleanup:    return dwError;error:    VmDirLog(LDAP_DEBUG_ANY, "VmDirConfigSetDefaultSiteandLduGuid failed with error (%u)", dwError);    goto cleanup;}

DWORDLWSetConfigValueBySectionName(    PCFGSECTION pSectionList,    PCSTR pszSectionName,    PCSTR pszName,    PCSTR pszValue    ){    DWORD dwError = 0;    PCFGSECTION pSection = NULL;    if (IsNullOrEmptyString(pszSectionName) ||        IsNullOrEmptyString(pszName)) {        dwError = MAC_AD_ERROR_INVALID_PARAMETER;        BAIL_ON_MAC_ERROR(dwError);    }    while (pSectionList) {        if (!strcmp(pSectionList->pszName, pszSectionName)) {            pSection = pSectionList;            break;        }        pSectionList = pSectionList->pNext;    }    if (!pSection) {        dwError = MAC_AD_ERROR_INVALID_RECORD_TYPE;        goto error;    }    dwError = LWSetConfigValueBySection(pSection,                                        pszName,                                        pszValue);    BAIL_ON_MAC_ERROR(dwError);cleanup:    return dwError;error:    goto cleanup;}

DWORDVmDirSchemaAttrIdMapAddNewAttr(    PVDIR_SCHEMA_ATTR_ID_MAP    pAttrIdMap,    PSTR                        pszAttrName,    USHORT                      usAttrId    // optional    ){    DWORD   dwError = 0;    PSTR    pszKey = 0;    if (!pAttrIdMap || IsNullOrEmptyString(pszAttrName))    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMDIR_ERROR(dwError);    }    if (VmDirSchemaAttrIdMapGetAttrId(pAttrIdMap, pszAttrName, NULL) == 0)    {        dwError = ERROR_ALREADY_EXISTS;        BAIL_ON_VMDIR_ERROR(dwError);    }    dwError = VmDirAllocateStringA(pszAttrName, &pszKey);    BAIL_ON_VMDIR_ERROR(dwError);    if (usAttrId)    {        dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds,                pszKey, (PVOID)(uintptr_t)usAttrId, NULL);        BAIL_ON_VMDIR_ERROR(dwError);        if (usAttrId >= pAttrIdMap->usNextId)        {            pAttrIdMap->usNextId = usAttrId + 1;        }    }    else    {        dwError = LwRtlHashMapInsert(pAttrIdMap->pNewIds,                pszKey, (PVOID)(uintptr_t)pAttrIdMap->usNextId, NULL);        BAIL_ON_VMDIR_ERROR(dwError);        pAttrIdMap->usNextId++;    }cleanup:    return dwError;error:    VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,            "%s failed, error (%d)", __FUNCTION__, dwError );    VMDIR_SAFE_FREE_MEMORY(pszKey);    goto cleanup;}

intmain(    int argc,    char* argv[]    ){    DWORD dwError = 0;    handle_t bindingHandle = 0;    HANDLE hEventLog = 0;    PSTR pszBindingString = NULL;    DWORD eventTableCategoryId = (DWORD) -1;    PSTR pszFilename = NULL;        evt_init_logging_to_file(LOG_LEVEL_VERBOSE, "");    dwError = ParseArgs(argc, argv, &pszFilename, &eventTableCategoryId);    BAIL_ON_EVT_ERROR(dwError);    if (IsNullOrEmptyString(pszFilename)) {       EVT_LOG_ERROR("No path to the file containing events was specified.");       ShowUsage();       BAIL_ON_EVT_ERROR((dwError = EINVAL));    }    TRY    {	dwError = LWIOpenEventLog(&bindingHandle, &hEventLog, &pszBindingString, "127.0.0.1", "127.0.0.1");	BAIL_ON_EVT_ERROR(dwError);        dwError = ParseAndAddEvents(bindingHandle, hEventLog, pszFilename, eventTableCategoryId, AddEventRecord);        BAIL_ON_EVT_ERROR(dwError);    }    CATCH_ALL    {        exc_get_status (THIS_CATCH, &dwError);        EVT_LOG_ERROR("Unexpected error . Error code [%d]/n", dwError);        BAIL_ON_EVT_ERROR(dwError);    }    ENDTRY;  error:    if (bindingHandle && hEventLog && pszBindingString)	LWICloseEventLog(bindingHandle, hEventLog, pszBindingString);            if(dwError != 0) {	EVT_LOG_ERROR("Failed to import events. Error code [%d]/n", dwError);    }    return dwError;}

DWORDCTMatchProgramToPID(    PCSTR pszProgramName,    pid_t    pid    ){    DWORD ceError = ERROR_SUCCESS;    CHAR szBuf[PATH_MAX+1];    FILE* pFile = NULL;#if defined(__LWI_DARWIN__) || defined(__LWI_FREEBSD__)    sprintf(szBuf, "ps -p %d -o command= | grep %s", pid, pszProgramName);#elif defined(__LWI_SOLARIS__) || defined(__LWI_HP_UX__) || defined(__LWI_AIX__)    sprintf(szBuf, "PS=ps; [ -x /bin/ps ] && PS=/bin/ps; UNIX95=1 $PS -p %ld -o comm= | grep %s", (long)pid, pszProgramName);#else    sprintf(szBuf, "UNIX95=1 ps -p %ld -o cmd= | grep %s", (long)pid, pszProgramName);#endif    pFile = popen(szBuf, "r");    if (pFile == NULL) {        ceError = LwMapErrnoToLwError(errno);        BAIL_ON_CENTERIS_ERROR(ceError);    }    /* Assume that we won't find the process we are looking for */    ceError = ERROR_PROC_NOT_FOUND;    while (TRUE) {        if (NULL == fgets(szBuf, PATH_MAX, pFile)) {            if (feof(pFile)) {                break;            } else {                ceError = LwMapErrnoToLwError(errno);                BAIL_ON_CENTERIS_ERROR(ceError);            }        }        CTStripWhitespace(szBuf);        if (!IsNullOrEmptyString(szBuf)) {            /* Well what do you know, it was found! */            ceError = ERROR_SUCCESS;            break;        }    }error:    if (pFile)        pclose(pFile);    return ceError;}

DWORDVMCAGetCRLInfoPrivate(    PSTR pszFileName,    time_t *ptmLastUpdate,    time_t *ptmNextUpdate,    DWORD  *pdwCRLNumber){    DWORD dwError = 0;    X509_CRL *pCrl = NULL;    ASN1_TIME *pLastUpdate = NULL;    ASN1_TIME *pNextUpdate = NULL;    ASN1_INTEGER *pCrlNumber = NULL;    long nCrlNum = 0;    if (   (IsNullOrEmptyString(pszFileName))        || (ptmNextUpdate == NULL)        || (ptmLastUpdate == NULL)        || (pdwCRLNumber == NULL)        ) {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_ERROR(dwError);    }    dwError = VMCAFileToCRL(pszFileName, &pCrl);    BAIL_ON_ERROR(dwError);    pLastUpdate = X509_CRL_get_lastUpdate(pCrl);    pNextUpdate = X509_CRL_get_nextUpdate(pCrl);    pCrlNumber = ASN1_INTEGER_new();    if(pCrlNumber == NULL) {        dwError = VMCA_OUT_MEMORY_ERR;        BAIL_ON_ERROR(dwError);    }    pCrlNumber = X509_CRL_get_ext_d2i(pCrl, NID_crl_number, 0,0);    nCrlNum = ASN1_INTEGER_get(pCrlNumber);    *pdwCRLNumber = nCrlNum;    dwError =  VMCAASN1ToTimeT(pLastUpdate,ptmLastUpdate);    BAIL_ON_ERROR(dwError);    dwError =  VMCAASN1ToTimeT(pNextUpdate,ptmNextUpdate);    BAIL_ON_ERROR(dwError);cleanup:    if(pCrlNumber){        ASN1_INTEGER_free(pCrlNumber);    }    VMCACrlFree(pCrl);    return dwError;error :    goto cleanup;}

DWORDDNSOpen(    PCSTR   pszNameServer,    DWORD   dwType,    PHANDLE phDNSServer    ){    DWORD  dwError = 0;    HANDLE hDNSServer = (HANDLE)NULL;    if (IsNullOrEmptyString(pszNameServer))    {        dwError = LWDNS_ERROR_INVALID_PARAMETER;        BAIL_ON_LWDNS_ERROR(dwError);    }    switch (dwType)    {        case DNS_TCP:            dwError = DNSTCPOpen(                            pszNameServer,                            &hDNSServer                            );            break;        case DNS_UDP:            dwError = DNSUDPOpen(                            pszNameServer,                            &hDNSServer                            );            break;        default:            dwError = LWDNS_ERROR_INVALID_PARAMETER;    }    BAIL_ON_LWDNS_ERROR(dwError);    *phDNSServer = hDNSServer;cleanup:    return dwError;error:    *phDNSServer = (HANDLE)NULL;    goto cleanup;}

DWORDVmAfdModifyOwner(          PVECS_SERV_STORE pStore,          PCWSTR pszUserName,          PVMAFD_SECURITY_DESCRIPTOR pSecurityDescriptor          ){    DWORD dwError = 0;    PVM_AFD_SECURITY_CONTEXT pSecurityContext = NULL;    PVM_AFD_SECURITY_CONTEXT pSecurityContextToClean = NULL;    if (IsNullOrEmptyString (pszUserName) ||        !pSecurityDescriptor ||        !pStore       )    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMAFD_ERROR (dwError);    }    dwError = VmAfdAllocateContextFromName (                                    pszUserName,                                    &pSecurityContext                                    );    BAIL_ON_VMAFD_ERROR (dwError);    pSecurityContextToClean = pSecurityContext;    dwError = VmAfdCheckOwnerShip (                                  pStore,                                  pSecurityContext                                  );    if (dwError == 0)    {        goto cleanup;    }    dwError = 0;    pSecurityContextToClean = pSecurityDescriptor->pOwnerSecurityContext;    pSecurityDescriptor->pOwnerSecurityContext = pSecurityContext;cleanup:    if (pSecurityContextToClean)    {        VmAfdFreeSecurityContext (pSecurityContextToClean);    }    return dwError;error:    goto cleanup;}

DWORDVmDnsCacheLoadZoneFromStore(    PVMDNS_CACHE_CONTEXT    pContext,    PCSTR                   pZoneName    ){    DWORD dwError = 0;    PVMDNS_RECORD_LIST pList = NULL;    PVMDNS_ZONE_OBJECT pZoneObject = NULL;    BOOL bLocked = FALSE;    PVMDNS_PROPERTY_LIST pPropertyList = NULL;    if (IsNullOrEmptyString(pZoneName))    {        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_VMDNS_ERROR(dwError);    }    VmDnsLockWrite(pContext->pLock);    bLocked = TRUE;    dwError = VmDnsStoreGetProperties(pZoneName, &pPropertyList);    if (dwError && dwError != ERROR_NOT_FOUND)    {        BAIL_ON_VMDNS_ERROR(dwError);    }    dwError = VmDnsStoreGetRecords(pZoneName, pZoneName, &pList);    if (dwError && dwError != ERROR_NOT_FOUND)    {        BAIL_ON_VMDNS_ERROR(dwError);    }    dwError = VmDnsZoneCreateFromRecordList(pZoneName, pList, pPropertyList, &pZoneObject);    BAIL_ON_VMDNS_ERROR(dwError);    VmDnsZoneListAddZone(pContext->pZoneList, pZoneObject);    BAIL_ON_VMDNS_ERROR(dwError);cleanup:    if (bLocked)    {        VmDnsUnlockWrite(pContext->pLock);    }    VmDnsRecordListRelease(pList);    VmDnsPropertyListRelease(pPropertyList);    VmDnsZoneObjectRelease(pZoneObject);    return dwError;error:    goto cleanup;}

DWORDDJUnjoinDomain(    PCSTR pszUsername,    PCSTR pszPassword    ){    DWORD dwError = 0;    LWException *exc = NULL;     JoinProcessOptions options;    DJZeroJoinProcessOptions(&options);    options.joiningDomain = FALSE;    if (!IsNullOrEmptyString(pszUsername))    {        LW_CLEANUP_CTERR(&exc, CTStrdup(pszUsername, &options.username));    }    if (!IsNullOrEmptyString(pszPassword))    {        LW_CLEANUP_CTERR(&exc, CTStrdup(pszPassword, &options.password));    }    LW_CLEANUP_CTERR(&exc, DJGetComputerName(&options.computerName));    LW_TRY(&exc, DJInitModuleStates(&options, &LW_EXC));    LW_TRY(&exc, DJRunJoinProcess(&options, &LW_EXC));cleanup:    DJFreeJoinProcessOptions(&options);    if (!LW_IS_OK(exc))    {        dwError = exc->code;        LWHandle(&exc);    }    return dwError;}

staticDWORD_VmDirSimpleEntryCreateInBEWithGuid(    PVDIR_BACKEND_INTERFACE pBE,    PVDIR_SCHEMA_CTX        pSchemaCtx,    PSTR*                   ppszEntryInitializer,    PSTR                    pszDN,    ENTRYID                 ulEntryId,    PSTR                    pszGuid /* Optional */    ){    DWORD                   dwError = 0;    VDIR_OPERATION          ldapOp = {0};    dwError = VmDirInitStackOperation( &ldapOp,                                       VDIR_OPERATION_TYPE_INTERNAL,                                       LDAP_REQ_ADD,                                       pSchemaCtx );    BAIL_ON_VMDIR_ERROR(dwError);    ldapOp.pBEIF = pBE;    assert(ldapOp.pBEIF);    ldapOp.reqDn.lberbv.bv_val = pszDN;    ldapOp.reqDn.lberbv.bv_len = VmDirStringLenA(pszDN);    dwError = AttrListToEntry(            pSchemaCtx,            pszDN,            ppszEntryInitializer,            ldapOp.request.addReq.pEntry);    BAIL_ON_VMDIR_ERROR(dwError);    ldapOp.request.addReq.pEntry->eId = ulEntryId;    if (!IsNullOrEmptyString(pszGuid))    {        dwError = VmDirAllocateStringA(pszGuid, &ldapOp.request.addReq.pEntry->pszGuid);        BAIL_ON_VMDIR_ERROR(dwError);    }    dwError = VmDirInternalAddEntry(&ldapOp);    BAIL_ON_VMDIR_ERROR(dwError);cleanup:    VmDirFreeOperationContent(&ldapOp);    return dwError;error:    goto cleanup;}

DWORDVmwDeployValidateSiteName(    PCSTR pszSite    ){    DWORD dwError = 0;    BOOLEAN bHasSpecialChars = FALSE;    VMW_DEPLOY_LOG_DEBUG(            "Validating site name [%s]",            VMW_DEPLOY_SAFE_LOG_STRING(pszSite));    if (!IsNullOrEmptyString(pszSite))    {        PCSTR pszCursor = pszSite;        while (*pszCursor && !bHasSpecialChars)        {            switch (*pszCursor)            {                case '!':                case '@':                case '#':                case '$':                case '%':                case '^':                case '&':                case '*':                case '[':                case ']':                     bHasSpecialChars = TRUE;                     break;                default:                     pszCursor++;                     break;            }        }    }    if (bHasSpecialChars)    {        VMW_DEPLOY_LOG_ERROR(                "Site name [%s] has invalid characters",                VMW_DEPLOY_SAFE_LOG_STRING(pszSite));        dwError = ERROR_INVALID_PARAMETER;        BAIL_ON_DEPLOY_ERROR(dwError);    }error:    return dwError;}

uint32_tTDNFGetGPGCheck(    PTDNF pTdnf,    const char* pszRepo,    int* pnGPGCheck,    char** ppszUrlGPGKey    ){    uint32_t dwError = 0;    PTDNF_REPO_DATA pRepo = NULL;    int nGPGCheck = 0;    char* pszUrlGPGKey = NULL;    if(!pTdnf || !ppszUrlGPGKey || IsNullOrEmptyString(pszRepo))    {        dwError = ERROR_TDNF_INVALID_PARAMETER;        BAIL_ON_TDNF_ERROR(dwError);    }    if(!pTdnf->pArgs->nNoGPGCheck)    {        dwError = TDNFGetRepoById(pTdnf, pszRepo, &pRepo);        if(dwError == ERROR_TDNF_NO_DATA)        {            dwError = 0;        }        BAIL_ON_TDNF_ERROR(dwError);        if(pRepo)        {            nGPGCheck = pRepo->nGPGCheck;            if(nGPGCheck)            {                dwError = TDNFAllocateString(                             pRepo->pszUrlGPGKey,                             &pszUrlGPGKey);                BAIL_ON_TDNF_ERROR(dwError);            }        }    }    *pnGPGCheck = nGPGCheck;    *ppszUrlGPGKey = pszUrlGPGKey;cleanup:    return dwError;error:    if(ppszUrlGPGKey)    {        *ppszUrlGPGKey = NULL;    }    TDNF_SAFE_FREE_MEMORY(pszUrlGPGKey);    goto cleanup;}