DWORD
CdcSrvInitDefaultHAMode(
PCDC_CONTEXT pCdcContext
)
{
DWORD dwError = 0;
CDC_DB_ENUM_HA_MODE cdcHAMode = CDC_DB_ENUM_HA_MODE_UNDEFINED;
if (!pCdcContext)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = CdcRegDbGetHAMode(&cdcHAMode);
BAIL_ON_VMAFD_ERROR(dwError);
if (cdcHAMode == CDC_DB_ENUM_HA_MODE_DEFAULT)
{
(DWORD)CdcWakeupCdcCacheUpdate(
pCdcContext->pCdcCacheUpdateContext,
TRUE
);
(DWORD)CdcWakeupStateMachine(
pCdcContext->pCdcStateMachineContext
);
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
CdcEnableClientAffinity(
VOID
)
{
DWORD dwError = 0;
BOOL bIsLocked = 0;
BOOL bEnabledHA = FALSE;
dwError = CdcRegDbGetHAMode(&bEnabledHA);
BAIL_ON_VMAFD_ERROR(dwError);
if (!bEnabledHA)
{
VMAFD_LOCK_MUTEX(bIsLocked,&mutexStateChange);
dwError = CdcDbSetHAClientState(CDC_DC_STATE_NO_DC_LIST);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcRegDbSetHAMode(TRUE);
BAIL_ON_VMAFD_ERROR(dwError);
VMAFD_UNLOCK_MUTEX(bIsLocked,&mutexStateChange);
}
dwError = CdcWakeupDCCachingThread(
gVmafdGlobals.pDCCacheThr,
TRUE
);
if (dwError)
{
VmAfdLog (VMAFD_DEBUG_ANY,
"Failed to wake up DC Caching thread: %d",
dwError
);
dwError = 0;
}
cleanup:
VMAFD_UNLOCK_MUTEX(bIsLocked,&mutexStateChange);
return dwError;
error:
goto cleanup;
}
DWORD
CdcSrvEnableDefaultHA(
PCDC_CONTEXT pCdcContext
)
{
DWORD dwError = 0;
CDC_DB_ENUM_HA_MODE cdcHAMode = CDC_DB_ENUM_HA_MODE_UNDEFINED;
BOOL bIsLocked = FALSE;
if (!pCdcContext)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = CdcRegDbGetHAMode(&cdcHAMode);
BAIL_ON_VMAFD_ERROR(dwError);
if (cdcHAMode != CDC_DB_ENUM_HA_MODE_DEFAULT)
{
VMAFD_LOCK_MUTEX(bIsLocked, &pCdcContext->context_mutex);
dwError = CdcRegDbSetHAMode(CDC_DB_ENUM_HA_MODE_DEFAULT);
BAIL_ON_VMAFD_ERROR(dwError);
VMAFD_UNLOCK_MUTEX(bIsLocked, &pCdcContext->context_mutex);
}
dwError = CdcSrvInitDefaultHAMode(pCdcContext);
BAIL_ON_VMAFD_ERROR(dwError);
cleanup:
if (pCdcContext)
{
VMAFD_UNLOCK_MUTEX(bIsLocked, &pCdcContext->context_mutex);
}
return dwError;
error:
goto cleanup;
}
static
PVOID
CdcHandleDCCaching(
PVOID pData
)
{
DWORD dwError = 0;
DWORD dwRefreshInterval = 0;
DWORD dwHeartBeat = 0;
BOOL bHAState = FALSE;
PVMAFD_CERT_THR_DATA pThrArgs = (PVMAFD_CERT_THR_DATA)pData;
pThrArgs->forceFlush = TRUE;
while (TRUE)
{
BOOLEAN bShutdown = FALSE;
dwError = CdcRegDbGetRefreshInterval(&dwRefreshInterval);
if (dwError)
{
dwRefreshInterval = DCCA_DEFAULT_SYNC_INTERVAL;
}
dwError = CdcRegDbGetHeartBeatInterval(&dwHeartBeat);
if (dwError)
{
dwHeartBeat = DCCA_DEFAULT_HEARTBEAT;
}
bShutdown = CdcToShutdownDCCacheThread(pThrArgs);
if (bShutdown)
{
break;
}
dwError = CdcRegDbGetHAMode(&bHAState);
if (dwError)
{
bHAState = FALSE;
dwError = 0;
}
if (bHAState)
{
dwError = CdcRunStateMachine(pThrArgs->forceFlush);
if (dwError)
{
VmAfdLog(
VMAFD_DEBUG_ANY,
"Failed to populate the DC Cache. Error [%u]",
dwError);
}
}
dwError = CdcDCCacheThreadSleep(
pThrArgs,
dwRefreshInterval,
dwHeartBeat
);
if (dwError == ETIMEDOUT)
{
dwError = 0;
}
BAIL_ON_VMAFD_ERROR(dwError);
}
cleanup:
return NULL;
error:
goto cleanup;
}
DWORD
CdcSrvGetCurrentState(
PCDC_DC_STATE pCdcState
)
{
DWORD dwError = 0;
DWORD dwCdcState = 0;
BOOL bIsHAEnabled = FALSE;
CDC_DC_STATE cdcState = CDC_DC_STATE_UNDEFINED;
if (!pCdcState)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = CdcRegDbGetHAMode(&bIsHAEnabled);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcDbGetHAClientState(&dwCdcState);
if (!bIsHAEnabled && dwError == ERROR_OBJECT_NOT_FOUND)
{
cdcState = CDC_DC_STATE_DISABLED;
dwError = 0;
}
else
{
BAIL_ON_VMAFD_ERROR(dwError);
switch (dwCdcState)
{
case CDC_DC_STATE_NO_DC_LIST:
cdcState = CDC_DC_STATE_NO_DC_LIST;
break;
case CDC_DC_STATE_SITE_AFFINITIZED:
cdcState = CDC_DC_STATE_SITE_AFFINITIZED;
break;
case CDC_DC_STATE_OFF_SITE:
cdcState = CDC_DC_STATE_OFF_SITE;
break;
case CDC_DC_STATE_NO_DCS_ALIVE:
cdcState = CDC_DC_STATE_NO_DCS_ALIVE;
break;
case CDC_DC_STATE_DISABLED:
cdcState = CDC_DC_STATE_DISABLED;
break;
default:
dwError = ERROR_INVALID_STATE;
break;
}
}
BAIL_ON_VMAFD_ERROR(dwError);
*pCdcState = cdcState;
cleanup:
return dwError;
error:
if (pCdcState)
{
*pCdcState = CDC_DC_STATE_UNDEFINED;
}
goto cleanup;
}
DWORD
CdcSrvGetDCName(
PCWSTR pszDomainName,
PCDC_DC_INFO_W *ppAffinitizedDC
)
{
DWORD dwError = 0;
PCDC_DC_INFO_W pAffinitizedDC = NULL;
DWORD dwAffinitizedSince = 0;
BOOL bHAState = FALSE;
PWSTR pszDomainToUse = NULL;
if (!ppAffinitizedDC)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = VmAfSrvGetDomainName(&pszDomainToUse);
BAIL_ON_VMAFD_ERROR(dwError);
if (!IsNullOrEmptyString(pszDomainName))
{
if (!VmAfdStringIsEqualW(
pszDomainName,
pszDomainToUse,
FALSE
)
)
{
dwError = ERROR_INVALID_DOMAINNAME;
BAIL_ON_VMAFD_ERROR(dwError);
}
}
dwError = CdcRegDbGetHAMode(&bHAState);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcDbGetAffinitizedDC(
pszDomainToUse,
&dwAffinitizedSince,
&pAffinitizedDC
);
if (!bHAState || dwError)
{
dwError = VmAfdAllocateMemory(
sizeof(CDC_DC_INFO_W),
(PVOID *)&pAffinitizedDC
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDCName(&pAffinitizedDC->pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDomainName(&pAffinitizedDC->pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcGetClientSiteName(&pAffinitizedDC->pszDcSiteName);
BAIL_ON_VMAFD_ERROR(dwError);
}
*ppAffinitizedDC = pAffinitizedDC;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pszDomainToUse);
return dwError;
error:
if (ppAffinitizedDC)
{
*ppAffinitizedDC = NULL;
}
if (pAffinitizedDC)
{
VmAfdFreeDomainControllerInfoW(pAffinitizedDC);
}
goto cleanup;
}
DWORD
CdcSrvGetDCName(
PCWSTR pszDomainName,
PCDC_DC_INFO_W *ppAffinitizedDC
)
{
DWORD dwError = 0;
PCDC_DC_INFO_W pAffinitizedDC = NULL;
PCDC_DC_INFO_W pAffinitizedDCToFree = NULL;
DWORD dwAffinitizedSince = 0;
CDC_DB_ENUM_HA_MODE cdcHAMode = CDC_DB_ENUM_HA_MODE_UNDEFINED;
PWSTR pszDomainToUse = NULL;
UINT64 iStart = 0;
UINT64 iEnd = 0;
if (!ppAffinitizedDC)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
iStart = VmAfdGetTimeInMilliSec();
dwError = VmAfSrvGetDomainName(&pszDomainToUse);
BAIL_ON_VMAFD_ERROR(dwError);
if (!IsNullOrEmptyString(pszDomainName))
{
if (!VmAfdStringIsEqualW(
pszDomainName,
pszDomainToUse,
FALSE
)
)
{
dwError = ERROR_INVALID_DOMAINNAME;
BAIL_ON_VMAFD_ERROR(dwError);
}
}
dwError = CdcRegDbGetHAMode(&cdcHAMode);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcDbGetAffinitizedDC(
pszDomainToUse,
&dwAffinitizedSince,
&pAffinitizedDC
);
if (cdcHAMode == CDC_DB_ENUM_HA_MODE_LEGACY || dwError)
{
pAffinitizedDCToFree = pAffinitizedDC;
dwError = VmAfdAllocateMemory(
sizeof(CDC_DC_INFO_W),
(PVOID *)&pAffinitizedDC
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDCName(&pAffinitizedDC->pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdTrimFQDNTrailingDot(pAffinitizedDC->pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDomainName(&pAffinitizedDC->pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcRegDbGetSiteName(&pAffinitizedDC->pszDcSiteName);
BAIL_ON_VMAFD_ERROR(dwError);
}
iEnd = VmAfdGetTimeInMilliSec();
*ppAffinitizedDC = pAffinitizedDC;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pszDomainToUse);
if (pAffinitizedDCToFree)
{
VmAfdFreeDomainControllerInfoW(pAffinitizedDCToFree);
}
return dwError;
error:
(DWORD)VmAfdAddDCSuperLogEntry(
gVmafdGlobals.pLogger,
iStart,
iEnd,
pAffinitizedDC,
dwError);
if (ppAffinitizedDC)
{
*ppAffinitizedDC = NULL;
}
if (pAffinitizedDC)
{
VmAfdFreeDomainControllerInfoW(pAffinitizedDC);
}
goto cleanup;
}
