static
DWORD
VmDirLdapSchemaAddDef(
PLW_HASHMAP pDefMap,
PVDIR_LDAP_DEFINITION pDef
)
{
DWORD dwError = 0;
BOOLEAN bRemoveOnError = FALSE;
LW_HASHMAP_PAIR pair = {NULL, NULL};
PVDIR_LDAP_DEFINITION pPrevDef = NULL;
PVDIR_LDAP_DEFINITION_LIST pDefList = NULL;
PVDIR_LDAP_DEFINITION_LIST pNewDefList = NULL;
if (!pDefMap || !pDef)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = LwRtlHashMapInsert(pDefMap, pDef->pszName, pDef, &pair);
BAIL_ON_VMDIR_ERROR(dwError);
pPrevDef = (PVDIR_LDAP_DEFINITION)pair.pValue;
if (pPrevDef)
{
assert(!pDef->pList); // linked list conflict
pDefList = pPrevDef->pList;
}
else
{
pDefList = pDef->pList;
bRemoveOnError = TRUE;
}
if (!pDefList)
{
dwError = VmDirLdapDefListCreate(&pNewDefList);
BAIL_ON_VMDIR_ERROR(dwError);
pDefList = pNewDefList;
}
dwError = VmDirLdapDefListUpdateHead(pDefList, pDef);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
if (pPrevDef)
{
(VOID)LwRtlHashMapInsert(pDefMap, pPrevDef->pszName, pPrevDef, NULL);
}
else if (bRemoveOnError)
{
(VOID)LwRtlHashMapRemove(pDefMap, pDef->pszName, NULL);
}
VmDirFreeLdapDefList(pNewDefList);
goto cleanup;
}
DWORD
VmDirSchemaAttrIdMapAddNewAttr(
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;
}
DWORD
_VdcAddCopiesToHashTable(
PLW_HASHMAP pHashMap,
PCSTR pszKey,
PCSTR pszValue
)
{
DWORD dwError = 0;
PSTR pszKeyCopy = NULL;
PSTR pszValueCopy = NULL;
dwError = VmDirAllocateStringA(pszKey, &pszKeyCopy);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringA(pszValue, &pszValueCopy);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapInsert(pHashMap, pszKeyCopy, pszValueCopy, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
VMDIR_SAFE_FREE_STRINGA(pszKeyCopy);
VMDIR_SAFE_FREE_STRINGA(pszValueCopy);
goto cleanup;
}
DWORD
VmDirUTDVectorCacheAdd(
PVMDIR_UTDVECTOR_CACHE pUTDVector,
PCSTR pszInvocationId,
PCSTR pszUsn
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PSTR pszDupKey = NULL;
USN Usn = 0;
LW_HASHMAP_PAIR pair = {0};
if (IsNullOrEmptyString(pszInvocationId) || !pUTDVector)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
}
dwError = VmDirAllocateStringA(pszInvocationId, &pszDupKey);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirStringToINT64(pszUsn, NULL, &Usn);
BAIL_ON_VMDIR_ERROR(dwError);
VMDIR_RWLOCK_READLOCK(bInLock, pUTDVector->pUtdVectorLock, 0);
dwError = LwRtlHashMapInsert(pUTDVector->pUtdVectorMap, pszDupKey, (PVOID)Usn, &pair);
BAIL_ON_VMDIR_ERROR(dwError);
VmDirSimpleHashMapPairFreeKeyOnly(&pair, NULL);
pszDupKey = NULL;
VMDIR_SAFE_FREE_STRINGA(pUTDVector->pszUtdVector);
dwError = VmDirVectorToStr(pUTDVector->pUtdVectorMap, _VmDirUTDVectorPairToStr, &pUTDVector->pszUtdVector);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_RWLOCK_UNLOCK(bInLock, pUTDVector->pUtdVectorLock);
VMDIR_SAFE_FREE_MEMORY(pszDupKey);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);
goto cleanup;
}
static
DWORD
_VmDirDDVectorUpdateDefaultsInLock(
DWORD dwValue
)
{
DWORD dwError = 0;
PSTR pszKey = NULL;
PDWORD pdwValue = NULL;
LW_HASHMAP_PAIR pair = {NULL, NULL};
LW_HASHMAP_PAIR prevPair = {NULL, NULL};
dwError = VmDirAllocateStringA(
gVmdirServerGlobals.bvServerObjName.lberbv_val,
&pszKey);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateMemory(
sizeof(DWORD),
(PVOID*)&pdwValue);
BAIL_ON_VMDIR_ERROR(dwError);
*pdwValue = dwValue;
pair.pKey = pszKey; pair.pValue = pdwValue;
pszKey = NULL; pdwValue = NULL;
dwError = LwRtlHashMapInsert(
gVmdirServerGlobals.pReplDeadlockDetectionVector->pEmptyPageSentMap,
pair.pKey,
pair.pValue,
&prevPair);
BAIL_ON_VMDIR_ERROR(dwError);
VmDirSimpleHashMapPairFree(&prevPair, NULL);
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszKey);
VMDIR_SAFE_FREE_MEMORY(pdwValue);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);
goto cleanup;
}
/*
* should only be used during bootstrap
* maybe add state check?
*/
DWORD
VmDirIndexOpen(
PVDIR_INDEX_CFG pIndexCfg
)
{
DWORD dwError = 0;
BOOLEAN bInLock = FALSE;
PVDIR_BACKEND_INTERFACE pBE = NULL;
if (!pIndexCfg)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
VMDIR_LOCK_MUTEX(bInLock, gVdirIndexGlobals.mutex);
if (LwRtlHashMapFindKey(
gVdirIndexGlobals.pIndexCfgMap, NULL, pIndexCfg->pszAttrName) == 0)
{
dwError = ERROR_ALREADY_INITIALIZED;
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = LwRtlHashMapInsert(
gVdirIndexGlobals.pIndexCfgMap,
pIndexCfg->pszAttrName,
pIndexCfg,
NULL);
BAIL_ON_VMDIR_ERROR(dwError);
pBE = VmDirBackendSelect(NULL);
dwError = pBE->pfnBEIndexOpen(pIndexCfg);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_UNLOCK_MUTEX(bInLock, gVdirIndexGlobals.mutex);
return dwError;
error:
goto cleanup;
}
static
DWORD
_populateHashMapWithSuperlogEntries(
PLW_HASHMAP pHashMap,
PVMDIR_SUPERLOG_ENTRY_LDAPOPERATION_ARRAY pEntries,
PVMDIR_SUPERLOG_TABLE_COLUMN_SET pCols
)
{
DWORD dwError = 0;
PSTR pszKey = NULL;
PVMDIR_SUPERLOG_TABLE_ROW pValue = NULL;
unsigned int i;
for (i = 0; i < pEntries->dwCount; i++)
{
dwError = _generateHashMapKeyString(&pEntries->entries[i], pCols, &pszKey);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapFindKey(pHashMap, (PVOID*)&pValue, pszKey);
if (dwError == 0)
{
pValue->count += 1;
pValue->totalTime += pEntries->entries[i].iEndTime - pEntries->entries[i].iStartTime;
VMDIR_SAFE_FREE_MEMORY(pszKey);
}
else
{
dwError = _allocateSuperlogTableRow(&pEntries->entries[i], pCols, &pValue);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapInsert(pHashMap, pszKey, pValue, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
}
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDirIndexDeleteUniquenessScope(
PVDIR_INDEX_UPD pIndexUpd,
PCSTR pszAttrName,
PCSTR* ppszUniqScopes
)
{
DWORD dwError = 0;
DWORD i = 0;
PLW_HASHMAP pCurCfgMap = NULL;
PLW_HASHMAP pUpdCfgMap = NULL;
PVDIR_INDEX_CFG pCurCfg = NULL;
PVDIR_INDEX_CFG pUpdCfg = NULL;
PVDIR_INDEX_CFG pNewCfg = NULL;
if (!pIndexUpd || IsNullOrEmptyString(pszAttrName) || !ppszUniqScopes)
{
dwError = VMDIR_ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
pCurCfgMap = gVdirIndexGlobals.pIndexCfgMap;
pUpdCfgMap = pIndexUpd->pUpdIndexCfgMap;
(VOID)LwRtlHashMapFindKey(pCurCfgMap, (PVOID*)&pCurCfg, pszAttrName);
(VOID)LwRtlHashMapFindKey(pUpdCfgMap, (PVOID*)&pUpdCfg, pszAttrName);
if (pCurCfg && !pUpdCfg)
{
dwError = VmDirIndexCfgCopy(pCurCfg, &pUpdCfg);
BAIL_ON_VMDIR_ERROR(dwError);
pNewCfg = pUpdCfg;
}
if (!pUpdCfg ||
pUpdCfg->status == VDIR_INDEXING_DISABLED ||
pUpdCfg->status == VDIR_INDEXING_DELETED)
{
dwError = VMDIR_ERROR_NOT_FOUND;
BAIL_ON_VMDIR_ERROR(dwError);
}
if (!pUpdCfg->bScopeEditable ||
pUpdCfg->status == VDIR_INDEXING_VALIDATING_SCOPES)
{
dwError = VMDIR_ERROR_UNWILLING_TO_PERFORM;
BAIL_ON_VMDIR_ERROR(dwError);
}
for (i = 0; ppszUniqScopes[i]; i++)
{
dwError = VmDirIndexCfgDeleteUniqueScopeMod(pUpdCfg, ppszUniqScopes[i]);
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = LwRtlHashMapInsert(pUpdCfgMap, pUpdCfg->pszAttrName, pUpdCfg, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s failed, error (%d)", __FUNCTION__, dwError );
VmDirFreeIndexCfg(pNewCfg);
goto cleanup;
}
DWORD
VmDirIndexSchedule(
PVDIR_INDEX_UPD pIndexUpd,
PCSTR pszAttrName,
PCSTR pszAttrSyntaxOid
)
{
DWORD dwError = 0;
PLW_HASHMAP pCurCfgMap = NULL;
PLW_HASHMAP pUpdCfgMap = NULL;
PVDIR_INDEX_CFG pCurCfg = NULL;
PVDIR_INDEX_CFG pUpdCfg = NULL;
PVDIR_INDEX_CFG pNewCfg = NULL;
if (!pIndexUpd || IsNullOrEmptyString(pszAttrName))
{
dwError = VMDIR_ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
pCurCfgMap = gVdirIndexGlobals.pIndexCfgMap;
pUpdCfgMap = pIndexUpd->pUpdIndexCfgMap;
(VOID)LwRtlHashMapFindKey(pCurCfgMap, (PVOID*)&pCurCfg, pszAttrName);
(VOID)LwRtlHashMapFindKey(pUpdCfgMap, (PVOID*)&pUpdCfg, pszAttrName);
if (pUpdCfg)
{
dwError = ERROR_ALREADY_EXISTS;
BAIL_ON_VMDIR_ERROR(dwError);
}
if (pCurCfg)
{
if (pCurCfg->status == VDIR_INDEXING_DELETED)
{
dwError = VmDirIndexCfgCopy(pCurCfg, &pUpdCfg);
BAIL_ON_VMDIR_ERROR(dwError);
pNewCfg = pUpdCfg;
pUpdCfg->status = VDIR_INDEXING_SCHEDULED;
}
else if (pCurCfg->status == VDIR_INDEXING_DISABLED)
{
dwError = VMDIR_ERROR_BUSY;
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = ERROR_ALREADY_EXISTS;
BAIL_ON_VMDIR_ERROR(dwError);
}
}
else
{
dwError = VmDirIndexCfgCreate(pszAttrName, &pUpdCfg);
BAIL_ON_VMDIR_ERROR(dwError);
pNewCfg = pUpdCfg;
pUpdCfg->bIsNumeric = VmDirSchemaSyntaxIsNumeric(pszAttrSyntaxOid);
}
dwError = LwRtlHashMapInsert(pUpdCfgMap, pUpdCfg->pszAttrName, pUpdCfg, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s failed, error (%d)", __FUNCTION__, dwError );
VmDirFreeIndexCfg(pNewCfg);
goto cleanup;
}
DWORD
VmDirUTDVectorUpdateNew(
PVMDIR_UTDVECTOR_CACHE pNewUTDVectorCache
)
{
USN origUsnInDB = 0;
USN newOrigUsn = 0;
DWORD dwError = 0;
PSTR pszInvocationId = NULL;
PSTR pszKey = NULL;
LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT;
LW_HASHMAP_PAIR pair = {NULL, NULL};
if (!pNewUTDVectorCache)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
}
while (LwRtlHashMapIterate(pNewUTDVectorCache->pUtdVectorMap, &iter, &pair))
{
origUsnInDB = 0;
pszInvocationId = (PSTR) pair.pKey;
newOrigUsn = (USN) pair.pValue;
dwError = VmDirUTDVectorGlobalCacheLookup(pszInvocationId, &origUsnInDB);
if (dwError == LW_STATUS_NOT_FOUND)
{
dwError = 0;
}
BAIL_ON_VMDIR_ERROR(dwError);
if (origUsnInDB > newOrigUsn)
{
dwError = VmDirAllocateStringA(pszInvocationId, &pszKey);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapInsert(
pNewUTDVectorCache->pUtdVectorMap,
pszKey,
(PVOID)origUsnInDB,
&pair);
BAIL_ON_VMDIR_ERROR(dwError);
pszKey = NULL;
VmDirSimpleHashMapPairFreeKeyOnly(&pair, NULL);
VMDIR_LOG_WARNING(
VMDIR_LOG_MASK_ALL,
"%s: smaller origUsn InvoId: %s origUsnInDB: %"PRId64 "newOrigUsn: %" PRId64,
__FUNCTION__,
VDIR_SAFE_STRING(pszInvocationId),
origUsnInDB,
newOrigUsn);
}
}
cleanup:
return dwError;
error:
VMDIR_SAFE_FREE_MEMORY(pszKey);
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", 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
VmDirIndexCfgRestoreProgress(
PVDIR_BACKEND_CTX pBECtx,
PVDIR_INDEX_CFG pIndexCfg,
PBOOLEAN pbRestore
)
{
DWORD dwError = 0;
PSTR pszStatusKey = NULL;
PSTR pszStatusVal = NULL;
PSTR pszInitOffsetKey = NULL;
PSTR pszInitOffsetVal = NULL;
PSTR pszScopesKey = NULL;
PSTR pszScopesVal = NULL;
PSTR pszNewScopesKey = NULL;
PSTR pszNewScopesVal = NULL;
PSTR pszDelScopesKey = NULL;
PSTR pszDelScopesVal = NULL;
PSTR pszScope = NULL;
if (!pBECtx || !pIndexCfg || !pbRestore)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = _BuildAllKeyStrs(
pIndexCfg,
&pszStatusKey,
&pszInitOffsetKey,
&pszScopesKey,
&pszNewScopesKey,
&pszDelScopesKey);
BAIL_ON_VMDIR_ERROR(dwError);
if (gVdirIndexGlobals.bFirstboot)
{
pIndexCfg->status = VDIR_INDEXING_COMPLETE;
}
else
{
PSTR pszToken = NULL;
char* save = NULL;
dwError = pBECtx->pBE->pfnBEUniqKeyGetValue(
pBECtx, pszStatusKey, &pszStatusVal);
BAIL_ON_VMDIR_ERROR(dwError);
pIndexCfg->status = VmDirStringToIA(pszStatusVal);
dwError = pBECtx->pBE->pfnBEUniqKeyGetValue(
pBECtx, pszInitOffsetKey, &pszInitOffsetVal);
BAIL_ON_VMDIR_ERROR(dwError);
pIndexCfg->initOffset = VmDirStringToIA(pszInitOffsetVal);
dwError = pBECtx->pBE->pfnBEUniqKeyGetValue(
pBECtx, pszScopesKey, &pszScopesVal);
BAIL_ON_VMDIR_ERROR(dwError);
if (!IsNullOrEmptyString(pszScopesVal))
{
pszToken = VmDirStringTokA(pszScopesVal, INDEX_SEP, &save);
while (pszToken)
{
dwError = VmDirAllocateStringA(pszToken, &pszScope);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapInsert(
pIndexCfg->pUniqScopes, pszScope, NULL, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
pszScope = NULL;
pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save);
}
}
dwError = pBECtx->pBE->pfnBEUniqKeyGetValue(
pBECtx, pszNewScopesKey, &pszNewScopesVal);
BAIL_ON_VMDIR_ERROR(dwError);
if (!IsNullOrEmptyString(pszNewScopesVal))
{
pszToken = VmDirStringTokA(pszNewScopesVal, INDEX_SEP, &save);
while (pszToken)
{
dwError = VmDirAllocateStringA(pszToken, &pszScope);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirLinkedListInsertHead(
pIndexCfg->pNewUniqScopes, pszScope, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
pszScope = NULL;
pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save);
}
}
dwError = pBECtx->pBE->pfnBEUniqKeyGetValue(
pBECtx, pszDelScopesKey, &pszDelScopesVal);
BAIL_ON_VMDIR_ERROR(dwError);
if (!IsNullOrEmptyString(pszDelScopesVal))
{
pszToken = VmDirStringTokA(pszDelScopesVal, INDEX_SEP, &save);
while (pszToken)
{
dwError = VmDirAllocateStringA(pszToken, &pszScope);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirLinkedListInsertHead(
pIndexCfg->pDelUniqScopes, pszScope, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
pszScope = NULL;
pszToken = VmDirStringTokA(NULL, INDEX_SEP, &save);
}
}
*pbRestore = TRUE;
}
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszStatusKey);
VMDIR_SAFE_FREE_MEMORY(pszStatusVal);
VMDIR_SAFE_FREE_MEMORY(pszInitOffsetKey);
VMDIR_SAFE_FREE_MEMORY(pszInitOffsetVal);
VMDIR_SAFE_FREE_MEMORY(pszScopesKey);
VMDIR_SAFE_FREE_MEMORY(pszScopesVal);
VMDIR_SAFE_FREE_MEMORY(pszNewScopesKey);
VMDIR_SAFE_FREE_MEMORY(pszNewScopesVal);
VMDIR_SAFE_FREE_MEMORY(pszDelScopesKey);
VMDIR_SAFE_FREE_MEMORY(pszDelScopesVal);
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s failed, error (%d)", __FUNCTION__, dwError );
VMDIR_SAFE_FREE_MEMORY(pszScope);
goto cleanup;
}
DWORD
VmDirSchemaAttrIdMapReadDB(
PVDIR_SCHEMA_ATTR_ID_MAP pAttrIdMap
)
{
DWORD dwError = 0;
DWORD i = 0;
VDIR_BACKEND_CTX beCtx = {0};
BOOLEAN bHasTxn = FALSE;
PVMDIR_STRING_LIST pStringList = NULL;
PSTR pszBuf = NULL;
PSTR pszName = NULL;
PSTR pszId = NULL;
USHORT usId = 0;
if (!pAttrIdMap)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
beCtx.pBE = VmDirBackendSelect(PERSISTED_DSE_ROOT_DN);
dwError = beCtx.pBE->pfnBETxnBegin(&beCtx, VDIR_BACKEND_TXN_READ, &bHasTxn);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = beCtx.pBE->pfnBEDupKeyGetValues(
&beCtx, ATTR_ID_MAP_KEY, &pStringList);
BAIL_ON_VMDIR_ERROR(dwError);
if (bHasTxn)
{
dwError = beCtx.pBE->pfnBETxnCommit(&beCtx);
bHasTxn = FALSE;
BAIL_ON_VMDIR_ERROR(dwError);
}
for (i = 0; i < pStringList->dwCount; i++)
{
dwError = VmDirAllocateStringA(pStringList->pStringList[i], &pszBuf);
BAIL_ON_VMDIR_ERROR(dwError);
pszId = VmDirStringTokA(pszBuf, SCHEMA_ATTR_ID_MAP_SEP, &pszName);
usId = (USHORT)VmDirStringToIA(pszId);
if (VmDirSchemaAttrIdMapGetAttrId(pAttrIdMap, pszName, NULL) != 0)
{
dwError = VmDirAllocateStringA(pszName, &pszName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = LwRtlHashMapInsert(pAttrIdMap->pStoredIds,
pszName, (PVOID)(uintptr_t)usId, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
if (usId >= pAttrIdMap->usNextId)
{
pAttrIdMap->usNextId = usId + 1;
}
}
VMDIR_SAFE_FREE_MEMORY(pszBuf);
}
cleanup:
VmDirBackendCtxContentFree(&beCtx);
VmDirStringListFree(pStringList);
return dwError;
error:
if (bHasTxn)
{
beCtx.pBE->pfnBETxnAbort(&beCtx);
}
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s failed, error (%d)", __FUNCTION__, dwError );
VMDIR_SAFE_FREE_MEMORY(pszBuf);
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;
}
