static
DWORD
_VmDirDeadlockDetectionVectorPairToStr(
LW_HASHMAP_PAIR pair,
BOOLEAN bStart,
PSTR* ppOutStr
)
{
PSTR pszTempStr = NULL;
DWORD dwError = 0;
VMDIR_LOG_INFO(LDAP_DEBUG_REPL, "%s: key: %s value: %d", (PSTR)pair.pKey, *(PDWORD)pair.pValue);
if (bStart)
{
dwError = VmDirAllocateStringPrintf(&pszTempStr, "vector:%s:%d", pair.pKey, *(PDWORD)pair.pValue);
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = VmDirAllocateStringPrintf(&pszTempStr, ",%s:%d", pair.pKey, *(PDWORD)pair.pValue);
BAIL_ON_VMDIR_ERROR(dwError);
}
*ppOutStr = pszTempStr;
pszTempStr = NULL;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszTempStr);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);
goto cleanup;
}
DWORD
VmDirTestCreateContainer(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer,
PCSTR pszAcl /* OPTIONAL */
)
{
DWORD dwError = 0;
PCSTR valsCn[] = {pszContainer, NULL};
PCSTR valsClass[] = {"top", "container", NULL};
PCSTR valsAcl[] = {pszAcl, NULL};
PSTR pszDN = NULL;
LDAPMod mod[]={
{LDAP_MOD_ADD, ATTR_CN, {(PSTR*)valsCn}},
{LDAP_MOD_ADD, ATTR_OBJECT_CLASS, {(PSTR*)valsClass}},
{LDAP_MOD_ADD, ATTR_ACL_STRING, {(PSTR*)valsAcl}},
};
LDAPMod *attrs[] = {&mod[0], &mod[1], &mod[2], NULL};
if (IsNullOrEmptyString(pszContainer))
{
valsCn[0] = VmDirTestGetTestContainerCn(pState);
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,%s",
VmDirTestGetTestContainerCn(pState),
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,cn=%s,%s",
pszContainer,
VmDirTestGetTestContainerCn(pState),
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
}
if (IsNullOrEmptyString(pszAcl))
{
attrs[2] = NULL;
}
dwError = ldap_add_ext_s(
pState->pLd, pszDN, attrs, NULL, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszDN);
return dwError;
error:
goto cleanup;
}
static
DWORD
_VmDirGetReplicateStatusCycle(
PCSTR pszHostName,
PCSTR pszUserName,
PCSTR pszPassword
)
{
DWORD dwError = 0;
PSTR pszDomainName = NULL;
PSTR pszURI = NULL;
DWORD dwCycleCount = 0;
PVMDIR_CONNECTION pConnection = NULL;
if ( VmDirIsIPV6AddrFormat( pszHostName ) )
{
dwError = VmDirAllocateStringPrintf( &pszURI, "ldap://[%s]", pszHostName );
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = VmDirAllocateStringPrintf( &pszURI, "ldap://%s", pszHostName );
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = VmDirGetDomainName( pszHostName, &pszDomainName );
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirConnectionOpen( pszURI, pszDomainName, pszUserName, pszPassword, &pConnection );
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirGetReplicationCycleCount( pConnection, &dwCycleCount );
BAIL_ON_VMDIR_ERROR(dwError);
if (dwCycleCount == 0)
{
printf("First replication cycle done: FALSE\n");
}
else
{
printf("First replication cycle done: TRUE\n");
}
cleanup:
VMDIR_SAFE_FREE_MEMORY( pszURI );
VMDIR_SAFE_FREE_MEMORY( pszDomainName );
VmDirConnectionClose( pConnection );
return dwError;
error:
printf("First replication cycle done: UNKNOWN, error code (%u)\n", dwError);
goto cleanup;
}
DWORD
TryToWriteSD(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer
)
{
DWORD dwError = 0;
PSTR ppszAttributeValues[] = { NULL, NULL };
PSTR pszUserName = NULL;
PSTR pszUserDn = NULL;
PSTR pszDomainSid = NULL;
dwError = VmDirTestGetGuid(&pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestCreateUser(pState, pszContainer, pszUserName, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUserDn,
"cn=%s,cn=%s,%s",
pszUserName,
pszContainer,
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestGetDomainSid(pState, pState->pszBaseDN, &pszDomainSid);
BAIL_ON_VMDIR_ERROR(dwError);
// Random SD. Actual values don't (entirely) matter.
dwError = VmDirAllocateStringPrintf(
&ppszAttributeValues[0],
"O:BAG:BAD:(A;;RCRPWPWDSD;;;%s-500)(A;;RCRPWPWDSD;;;%s-544)",
pszDomainSid,
pszDomainSid);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestReplaceAttributeValues(
pState->pLd,
pszUserDn,
ATTR_ACL_STRING,
(PCSTR*)ppszAttributeValues);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(ppszAttributeValues[0]);
VMDIR_SAFE_FREE_STRINGA(pszDomainSid);
VMDIR_SAFE_FREE_STRINGA(pszUserName);
VMDIR_SAFE_FREE_STRINGA(pszUserDn);
return dwError;
error:
goto cleanup;
}
/*
* caller owns return PSTR
*/
PSTR
VmDirOPStatistic(
ber_tag_t opTag
)
{
DWORD dwError = 0;
PSTR pszStatistic = NULL;
PVMDIR_OPERATION_STATISTIC pOPStatistic = NULL;
pOPStatistic = _VmDirGetStatisticFromTag(opTag);
if (pOPStatistic != NULL)
{
PCSTR pszOPName = VmDirGetOperationStringFromTag(opTag);
dwError = VmDirAllocateStringPrintf(
&pszStatistic,
"LDAP %10s - count:(%ld), Avg response time in MS:(%ld)",
pszOPName,
VmDirOPStatisticGetCount(opTag),
VmDirOPStatisticGetAvgTime(pOPStatistic));
BAIL_ON_VMDIR_ERROR(dwError);
}
cleanup:
return pszStatistic;
error:
VMDIR_SAFE_FREE_MEMORY(pszStatistic);
goto cleanup;
}
static
DWORD
_VmDirUTDVectorPairToStr(
LW_HASHMAP_PAIR pair,
BOOLEAN bFirst,
PSTR* ppOutStr
)
{
PSTR pszTempStr = NULL;
DWORD dwError = 0;
dwError = VmDirAllocateStringPrintf(&pszTempStr, "%s:%"PRId64",", pair.pKey, (USN)pair.pValue);
BAIL_ON_VMDIR_ERROR(dwError);
*ppOutStr = pszTempStr;
pszTempStr = NULL;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszTempStr);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "failed, error (%d)", dwError);
goto cleanup;
}
DWORD
VmDirTestConnectionFromUser(
PVMDIR_TEST_STATE pState,
PCSTR pszUserName,
LDAP **ppLd
)
{
DWORD dwError = 0;
PSTR pszUserUPN = NULL;
LDAP *pLd;
dwError = VmDirAllocateStringPrintf(
&pszUserUPN,
"%s@%s",
pszUserName,
pState->pszDomain);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSafeLDAPBind(
&pLd,
pState->pszServerName,
pszUserUPN,
pState->pszPassword);
BAIL_ON_VMDIR_ERROR(dwError);
*ppLd = pLd;
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszUserUPN);
return dwError;
error:
goto cleanup;
}
DWORD VmDirSetBaseDN(
PVMDIR_TEST_STATE pState
)
{
PSTR pszBaseDN = NULL;
DWORD dwError = 0;
PSTR pszDot = NULL;
pszDot = strchr(pState->pszDomain, '.');
if (pszDot == NULL)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
}
*pszDot = '\0';
dwError = VmDirAllocateStringPrintf(
&pszBaseDN,
"dc=%s,dc=%s",
pState->pszDomain,
pszDot + 1);
*pszDot = '.';
BAIL_ON_VMDIR_ERROR(dwError);
pState->pszBaseDN = pszBaseDN;
cleanup:
return dwError;
error:
VMDIR_SAFE_FREE_STRINGA(pszBaseDN);
goto cleanup;
}
DWORD
TryToListChildObjects(
PVMDIR_TEST_STATE pState,
PCSTR pszContainerName
)
{
DWORD dwError = 0;
PSTR pszUserName = NULL;
PSTR pszContainerDn = NULL;
dwError = VmDirTestGetGuid(&pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestCreateUser(pState, pszContainerName, pszUserName, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszContainerDn,
"cn=%s,%s",
pszContainerName,
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestGetObjectList(pState->pLd, pszContainerDn, NULL, NULL, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDirAdministratorAccessCheck(
PCSTR pszUpn,
PCSTR pszDomainDn
)
{
DWORD dwError = 0;
const CHAR szAdministrators[] = "cn=Administrators,cn=Builtin";
PSTR pszAdministratorsDn = NULL;
PSTR *ppszMemberships = NULL;
DWORD dwMemberships = 0;
PSTR pszSystemDomainDn = NULL;
if (IsNullOrEmptyString(pszUpn) || IsNullOrEmptyString(pszDomainDn))
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
VMDIR_GET_SYSTEM_DOMAIN_DN(pszSystemDomainDn, dwError);
dwError = VmDirGetUPNMemberships(pszUpn, &ppszMemberships, &dwMemberships);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(&pszAdministratorsDn, "%s,%s", szAdministrators, pszDomainDn);
BAIL_ON_VMDIR_ERROR(dwError);
if (VmDirStringCompareA(pszSystemDomainDn, pszDomainDn, FALSE) == 0)
{
if (!VmDirIsMemberOf(ppszMemberships, dwMemberships, gVmdirServerGlobals.bvDCGroupDN.lberbv.bv_val) &&
!VmDirIsMemberOf(ppszMemberships, dwMemberships, pszAdministratorsDn))
{
dwError = ERROR_ACCESS_DENIED;
BAIL_ON_VMDIR_ERROR(dwError);
}
}
else
{
if (!VmDirIsMemberOf(ppszMemberships, dwMemberships, pszAdministratorsDn))
{
dwError = ERROR_ACCESS_DENIED;
BAIL_ON_VMDIR_ERROR(dwError);
}
}
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszAdministratorsDn);
VmDirFreeMemberships(ppszMemberships, dwMemberships);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "VmDirAdministratorAccessCheck failed (%u)", dwError);
goto cleanup;
}
static
DWORD
_VmGetHighestCommittedUSN(
PSTR* ppszHighestCommittedUSN
)
{
DWORD dwError = 0;
USN usn = 0;
USN nextUSN = 0;
VDIR_ENTRY_ARRAY entryArray = {0};
PSTR pszUSN = NULL;
VDIR_BACKEND_CTX beCtx = {0};
beCtx.pBE = VmDirBackendSelect(NULL);
assert(beCtx.pBE);
dwError = beCtx.pBE->pfnBEGetNextUSN(&beCtx, &nextUSN);
BAIL_ON_VMDIR_ERROR(dwError);
for (usn=nextUSN; usn > 1LL; usn--)
{
VMDIR_SAFE_FREE_MEMORY(pszUSN);
VmDirFreeEntryArrayContent(&entryArray);
dwError = VmDirAllocateStringPrintf(&pszUSN, "%" PRId64, usn);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSimpleEqualFilterInternalSearch(
"", LDAP_SCOPE_SUBTREE, ATTR_USN_CHANGED, pszUSN, &entryArray);
BAIL_ON_VMDIR_ERROR(dwError);
if (entryArray.iSize == 1 )
{
break;
}
}
if (usn == 0)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_STATE);
}
*ppszHighestCommittedUSN = pszUSN;
pszUSN = NULL;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszUSN);
VmDirFreeEntryArrayContent(&entryArray);
VmDirBackendCtxContentFree(&beCtx);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "error (%u), start USN %" PRId64, dwError, nextUSN);
goto cleanup;
}
static
DWORD
_convertHashMapToSuperlogTable(
PLW_HASHMAP pHashMap,
PVMDIR_SUPERLOG_TABLE_COLUMN_SET pCols,
PVMDIR_SUPERLOG_TABLE *ppTable
)
{
DWORD dwError = 0;
DWORD dwCount = 0;
PVMDIR_SUPERLOG_TABLE pTable = NULL;
LW_HASHMAP_ITER iter = LW_HASHMAP_ITER_INIT;
LW_HASHMAP_PAIR pair = {NULL, NULL};
unsigned int i = 0;
unsigned int j;
PVMDIR_SUPERLOG_TABLE_ROW pSrcRow = NULL;
PVMDIR_SUPERLOG_TABLE_ROW pDstRow = NULL;
dwCount = LwRtlHashMapGetCount(pHashMap);
dwError = _allocateSuperlogTable(dwCount, pCols, &pTable);
BAIL_ON_VMDIR_ERROR(dwError);
while (LwRtlHashMapIterate(pHashMap, &iter, &pair))
{
pSrcRow = pair.pValue;
pDstRow = (PVMDIR_SUPERLOG_TABLE_ROW)&pTable->rows[i++];
pDstRow->count = pSrcRow->count;
pDstRow->totalTime = pSrcRow->totalTime;
for (j = 0; j < VMDIR_SUPERLOG_TABLE_COL_NUM; j++)
{
if (pSrcRow->colVals[j])
{
dwError = VmDirAllocateStringA(pSrcRow->colVals[j], &pDstRow->colVals[j]);
BAIL_ON_VMDIR_ERROR(dwError);
}
}
dwError = VmDirAllocateStringPrintf(
&pDstRow->colVals[AVG_TIME],
"%lu",
pDstRow->totalTime / pDstRow->count
);
BAIL_ON_VMDIR_ERROR(dwError);
}
*ppTable = pTable;
cleanup:
return dwError;
error:
VmDirFreeSuperLogTable(pTable);
goto cleanup;
}
int
VmDirCreateRequestVoteCtrl(
PVDIR_REQUEST_VOTE_CONTROL_VALUE pRequestVoteCtrlValue,
LDAPControl* pRequestVoteCtrl
)
{
int retVal = LDAP_SUCCESS;
BerElement* pBer = NULL;
BerValue candidateIdBV = {0};
BerValue lastLogIndexBV = {0};
if (!pRequestVoteCtrlValue || !pRequestVoteCtrl)
{
BAIL_WITH_VMDIR_ERROR(retVal, VMDIR_ERROR_INVALID_PARAMETER);
}
if ((pBer = ber_alloc()) == NULL)
{
BAIL_WITH_VMDIR_ERROR(retVal, VMDIR_ERROR_NO_MEMORY);
}
candidateIdBV.bv_val = pRequestVoteCtrlValue->candidateId;
candidateIdBV.bv_len = VmDirStringLenA(pRequestVoteCtrlValue->candidateId);
retVal = VmDirAllocateStringPrintf(&lastLogIndexBV.bv_val, "%"PRIu64, pRequestVoteCtrlValue->lastLogIndex);
BAIL_ON_VMDIR_ERROR( retVal );
lastLogIndexBV.bv_len = VmDirStringLenA(lastLogIndexBV.bv_val);
if ( ber_printf( pBer, "{iOOi}", pRequestVoteCtrlValue->term, &candidateIdBV,
&lastLogIndexBV, pRequestVoteCtrlValue->lastLogTerm) == -1)
{
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "%s: ber_printf failed.", __FUNCTION__ );
BAIL_WITH_VMDIR_ERROR(retVal, VMDIR_ERROR_NO_MEMORY);
}
memset( pRequestVoteCtrl, 0, sizeof( LDAPControl ));
pRequestVoteCtrl->ldctl_oid = LDAP_REQUEST_VOTE_CONTROL;
pRequestVoteCtrl->ldctl_iscritical = '1';
if (ber_flatten2(pBer, &pRequestVoteCtrl->ldctl_value, 1))
{
BAIL_WITH_VMDIR_ERROR(retVal, VMDIR_ERROR_NO_MEMORY);
}
cleanup:
VMDIR_SAFE_FREE_MEMORY(lastLogIndexBV.bv_val);
if (pBer)
{
ber_free(pBer, 1);
}
return retVal;
error:
VmDirFreeCtrlContent(pRequestVoteCtrl);
goto cleanup;
}
DWORD
VmDirTestDeleteContainer(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer
)
{
DWORD dwError = 0;
PSTR pszDN = NULL;
if (IsNullOrEmptyString(pszContainer))
{
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,%s",
VmDirTestGetTestContainerCn(pState),
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
}
else
{
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,cn=%s,%s",
pszContainer,
VmDirTestGetTestContainerCn(pState),
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = VmDirTestDeleteContainerByDn(pState->pLd, pszDN);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszDN);
return dwError;
error:
goto cleanup;
}
static
DWORD
_OpenLdapConnection(
PCSTR pszFQDomainName,
PCSTR pszUsername,
PCSTR pszPassword,
PCSTR pszReplURI,
LDAP **ppLd
)
{
DWORD dwError = 0;
PSTR pszPartnerHostName = NULL;
PSTR pszUPN = NULL;
LDAP *pLd = NULL;
dwError = VmDirReplURIToHostname((PSTR)pszReplURI, &pszPartnerHostName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUPN,
"%s@%s",
pszUsername,
pszFQDomainName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSafeLDAPBind(
&pLd,
pszPartnerHostName,
pszUPN,
pszPassword);
BAIL_ON_VMDIR_ERROR(dwError);
*ppLd = pLd;
cleanup:
VMDIR_SAFE_FREE_MEMORY(pszPartnerHostName);
VMDIR_SAFE_FREE_MEMORY(pszUPN);
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL,
"%s,%d failed, error(%d)", __FUNCTION__, __LINE__, dwError );
if (pLd)
{
ldap_unbind_ext_s(pLd,NULL,NULL);
}
goto cleanup;
}
DWORD
_TestVmDirAllocateStringPrintfWithBadParameters(
PVMDIR_TEST_STATE pState
)
{
DWORD dwError = 0;
PSTR pszString = NULL;
dwError = VmDirAllocateStringPrintf(
NULL,
"dword ==> %d, string ==> '%s'",
42,
"Hello, world!");
TestAssertEquals(dwError, ERROR_INVALID_PARAMETER);
dwError = VmDirAllocateStringPrintf(
&pszString,
NULL,
42,
"Hello, world!");
TestAssertEquals(dwError, ERROR_INVALID_PARAMETER);
return 0;
}
DWORD
TryToReadSD(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer
)
{
DWORD dwError = 0;
PSTR pszAttribute = NULL;
PSTR pszUserName = NULL;
PSTR pszUserDn = NULL;
dwError = VmDirTestGetGuid(&pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestCreateUser(pState, pszContainer, pszUserName, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUserDn,
"cn=%s,cn=%s,%s",
pszUserName,
pszContainer,
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = _VdcSearchForEntryAndAttribute(
pState->pLd,
pszUserDn,
ATTR_ACL_STRING,
&pszAttribute);
BAIL_ON_VMDIR_ERROR(dwError);
//
// Make sure there's data. We don't bother validating the contents of the
// SD as that's installation- and entry-specific.
//
if (strlen(pszAttribute) == 0)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_DATA_CONSTRAINT_VIOLATION);
}
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszAttribute);
return dwError;
error:
goto cleanup;
}
static
DWORD
_VmDirComposeHighWaterMark(
PVMDIR_SWAP_DB_INFO pSwapDBInfo
)
{
DWORD dwError = 0;
PVDIR_ENTRY pServerEntry = NULL;
PVDIR_ATTRIBUTE pAttrInvocationId = NULL;
VDIR_OPERATION searchOp = {0};
USN hwmUSN = 0;
dwError = VmDirInitStackOperation(&searchOp, VDIR_OPERATION_TYPE_INTERNAL, LDAP_REQ_SEARCH, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirInternalSearchSeverObj(pSwapDBInfo->pszPartnerServerName, &searchOp);
BAIL_ON_VMDIR_ERROR(dwError);
pServerEntry = searchOp.internalSearchEntryArray.pEntry;
pAttrInvocationId = VmDirEntryFindAttribute(ATTR_INVOCATION_ID, pServerEntry);
// use this node max originating usn as high water mark
dwError = VmDirUTDVectorCacheLookup(
pSwapDBInfo->pMyUTDVector, pAttrInvocationId->vals[0].lberbv_val, &hwmUSN);
if (dwError == LW_STATUS_NOT_FOUND)
{
VMDIR_LOG_WARNING(VMDIR_LOG_MASK_ALL,
"Partner (%s,%s) not found in ORG DB UTDVector (%s). Join scenario NOT supported.",
pSwapDBInfo->pszPartnerServerName,
pAttrInvocationId->vals[0].lberbv_val,
pSwapDBInfo->pMyUTDVector->pszUtdVector);
}
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(&pSwapDBInfo->pszMyHighWaterMark, "%" PRId64, hwmUSN);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VmDirFreeOperationContent(&searchOp);
return dwError;
error:
VMDIR_LOG_ERROR(VMDIR_LOG_MASK_ALL, "error (%u)", dwError);
goto cleanup;
}
DWORD
_TestVmDirAllocateStringPrintfWithGoodParameters(
PVMDIR_TEST_STATE pState
)
{
PSTR pszString = NULL;
DWORD dwError = 0;
dwError = VmDirAllocateStringPrintf(
&pszString,
"dword ==> %d, string ==> '%s'",
(DWORD)42,
"Hello, world!");
TestAssertEquals(dwError, ERROR_SUCCESS);
TestAssertStrEquals(pszString, "dword ==> 42, string ==> 'Hello, world!'");
return 0;
}
DWORD
TryToReadProperties(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer
)
{
DWORD dwError = 0;
PSTR pszAttribute = NULL;
PSTR pszUserName = NULL;
PSTR pszUserDn = NULL;
dwError = VmDirTestGetGuid(&pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestCreateUser(pState, pszContainer, pszUserName, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUserDn,
"cn=%s,cn=%s,%s",
pszUserName,
pszContainer,
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = _VdcSearchForEntryAndAttribute(
pState->pLd,
pszUserDn,
ATTR_SAM_ACCOUNT_NAME,
&pszAttribute);
BAIL_ON_VMDIR_ERROR(dwError);
if (strcmp(pszAttribute, pszUserName) != 0)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_DATA_CONSTRAINT_VIOLATION);
}
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszAttribute);
return dwError;
error:
goto cleanup;
}
DWORD
VmDirTestCreateClass(
PVMDIR_TEST_STATE pState,
PCSTR pszClassName
)
{
DWORD dwError = 0;
PCSTR valsCn[] = {pszClassName, NULL};
PCSTR valsClass[] = {"classschema", NULL};
PCSTR valsSubclass[] = {OC_TOP, NULL};
PCSTR valsGovernsId[] = {"111.111.4.001", NULL};
PCSTR valsCategory[] = {"1", NULL};
PSTR pszDN = NULL;
LDAPMod mod[]={
{LDAP_MOD_ADD, ATTR_CN, {(PSTR*)valsCn}},
{LDAP_MOD_ADD, ATTR_OBJECT_CLASS, {(PSTR*)valsClass}},
{LDAP_MOD_ADD, "governsid", {(PSTR*)valsGovernsId}},
{LDAP_MOD_ADD, "objectclasscategory", {(PSTR*)valsCategory}},
{LDAP_MOD_ADD, "subclassof", {(PSTR*)valsSubclass}},
};
LDAPMod *attrs[] = {&mod[0], &mod[1], &mod[2], &mod[3], &mod[4], NULL};
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,cn=schemacontext",
pszClassName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = ldap_add_ext_s(
pState->pLd,
pszDN,
attrs,
NULL,
NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszDN);
return dwError;
error:
goto cleanup;
}
static
int
_VmGetHighestCommittedUSN(
USN startUsn,
USN *hcUsn)
{
DWORD dwError = 0;
USN usn = 0;
VDIR_ENTRY_ARRAY entryArray = {0};
PSTR usnStr = NULL;
for (usn=startUsn; usn > 1LL; usn--)
{
VMDIR_SAFE_FREE_MEMORY(usnStr);
VmDirFreeEntryArrayContent(&entryArray);
dwError = VmDirAllocateStringPrintf(&usnStr, "%" PRId64, usn);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSimpleEqualFilterInternalSearch(
"", LDAP_SCOPE_SUBTREE, ATTR_USN_CHANGED, usnStr, &entryArray);
BAIL_ON_VMDIR_ERROR(dwError);
if (entryArray.iSize == 1 )
{
*hcUsn = usn;
goto cleanup;
}
}
dwError = LDAP_OPERATIONS_ERROR;
goto error;
cleanup:
VMDIR_SAFE_FREE_MEMORY(usnStr);
VmDirFreeEntryArrayContent(&entryArray);
return dwError;
error:
VMDIR_LOG_ERROR( VMDIR_LOG_MASK_ALL, "_VmGetHighestCommittedUSN: fail to find an entry with USN <= %" PRId64, startUsn);
goto cleanup;
}
DWORD
VdcSchemaConnValidateAndSetDefault(
PVDC_SCHEMA_CONN pConn
)
{
DWORD dwError = 0;
if (!pConn)
{
dwError = VMDIR_ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
// domain is mandatory
if (!pConn->pszDomain)
{
dwError = VMDIR_ERROR_INVALID_PARAMETER;
BAIL_ON_VMDIR_ERROR(dwError);
}
// default host is "localhost"
if (!pConn->pszHostName)
{
dwError = VmDirAllocateStringA("localhost", &pConn->pszHostName);
BAIL_ON_VMDIR_ERROR(dwError);
}
// default user is "administrator"
if (!pConn->pszUserName)
{
dwError = VmDirAllocateStringA("administrator", &pConn->pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
}
dwError = VmDirAllocateStringPrintf(
&pConn->pszUPN, "%s@%s", pConn->pszUserName, pConn->pszDomain);
BAIL_ON_VMDIR_ERROR(dwError);
error:
return dwError;
}
DWORD
VmDirTestCreateObjectByDNPrefix(
PVMDIR_TEST_STATE pState,
PCSTR pszDNPrefix,
PCSTR pszClassName
)
{
DWORD dwError = 0;
PSTR pszCN = NULL;
PSTR pszDN = NULL;
PSTR valsCn[] = { NULL, NULL };
PSTR valsClass[] = { NULL, NULL };
LDAPMod mod[]=
{
{ LDAP_MOD_ADD, ATTR_CN, { valsCn } },
{ LDAP_MOD_ADD, ATTR_OBJECT_CLASS, { valsClass } },
};
LDAPMod *attrs[] = {&mod[0], &mod[1], NULL};
dwError = VmDirDnLastRDNToCn(pszDNPrefix, &pszCN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszDN, "%s,%s", pszDNPrefix, pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
valsCn[0] = pszCN;
valsClass[0] = (PSTR)pszClassName;
dwError = ldap_add_ext_s(pState->pLd, pszDN, attrs, NULL, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszCN);
VMDIR_SAFE_FREE_STRINGA(pszDN);
return dwError;
error:
goto cleanup;
}
DWORD
VmDirGetDefaultSchemaFile(
PSTR* ppszSchemaFile
)
{
DWORD dwError = 0;
PSTR pszSchemaFile = NULL;
#ifdef _WIN32
PSTR pszCfgPath = NULL;
#else
PCSTR pszLinuxFile = LWRAFT_CONFIG_DIR VMDIR_PATH_SEPARATOR_STR VMDIR_DEFAULT_SCHEMA_FILE ;
#endif
if (!ppszSchemaFile)
{
BAIL_WITH_VMDIR_ERROR(dwError, VMDIR_ERROR_INVALID_PARAMETER);
}
#ifdef _WIN32
dwError = VmDirGetCfgPath(&pszCfgPath);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(&pszSchemaFile,"%s\\%s", pszCfgPath, VMDIR_DEFAULT_SCHEMA_FILE);
BAIL_ON_VMDIR_ERROR(dwError);
#else
dwError = VmDirAllocateStringA(pszLinuxFile, &pszSchemaFile);
BAIL_ON_VMDIR_ERROR(dwError);
#endif
*ppszSchemaFile = pszSchemaFile;
cleanup:
return dwError;
error:
#ifdef _WIN32
VMDIR_SAFE_FREE_MEMORY(pszCfgPath);
#endif
VMDIR_SAFE_FREE_MEMORY(pszSchemaFile);
goto cleanup;
}
/*
* Error map from MDB to BE space
* If no map specified, ERROR_BACKEND_ERROR is returned.
*
* BECtx.dwBEErrorCode is set to the first mdb error encountered
* BECtx.pszBEErrorMsg is set to the first mdb error text encountered
*
* NOTE, this could be called multiple times during one LDAP level operation.
* The last one counts.
*/
DWORD
MDBToBackendError(
DWORD dwMdbError,
DWORD dwFromMdbError,
DWORD dwToBEError,
PVDIR_BACKEND_CTX pBECtx,
PCSTR pszErrorContext)
{
DWORD dwError = 0;
assert(pBECtx);
if (dwMdbError != 0)
{
pBECtx->dwBEErrorCode = dwMdbError;
VMDIR_SAFE_FREE_MEMORY(pBECtx->pszBEErrorMsg);
// ignore error
VmDirAllocateStringPrintf( &pBECtx->pszBEErrorMsg,
"(%s)(%s)",
mdb_strerror(dwMdbError),
VDIR_SAFE_STRING(pszErrorContext));
if (dwMdbError == dwFromMdbError)
{
dwError = dwToBEError;
}
// check if the error is caused by one of raft callbacks
// if yes return the same error
else if (IS_VMDIR_ERROR_SPACE(dwMdbError))
{
dwError = dwMdbError;
}
else
{
dwError = ERROR_BACKEND_ERROR;
}
}
return dwError;
}
DWORD
VmDirTestGetTestContainerDn(
PVMDIR_TEST_STATE pState,
PSTR *ppszDN
)
{
DWORD dwError = 0;
PSTR pszDN = NULL;
dwError = VmDirAllocateStringPrintf(
&pszDN,
"cn=%s,%s",
VmDirTestGetTestContainerCn(pState),
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
*ppszDN = pszDN;
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
_VmDirTestCreateLimitedUserAndConnection(
PVMDIR_TEST_STATE pState
)
{
DWORD dwError = 0;
PSTR pszUserUPN = NULL;
LDAP *pLd;
dwError = VmDirTestCreateUser(
pState,
NULL,
VmDirTestGetInternalUserCn(pState),
NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszUserUPN,
"%s@%s",
VmDirTestGetInternalUserCn(pState),
pState->pszDomain);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirSafeLDAPBind(
&pLd,
pState->pszServerName,
pszUserUPN,
pState->pszPassword);
BAIL_ON_VMDIR_ERROR(dwError);
pState->pLdLimited = pLd;
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszUserUPN);
return dwError;
error:
printf("%s failed with error %d\n", __FUNCTION__, dwError);
goto cleanup;
}
DWORD
TryToListObject(
PVMDIR_TEST_STATE pState,
PCSTR pszContainer
)
{
DWORD dwError = 0;
PSTR pszDn = NULL;
PSTR pszUserName = NULL;
dwError = VmDirTestGetGuid(&pszUserName);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirTestCreateUser(pState, pszContainer, pszUserName, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = VmDirAllocateStringPrintf(
&pszDn,
"cn=%s,cn=%s,%s",
pszUserName,
pszContainer,
pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = _VdcSearchForEntryAndAttribute(
pState->pLd,
pszDn,
NULL,
NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszUserName);
VMDIR_SAFE_FREE_STRINGA(pszDn);
return dwError;
error:
goto cleanup;
}
DWORD
VmDirTestDeleteObjectByDNPrefix(
PVMDIR_TEST_STATE pState,
PCSTR pszDNPrefix
)
{
DWORD dwError = 0;
PSTR pszDN = NULL;
dwError = VmDirAllocateStringPrintf(
&pszDN, "%s,%s", pszDNPrefix, pState->pszBaseDN);
BAIL_ON_VMDIR_ERROR(dwError);
dwError = ldap_delete_ext_s(pState->pLd, pszDN, NULL, NULL);
BAIL_ON_VMDIR_ERROR(dwError);
cleanup:
VMDIR_SAFE_FREE_STRINGA(pszDN);
return dwError;
error:
goto cleanup;
}
