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