VOID VmDirIndexLibShutdown( VOID ) { if (gVdirIndexGlobals.pThrInfo) { VmDirSrvThrShutdown(gVdirIndexGlobals.pThrInfo); gVdirIndexGlobals.pThrInfo = NULL; } if (gVdirIndexGlobals.pIndexCfgMap) { LwRtlHashMapClear(gVdirIndexGlobals.pIndexCfgMap, VmDirFreeIndexCfgMapPair, NULL); LwRtlFreeHashMap(&gVdirIndexGlobals.pIndexCfgMap); gVdirIndexGlobals.pIndexCfgMap = NULL; } VmDirIndexUpdFree(gVdirIndexGlobals.pIndexUpd); gVdirIndexGlobals.pIndexUpd = NULL; VMDIR_SAFE_FREE_CONDITION(gVdirIndexGlobals.cond); gVdirIndexGlobals.cond = NULL; gVdirIndexGlobals.mutex = NULL; gVdirIndexGlobals.bFirstboot = FALSE; gVdirIndexGlobals.bLegacyDB = FALSE; }
VOID VmDirDDVectorShutdown( VOID ) { BOOLEAN bInLock = FALSE; if (gVmdirServerGlobals.pReplDeadlockDetectionVector) { VMDIR_LOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); if (gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap) { LwRtlHashMapClear( gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, VmDirSimpleHashMapPairFree, NULL); LwRtlFreeHashMap(&gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap); } VMDIR_SAFE_FREE_MEMORY(gVmdirServerGlobals.pReplDeadlockDetectionVector->pszInvocationId); VMDIR_UNLOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); } VMDIR_SAFE_FREE_MUTEX(gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); VMDIR_SAFE_FREE_MEMORY(gVmdirServerGlobals.pReplDeadlockDetectionVector); }
VOID VmDirFreeUTDVectorCache( PVMDIR_UTDVECTOR_CACHE pUTDVector ) { BOOLEAN bInLock = FALSE; if (!pUTDVector) { return; } VMDIR_RWLOCK_WRITELOCK(bInLock, pUTDVector->pUtdVectorLock, 0); if (pUTDVector->pUtdVectorMap) { LwRtlHashMapClear(pUTDVector->pUtdVectorMap, VmDirSimpleHashMapPairFreeKeyOnly, NULL); LwRtlFreeHashMap(&pUTDVector->pUtdVectorMap); } VMDIR_SAFE_FREE_MEMORY(pUTDVector->pszUtdVector); VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock); VMDIR_SAFE_FREE_RWLOCK(pUTDVector->pUtdVectorLock); VMDIR_SAFE_FREE_MEMORY(pUTDVector); }
VOID VdcFreeHashMap( PLW_HASHMAP *ppHashMap ) { if (*ppHashMap != NULL) { LwRtlHashMapClear(*ppHashMap, VdcHashMapFreeStringPair, NULL); LwRtlFreeHashMap(ppHashMap); } }
VOID VmDirFreeLdapSchema( PVDIR_LDAP_SCHEMA pSchema ) { if (pSchema) { if (pSchema->attributeTypes) { LwRtlHashMapClear(pSchema->attributeTypes, _FreeDefMapPair, NULL); LwRtlFreeHashMap(&pSchema->attributeTypes); } if (pSchema->objectClasses) { LwRtlHashMapClear(pSchema->objectClasses, _FreeDefMapPair, NULL); LwRtlFreeHashMap(&pSchema->objectClasses); } if (pSchema->contentRules) { LwRtlHashMapClear(pSchema->contentRules, _FreeDefMapPair, NULL); LwRtlFreeHashMap(&pSchema->contentRules); } if (pSchema->structureRules) { LwRtlHashMapClear(pSchema->structureRules, _FreeDefMapPair, NULL); LwRtlFreeHashMap(&pSchema->structureRules); } if (pSchema->nameForms) { LwRtlHashMapClear(pSchema->nameForms, _FreeDefMapPair, NULL); LwRtlFreeHashMap(&pSchema->nameForms); } VMDIR_SAFE_FREE_MEMORY(pSchema); } }
VOID VmDirFreeSchemaAttrIdMap( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap ) { if (pAttrIdMap) { if (pAttrIdMap->pStoredIds) { LwRtlHashMapClear(pAttrIdMap->pStoredIds, _FreeAttrIdMapPair, NULL); LwRtlFreeHashMap(&pAttrIdMap->pStoredIds); } if (pAttrIdMap->pNewIds) { LwRtlHashMapClear(pAttrIdMap->pNewIds, _FreeAttrIdMapPair, NULL); LwRtlFreeHashMap(&pAttrIdMap->pNewIds); } VMDIR_SAFE_FREE_MEMORY(pAttrIdMap); } }
VOID VmDirSchemaAttrIdMapRemoveAllPending( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap ) { if (pAttrIdMap) { if (pAttrIdMap->pNewIds) { LwRtlHashMapClear(pAttrIdMap->pNewIds, _FreeAttrIdMapPair, NULL); } } }
DWORD VmDirSuperLogGetTable( PVMDIR_SUPERLOG_ENTRY_LDAPOPERATION_ARRAY pEntries, PVMDIR_SUPERLOG_TABLE_COLUMN_SET pColumnSet, PVMDIR_SUPERLOG_TABLE *ppTable ) { DWORD dwError = 0; PLW_HASHMAP pHashMap = NULL; PVMDIR_SUPERLOG_TABLE pTable = NULL; dwError = LwRtlCreateHashMap( &pHashMap, LwRtlHashDigestPstr, LwRtlHashEqualPstr, NULL ); BAIL_ON_VMDIR_ERROR(dwError); dwError = _populateHashMapWithSuperlogEntries( pHashMap, pEntries, pColumnSet ); BAIL_ON_VMDIR_ERROR(dwError); dwError = _convertHashMapToSuperlogTable( pHashMap, pColumnSet, &pTable ); BAIL_ON_VMDIR_ERROR(dwError); qsort( pTable->rows, pTable->numRows, sizeof(VMDIR_SUPERLOG_TABLE_ROW), _compareSuperlogTableRows); *ppTable = pTable; cleanup: LwRtlHashMapClear(pHashMap, _hashMapPairFree, NULL); LwRtlFreeHashMap(&pHashMap); return dwError; error: VmDirFreeSuperLogTable(pTable); goto cleanup; }
DWORD VmDirUTDVectorCacheReplace( PVMDIR_UTDVECTOR_CACHE pUTDVector, PCSTR pszNewUTDVector ) { DWORD dwError = 0; BOOLEAN bInLock = FALSE; if (!pUTDVector) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } if (IsNullOrEmptyString(pszNewUTDVector)) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } VMDIR_RWLOCK_WRITELOCK(bInLock, pUTDVector->pUtdVectorLock, 0); // update hash map first LwRtlHashMapClear(pUTDVector->pUtdVectorMap, VmDirSimpleHashMapPairFreeKeyOnly, NULL); dwError = VmDirStrtoVector(pszNewUTDVector, _VmDirUTDVectorStrToPair, pUTDVector->pUtdVectorMap); BAIL_ON_VMDIR_ERROR(dwError); // update string VMDIR_SAFE_FREE_MEMORY(pUTDVector->pszUtdVector); dwError = VmDirAllocateStringA(pszNewUTDVector, &pUTDVector->pszUtdVector); BAIL_ON_VMDIR_ERROR(dwError); cleanup: VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD _VmDirDDVectorUpdateInLock( DWORD dwValue ) { DWORD dwError = 0; LwRtlHashMapClear( gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, VmDirSimpleHashMapPairFree, NULL); dwError = _VmDirDDVectorUpdateDefaultsInLock(dwValue); BAIL_ON_VMDIR_ERROR(dwError); cleanup: return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirDDVectorParseString( PSTR pszDeadlockDetectionVectorStr, PBOOLEAN pbCompleteReplCycle ) { PSTR pszLocalVectorStr = NULL; PDWORD pdwValue = NULL; DWORD dwError = 0; DWORD dwMinConsecutiveEmptyPage = INT_MAX; BOOLEAN bInLock = FALSE; LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT; LW_HASHMAP_PAIR pair = {NULL, NULL}; VMDIR_LOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); if (pszDeadlockDetectionVectorStr && pbCompleteReplCycle) { dwError = VmDirAllocateStringA(pszDeadlockDetectionVectorStr+VmDirStringLenA("vector:"), &pszLocalVectorStr); BAIL_ON_VMDIR_ERROR(dwError); // cache the counter value if (LwRtlHashMapFindKey( gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, (PVOID*)&pdwValue, gVmdirServerGlobals.bvServerObjName.lberbv_val) == 0) { dwMinConsecutiveEmptyPage = *pdwValue; dwMinConsecutiveEmptyPage++; VMDIR_LOG_INFO(LDAP_DEBUG_REPL, "consecutive empty pages received: %d", dwMinConsecutiveEmptyPage); } // clear and reconstruct the vector LwRtlHashMapClear( gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, VmDirSimpleHashMapPairFree, NULL); dwError = VmDirStrtoVector( pszLocalVectorStr, _VmDirDeadlockDetectionVectorStrToPair, gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap); BAIL_ON_VMDIR_ERROR(dwError); // update the cached counter value dwError = _VmDirDDVectorUpdateDefaultsInLock(dwMinConsecutiveEmptyPage); BAIL_ON_VMDIR_ERROR(dwError); // check for replication cycle completion while (LwRtlHashMapIterate(gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap, &iter, &pair)) { dwMinConsecutiveEmptyPage = VMDIR_MIN(dwMinConsecutiveEmptyPage, *(PDWORD)pair.pValue); } *pbCompleteReplCycle = (dwMinConsecutiveEmptyPage >= gVmdirGlobals.dwEmptyPageCnt); if (*pbCompleteReplCycle) { VMDIR_LOG_INFO( VMDIR_LOG_MASK_ALL, "%s: Break Empty Pages Received, vec: %s", __FUNCTION__, pszDeadlockDetectionVectorStr); } } else // if vector not present - non empty page - clear the vector contents { _VmDirDDVectorUpdateInLock(0); } cleanup: VMDIR_UNLOCK_MUTEX(bInLock, gVmdirServerGlobals.pReplDeadlockDetectionVector->pMutex); VMDIR_SAFE_FREE_MEMORY(pszLocalVectorStr); return dwError; error: VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirEntryIsAttrAllowed( PVDIR_ENTRY pEntry, PSTR pszAttrName, PBOOLEAN pbMust, PBOOLEAN pbMay ) { DWORD dwError = 0; DWORD i = 0; PVDIR_ATTRIBUTE pAttrOC = NULL; PVDIR_SCHEMA_OC_DESC pOCDesc = NULL; PLW_HASHMAP pAllMustAttrMap = NULL; PLW_HASHMAP pAllMayAttrMap = NULL; if (!pEntry || IsNullOrEmptyString(pszAttrName)) { dwError = VMDIR_ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwError = LwRtlCreateHashMap(&pAllMustAttrMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlCreateHashMap(&pAllMayAttrMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); pAttrOC = VmDirFindAttrByName(pEntry, ATTR_OBJECT_CLASS); for (i = 0; pAttrOC && i < pAttrOC->numVals; i++) { dwError = VmDirSchemaOCNameToDescriptor( pEntry->pSchemaCtx, pAttrOC->vals[i].lberbv.bv_val, &pOCDesc); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirSchemaClassGetAllMustAttrs( pEntry->pSchemaCtx, pOCDesc, pAllMustAttrMap); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirSchemaClassGetAllMayAttrs( pEntry->pSchemaCtx, pOCDesc, pAllMayAttrMap); BAIL_ON_VMDIR_ERROR(dwError); } if (pbMust) { *pbMust = FALSE; if (LwRtlHashMapFindKey(pAllMustAttrMap, NULL, pszAttrName) == 0) { *pbMust = TRUE; } } if (pbMay) { *pbMay = FALSE; if (LwRtlHashMapFindKey(pAllMayAttrMap, NULL, pszAttrName) == 0) { *pbMay = TRUE; } } cleanup: LwRtlHashMapClear(pAllMustAttrMap, VmDirNoopHashMapPairFree, NULL); LwRtlFreeHashMap(&pAllMustAttrMap); LwRtlHashMapClear(pAllMayAttrMap, VmDirNoopHashMapPairFree, NULL); LwRtlFreeHashMap(&pAllMayAttrMap); return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); goto cleanup; }
//TODO_REMOVE_REPLV2 DWORD VmDirAttributeMetaDataToHashMap( PVDIR_ATTRIBUTE pAttrAttrMetaData, PLW_HASHMAP* ppMetaDataMap ) { DWORD dwError = 0; DWORD dwCnt = 0; PLW_HASHMAP pMetaDataMap = NULL; PSTR pszKey = NULL; PVMDIR_ATTRIBUTE_METADATA pMetaData = NULL; if (!pAttrAttrMetaData || !ppMetaDataMap) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = LwRtlCreateHashMap( &pMetaDataMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); for (dwCnt = 0; pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val != NULL; dwCnt++) { // Format is: <attr name>:<local USN>:<version no>:<originating server ID>:<originating time>:<originating USN> char* pszMetaData = VmDirStringChrA(pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val, ':'); if (pszMetaData == NULL) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_BACKEND_INVALID_METADATA); } // pszMetaData now points to <local USN>... pszMetaData++; //pAttrAttrMetaData->vals[i] has <attr type>\0<pszMetaData> *(pszMetaData - 1) = '\0'; dwError = VmDirAllocateStringA(pAttrAttrMetaData->vals[dwCnt].lberbv.bv_val, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirMetaDataDeserialize(pszMetaData, &pMetaData); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pMetaDataMap, pszKey, pMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); pszKey = NULL; pMetaData = NULL; } *ppMetaDataMap = pMetaDataMap; cleanup: return dwError; error: if (pMetaDataMap) { LwRtlHashMapClear( pMetaDataMap, VmDirFreeMetaDataMapPair, NULL); LwRtlFreeHashMap(&pMetaDataMap); } VmDirFreeMetaData(pMetaData); VMDIR_SAFE_FREE_MEMORY(pszKey); VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
DWORD VmDirAttributeMetaDataListConvertToHashMap( PVDIR_LINKED_LIST pMetaDataList, PLW_HASHMAP *ppMetaDataMap ) { DWORD dwError = 0; PLW_HASHMAP pMetaDataMap = NULL; PVDIR_LINKED_LIST_NODE pCurrNode = NULL; PVDIR_LINKED_LIST_NODE pNextNode = NULL; PVMDIR_REPL_ATTRIBUTE_METADATA pReplMetaData = NULL; if (!pMetaDataList || !ppMetaDataMap) { BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER); } dwError = LwRtlCreateHashMap( &pMetaDataMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirLinkedListGetHead(pMetaDataList, &pCurrNode); BAIL_ON_VMDIR_ERROR(dwError); while (pCurrNode) { pReplMetaData = (PVMDIR_REPL_ATTRIBUTE_METADATA) pCurrNode->pElement; pNextNode = pCurrNode->pNext; dwError = LwRtlHashMapInsert( pMetaDataMap, pReplMetaData->pszAttrType, pReplMetaData->pMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); pReplMetaData->pszAttrType = NULL; pReplMetaData->pMetaData = NULL; VmDirFreeReplMetaData(pReplMetaData); dwError = VmDirLinkedListRemove(pMetaDataList, pCurrNode); BAIL_ON_VMDIR_ERROR(dwError) pCurrNode = pNextNode; } *ppMetaDataMap = pMetaDataMap; cleanup: return dwError; error: if (pMetaDataMap) { LwRtlHashMapClear( pMetaDataMap, VmDirFreeMetaDataMapPair, NULL); LwRtlFreeHashMap(&pMetaDataMap); } VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError); goto cleanup; }
static DWORD _PopulateOperationModAttributes( LDAP *pLd, LDAPMessage *pEntry, PVDIR_OPERATION pLdapOp ) { DWORD dwError = 0; struct berval** ppValues = NULL; PLW_HASHMAP pHashMap = NULL; PSTR pszBuf = NULL; PSTR pszAttrName = NULL; PSTR pszAttrMetaData = NULL; PSTR pszAttrUsnlessMetaData = NULL; PSTR pszAttrNewMetaData = NULL; PSTR pszKey = NULL; PSTR pszValue = NULL; USN localUsn = 0; PVDIR_BERVALUE pBerValue = NULL; size_t iBerValueSize = 0; DWORD i = 0, j = 0; dwError = LwRtlCreateHashMap( &pHashMap, LwRtlHashDigestPstrCaseless, LwRtlHashEqualPstrCaseless, NULL ); BAIL_ON_VMDIR_ERROR(dwError); dwError = pLdapOp->pBEIF->pfnBEGetNextUSN(pLdapOp->pBECtx, &localUsn); BAIL_ON_VMDIR_ERROR(dwError); if (!(ppValues = ldap_get_values_len(pLd, pEntry, ATTR_ATTR_META_DATA))) { dwError = VMDIR_ERROR_SCHEMA_BAD_METADATA; BAIL_ON_VMDIR_ERROR(dwError); } for (i = 0; ppValues[i] != NULL; i++) { dwError = VmDirAllocateStringA(ppValues[i]->bv_val, &pszBuf); BAIL_ON_VMDIR_ERROR(dwError); pszAttrName = VmDirStringTokA(pszBuf, ":", &pszAttrMetaData); VmDirStringTokA(pszAttrMetaData, ":", &pszAttrUsnlessMetaData); dwError = VmDirAllocateStringPrintf( &pszAttrNewMetaData, "%ld:%s", localUsn, pszAttrUsnlessMetaData); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirAllocateStringA(pszAttrName, &pszKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapInsert(pHashMap, pszKey, pszAttrNewMetaData, NULL); BAIL_ON_VMDIR_ERROR(dwError); VMDIR_SAFE_FREE_MEMORY(pszBuf); } ldap_value_free_len(ppValues); ppValues = NULL; for (i = 0; ppszSchemaEntryAttrs[i] != NULL; i++) { if (VmDirStringCompareA(ppszSchemaEntryAttrs[i], ATTR_ATTR_META_DATA, FALSE) != 0) { ppValues = ldap_get_values_len(pLd, pEntry, ppszSchemaEntryAttrs[i]); if (ppValues) { iBerValueSize = ldap_count_values_len(ppValues); dwError = VmDirAllocateMemory( sizeof(VDIR_BERVALUE) * iBerValueSize, (PVOID*)&pBerValue); BAIL_ON_VMDIR_ERROR(dwError); if (VmDirStringCompareA(ppszSchemaEntryAttrs[i], ATTR_USN_CHANGED, FALSE) == 0) { assert(iBerValueSize == 1); dwError = VmDirAllocateStringPrintf(&pBerValue[0].lberbv_val, "%ld", localUsn); BAIL_ON_VMDIR_ERROR(dwError); pBerValue[0].lberbv_len = VmDirStringLenA(pBerValue[0].lberbv_val); pBerValue[0].bOwnBvVal = TRUE; } else { for (j = 0; j < iBerValueSize; j++) { dwError = VmDirAllocateStringA(ppValues[j]->bv_val, &pBerValue[j].lberbv_val); BAIL_ON_VMDIR_ERROR(dwError); pBerValue[j].lberbv_len = ppValues[j]->bv_len; pBerValue[j].bOwnBvVal = TRUE; } } dwError = VmDirOperationAddModReq( pLdapOp, MOD_OP_REPLACE, ppszSchemaEntryAttrs[i], pBerValue, iBerValueSize); BAIL_ON_VMDIR_ERROR(dwError); dwError = LwRtlHashMapFindKey( pHashMap, (PVOID*)&pszValue, ppszSchemaEntryAttrs[i]); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringCpyA( pLdapOp->request.modifyReq.mods->attr.metaData, VMDIR_MAX_ATTR_META_DATA_LEN, pszValue); BAIL_ON_VMDIR_ERROR(dwError); ldap_value_free_len(ppValues); ppValues = NULL; for (j = 0; j < iBerValueSize; j++) { VmDirFreeBervalContent(&pBerValue[j]); } VMDIR_SAFE_FREE_MEMORY(pBerValue); } } } cleanup: LwRtlHashMapClear(pHashMap, _FreeStringPair, NULL); LwRtlFreeHashMap(&pHashMap); return dwError; error: VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s,%d failed, error(%d)", __FUNCTION__, __LINE__, dwError ); VMDIR_SAFE_FREE_MEMORY(pszBuf); VMDIR_SAFE_FREE_MEMORY(pszAttrNewMetaData); if (ppValues) { ldap_value_free_len(ppValues); } for (j = 0; j < iBerValueSize; j++) { VmDirFreeBervalContent(&pBerValue[j]); } VMDIR_SAFE_FREE_MEMORY(pBerValue); goto cleanup; }
DWORD VmDirSchemaAttrIdMapUpdateDB( PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap ) { DWORD dwError = 0; DWORD dwNumNewIds = 0; LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT; LW_HASHMAP_PAIR pair = {NULL, NULL}; PSTR pszMapStr = NULL; PVMDIR_STRING_LIST pMapStrList = NULL; VDIR_BACKEND_CTX beCtx = {0}; BOOLEAN bHasTxn = FALSE; if (!pAttrIdMap) { dwError = ERROR_INVALID_PARAMETER; BAIL_ON_VMDIR_ERROR(dwError); } dwNumNewIds = LwRtlHashMapGetCount(pAttrIdMap->pNewIds); if (dwNumNewIds == 0) { // No new Id goto cleanup; } dwError = VmDirStringListInitialize(&pMapStrList, dwNumNewIds); BAIL_ON_VMDIR_ERROR(dwError); while (LwRtlHashMapIterate(pAttrIdMap->pNewIds, &iter, &pair)) { dwError = VmDirAllocateStringPrintf(&pszMapStr, "%d%s%s", (USHORT)(uintptr_t)pair.pValue, SCHEMA_ATTR_ID_MAP_SEP, (PSTR)pair.pKey); BAIL_ON_VMDIR_ERROR(dwError); dwError = VmDirStringListAdd(pMapStrList, pszMapStr); BAIL_ON_VMDIR_ERROR(dwError); } beCtx.pBE = VmDirBackendSelect(PERSISTED_DSE_ROOT_DN); dwError = beCtx.pBE->pfnBETxnBegin(&beCtx, VDIR_BACKEND_TXN_WRITE, &bHasTxn); BAIL_ON_VMDIR_ERROR( dwError ); dwError = beCtx.pBE->pfnBEDupKeySetValues(&beCtx, ATTR_ID_MAP_KEY, pMapStrList); BAIL_ON_VMDIR_ERROR(dwError); if (bHasTxn) { dwError = beCtx.pBE->pfnBETxnCommit(&beCtx); bHasTxn = FALSE; BAIL_ON_VMDIR_ERROR(dwError); } LwRtlHashMapResetIter(&iter); while (LwRtlHashMapIterate(pAttrIdMap->pNewIds, &iter, &pair)) { dwError = LwRtlHashMapInsert(pAttrIdMap->pStoredIds, pair.pKey, pair.pValue, NULL); BAIL_ON_VMDIR_ERROR(dwError); } LwRtlHashMapClear(pAttrIdMap->pNewIds, VmDirNoopHashMapPairFree, NULL); cleanup: VmDirBackendCtxContentFree(&beCtx); VmDirStringListFree(pMapStrList); return dwError; error: if (bHasTxn) { beCtx.pBE->pfnBETxnAbort(&beCtx); } VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "%s failed, error (%d)", __FUNCTION__, dwError ); goto cleanup; }