static
DWORD
CdcUpdateAffinitizedDC(
PWSTR pszNewDCName
)
{
DWORD dwError = 0;
PWSTR pszDomainName = NULL;
dwError = VmAfSrvGetDomainName(&pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcDbAddAffinitizedDC(
pszNewDCName,
pszDomainName
);
BAIL_ON_VMAFD_ERROR(dwError);
cleanup:
VMAFD_SAFE_FREE_MEMORY(pszDomainName);
return dwError;
error:
goto cleanup;
}
static
DWORD
CdcGetNewDC(
PWSTR* ppszNewDCName,
PCDC_DC_STATE pCdcNextState
)
{
DWORD dwError = 0;
PWSTR pszNewDCName = NULL;
PWSTR pszSiteName = NULL;
PWSTR pszDomainName = NULL;
CDC_DC_STATE cdcNextState = CDC_DC_STATE_UNDEFINED;
dwError = VmAfSrvGetDomainName(&pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcGetClientSiteName(&pszSiteName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcDbGetClosestDCOnSite(
pszSiteName,
pszDomainName,
&pszNewDCName
);
if (dwError)
{
VMAFD_SAFE_FREE_MEMORY(pszNewDCName);
dwError = CdcDbGetClosestDC(
pszDomainName,
&pszNewDCName
);
if (dwError)
{
cdcNextState = CDC_DC_STATE_NO_DCS_ALIVE;
dwError = 0;
}
else
{
cdcNextState = CDC_DC_STATE_OFF_SITE;
}
}
else
{
cdcNextState = CDC_DC_STATE_SITE_AFFINITIZED;
}
*ppszNewDCName = pszNewDCName;
*pCdcNextState = cdcNextState;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pszDomainName);
VMAFD_SAFE_FREE_MEMORY(pszSiteName);
return dwError;
error:
if (ppszNewDCName)
{
*ppszNewDCName = NULL;
}
if (pCdcNextState)
{
*pCdcNextState = CDC_DC_STATE_UNDEFINED;
}
VMAFD_SAFE_FREE_MEMORY(pszNewDCName);
goto cleanup;
}
static
DWORD
CdcRefreshCache(
BOOL bPurgeRefresh,
PCDC_DB_ENTRY_W pCdcEntry,
DWORD dwCount
)
{
//TODO: Or simply always purge and repopulate?
DWORD dwError = 0;
PWSTR *ppszDomainControllers = NULL;
DWORD dwDBDCCount = 0;
DWORD dwDbIndex = 0;
DWORD dwIndex = 0;
PWSTR pwszDomainName = NULL;
if (!pCdcEntry)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = VmAfSrvGetDomainName(&pwszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
if (bPurgeRefresh)
{
dwError = CdcDbEnumDCEntries(&ppszDomainControllers, &dwDBDCCount);
BAIL_ON_VMAFD_ERROR(dwError);
for (; dwDbIndex<dwDBDCCount; ++dwDbIndex)
{
BOOL bFoundDC = FALSE;
for (dwIndex = 0;dwIndex < dwCount; ++dwIndex)
{
if (VmAfdStringIsEqualW(
ppszDomainControllers[dwDbIndex],
pCdcEntry[dwIndex].pszDCName,
FALSE
)
)
{
pCdcEntry[dwIndex].cdcEntryStatus =
CDC_DB_ENTRY_STATUS_UPDATE;
bFoundDC = TRUE;
break;
}
}
if (!bFoundDC)
{
CdcDbDeleteDCEntry(ppszDomainControllers[dwDbIndex]);
}
}
}
for (dwIndex = 0; dwIndex < dwCount; ++dwIndex)
{
dwError = VmAfdAllocateStringW(
pwszDomainName,
&pCdcEntry[dwIndex].pszDomainName
);
BAIL_ON_VMAFD_ERROR(dwError);
switch (pCdcEntry[dwIndex].cdcEntryStatus)
{
case CDC_DB_ENTRY_STATUS_NEW:
dwError = CdcDbAddDCEntry(&pCdcEntry[dwIndex]);
break;
case CDC_DB_ENTRY_STATUS_UPDATE:
dwError = CdcDbUpdateDCEntry(&pCdcEntry[dwIndex]);
break;
default:
dwError = ERROR_INVALID_PARAMETER;
break;
}
BAIL_ON_VMAFD_ERROR(dwError);
}
cleanup:
if (ppszDomainControllers)
{
VmAfdFreeStringArrayW(ppszDomainControllers, dwDBDCCount);
}
VMAFD_SAFE_FREE_MEMORY(pwszDomainName);
return dwError;
error:
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;
}
static
DWORD
CdcDCPing(
PWSTR pszDCName,
PWSTR pszDomainName,
PDWORD pdwResult,
time_t *ptimeTaken,
PWSTR *ppszSiteName
)
{
DWORD dwError = 0;
DWORD dwAfdPingResult = 0;
DWORD dwDirPingResult = 0;
time_t timeBefore = 0;
time_t timeAfter = 0;
time_t timeDiff = 0;
PWSTR pwszAccount = NULL;
PWSTR pwszPassword = NULL;
PWSTR pwszAccountDN = NULL;
PWSTR pwszDomain = NULL;
PSTR pszSiteName = NULL;
PWSTR pwszSiteName = NULL;
PVMDIR_CONNECTION pConnection = NULL;
BOOL bDCIsAlive = FALSE;
if (!pszDCName || !pdwResult || !ptimeTaken || !ppszSiteName)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = VmAfSrvGetMachineAccountInfo(
&pwszAccount,
&pwszPassword,
&pwszAccountDN,
NULL
);
BAIL_ON_VMAFD_ERROR(dwError);
if (IsNullOrEmptyString(pszDomainName))
{
dwError = VmAfSrvGetDomainName(&pwszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
}
else
{
dwError = VmAfdAllocateStringW(
pszDomainName,
&pwszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
}
time(&timeBefore);
dwAfdPingResult = CdcVmafdHeartbeatPing(
pszDCName,
pwszAccount,
pwszPassword,
pwszDomain,
&bDCIsAlive
);
time(&timeAfter);
timeDiff = timeAfter-timeBefore;
dwDirPingResult = VmAfSrvDirOpenConnection(
pszDCName,
pwszDomain,
pwszAccount,
pwszPassword,
&pConnection
);
if (!dwDirPingResult)
{
dwDirPingResult = VmDirGetSiteName(pConnection,&pszSiteName);
}
if (dwDirPingResult)
{
*ppszSiteName = NULL;
}
else
{
dwError = VmAfdAllocateStringWFromA(
pszSiteName,
&pwszSiteName
);
BAIL_ON_VMAFD_ERROR(dwError);
*ppszSiteName = pwszSiteName;
pwszSiteName = NULL;
}
*ptimeTaken = timeDiff;
*pdwResult = !(!dwDirPingResult && !dwAfdPingResult && bDCIsAlive);
cleanup:
if (pConnection)
{
VmDirConnectionClose(pConnection);
}
VMAFD_SAFE_FREE_MEMORY(pwszDomain);
VMAFD_SAFE_FREE_MEMORY(pwszAccount);
VMAFD_SAFE_FREE_MEMORY(pwszPassword);
VMAFD_SAFE_FREE_MEMORY(pwszAccountDN);
VMAFD_SAFE_FREE_MEMORY(pwszSiteName);
VMAFD_SAFE_FREE_MEMORY(pszSiteName);
return dwError;
error:
if (ptimeTaken)
{
*ptimeTaken = 0;
}
if (ppszSiteName)
{
*ppszSiteName = NULL;
}
if (pdwResult)
{
*pdwResult = 0;
}
goto cleanup;
}
static
DWORD
CdcGetDomainControllers(
PWSTR** ppszDomainControllers,
PDWORD pdwCount
)
{
DWORD dwError = 0;
DWORD dwIndex = 0;
PWSTR pwszDomain = NULL;
PSTR pszDomain = NULL;
PSTR pszDCName = NULL;
PWSTR pwszAccount = NULL;
PSTR pszAccount = NULL;
PWSTR pwszPassword = NULL;
PSTR pszPassword = NULL;
PWSTR pwszAccountDN = NULL;
PSTR pszAccountDN = NULL;
PVMDNS_SERVER_CONTEXT pConnection = NULL;
PVMDNS_RECORD_ARRAY pRecordArray = NULL;
PWSTR* pszDomainControllers = NULL;
PCDC_DC_INFO_W pAffinitizedDC = NULL;
if (!ppszDomainControllers || !pdwCount)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = VmAfSrvGetMachineAccountInfo(
&pwszAccount,
&pwszPassword,
&pwszAccountDN,
NULL
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszAccount,
&pszAccount
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszPassword,
&pszPassword
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDomainName(&pwszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszDomain,
&pszDomain
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = CdcSrvGetDCName(pwszDomain,&pAffinitizedDC);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pAffinitizedDC->pszDCName,
&pszDCName
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmDnsOpenServerA(
pszDCName,
pszAccount,
pszDomain,
pszPassword,
0,
NULL,
&pConnection);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmDnsQueryRecordsA(
pConnection,
pszDomain,
"_ldap._tcp",
VMDNS_RR_TYPE_SRV,
0,
&pRecordArray);
BAIL_ON_VMAFD_ERROR(dwError);
if (pRecordArray->dwCount)
{
dwError = VmAfdAllocateMemory(
sizeof(PWSTR)*pRecordArray->dwCount,
(PVOID *)&pszDomainControllers
);
BAIL_ON_VMAFD_ERROR(dwError);
}
for (; dwIndex < pRecordArray->dwCount; dwIndex++)
{
dwError = VmAfdAllocateStringWFromA(
pRecordArray->Records[dwIndex].Data.SRV.pNameTarget,
&pszDomainControllers[dwIndex]
);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdTrimFQDNTrailingDot(pszDomainControllers[dwIndex]);
BAIL_ON_VMAFD_ERROR(dwError);
}
dwIndex = 0;
*ppszDomainControllers = pszDomainControllers;
*pdwCount = pRecordArray->dwCount;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pwszDomain);
VMAFD_SAFE_FREE_MEMORY(pszDomain);
VMAFD_SAFE_FREE_MEMORY(pszDCName);
VMAFD_SAFE_FREE_MEMORY(pwszAccount);
VMAFD_SAFE_FREE_MEMORY(pszAccount);
VMAFD_SAFE_FREE_MEMORY(pwszPassword);
VMAFD_SAFE_FREE_MEMORY(pszPassword);
VMAFD_SAFE_FREE_MEMORY(pwszAccountDN);
VMAFD_SAFE_FREE_MEMORY(pszAccountDN);
if (pAffinitizedDC)
{
VmAfdFreeDomainControllerInfoW(pAffinitizedDC);
}
if (pRecordArray)
{
VmDnsFreeRecordArray(pRecordArray);
}
if (pConnection)
{
VmDnsCloseServer(pConnection);
}
return dwError;
error:
if (ppszDomainControllers)
{
*ppszDomainControllers = NULL;
}
if (pszDomainControllers)
{
VmAfdFreeStringArrayW(pszDomainControllers,pRecordArray->dwCount);
}
goto cleanup;
}
DWORD
VmAfdGetMachineInfo(
PVMAFD_REG_ARG *ppArgs
)
{
DWORD dwError = 0;
PWSTR pwszAccountName = NULL;
PWSTR pwszPassword = NULL;
PWSTR pwszAccountDN = NULL;
PWSTR pwszDomain = NULL;
PWSTR pwszAccount = NULL;
PVMAFD_REG_ARG pArgs = NULL;
VMAFD_DOMAIN_STATE domainState = VMAFD_DOMAIN_STATE_NONE ;
dwError = VmAfSrvGetDomainState(&domainState);
BAIL_ON_VMAFD_ERROR(dwError);
if (domainState == VMAFD_DOMAIN_STATE_NONE)
{
dwError = ERROR_NOT_JOINED;
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
}
dwError = VmAfSrvGetMachineAccountInfo(
&pwszAccount,
&pwszPassword,
&pwszAccountDN,
NULL);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateMemory(
sizeof(VMAFD_REG_ARG),
(PVOID*)&pArgs);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszAccountDN,
&pArgs->pszAccountDN);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszPassword,
&pArgs->pszPassword);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszAccount,
&pArgs->pszAccount);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfSrvGetDomainName(&pwszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(
pwszDomain,
&pArgs->pszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringPrintf( &(pArgs->pszAccountUPN), "%s@%s",
pArgs->pszAccount, pArgs->pszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
if (IsNullOrEmptyString(pArgs->pszAccountDN) ||
IsNullOrEmptyString(pArgs->pszPassword))
{
dwError = VECS_MISSING_CREDS;
BAIL_ON_VMAFD_ERROR(dwError);
}
*ppArgs = pArgs;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pwszAccountName);
VMAFD_SAFE_FREE_MEMORY(pwszPassword);
VMAFD_SAFE_FREE_MEMORY(pwszAccountDN);
VMAFD_SAFE_FREE_MEMORY(pwszDomain);
VMAFD_SAFE_FREE_MEMORY(pwszAccount);
return dwError;
error :
*ppArgs = NULL;
if (pArgs)
{
VmAfdFreeRegArgs(pArgs);
}
switch (dwError)
{
case VECS_MISSING_CREDS:
VmAfdLog(VMAFD_DEBUG_ANY, "Account DN / Password missing");
break;
case VECS_MISSING_DC_NAME:
VmAfdLog(VMAFD_DEBUG_ANY, "Invalid domain controller name");
break;
default:
VmAfdLog(
VMAFD_DEBUG_ANY,
"Error [%d] getting machine Info",
dwError);
break;
}
goto cleanup;
}
DWORD
CdcSrvGetDCStatusInfo(
PWSTR pwszDCName,
PWSTR pwszDomainName,
PCDC_DC_STATUS_INFO_W *ppCdcStatusInfo,
PVMAFD_HB_STATUS_W *ppHeartbeatStatus
)
{
DWORD dwError = 0;
PWSTR pwszDomainToUse = NULL;
PCDC_DC_STATUS_INFO_W pCdcStatusInfo = NULL;
PVMAFD_HB_STATUS_W pHeartbeatStatus = NULL;
if (IsNullOrEmptyString(pwszDCName))
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
if (!ppCdcStatusInfo)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
if (IsNullOrEmptyString(pwszDomainName))
{
dwError = VmAfSrvGetDomainName(&pwszDomainToUse);
BAIL_ON_VMAFD_ERROR(dwError);
}
else
{
dwError = VmAfdAllocateStringW(pwszDomainName, &pwszDomainToUse);
BAIL_ON_VMAFD_ERROR(dwError);
}
dwError = CdcDbGetDCInfo(
pwszDCName,
pwszDomainToUse,
&pCdcStatusInfo
);
BAIL_ON_VMAFD_ERROR(dwError);
if (ppHeartbeatStatus)
{
dwError = CdcDbGetHeartbeatStatus(
pwszDCName,
pwszDomainToUse,
&pHeartbeatStatus
);
BAIL_ON_VMAFD_ERROR(dwError);
pHeartbeatStatus->bIsAlive = pCdcStatusInfo->bIsAlive;
*ppHeartbeatStatus = pHeartbeatStatus;
}
*ppCdcStatusInfo = pCdcStatusInfo;
cleanup:
VMAFD_SAFE_FREE_MEMORY(pwszDomainToUse);
return dwError;
error:
if (ppCdcStatusInfo)
{
*ppCdcStatusInfo = NULL;
}
if (ppHeartbeatStatus)
{
*ppHeartbeatStatus = NULL;
}
if (pCdcStatusInfo)
{
VmAfdFreeCdcStatusInfoW(pCdcStatusInfo);
}
if (pHeartbeatStatus)
{
VmAfdFreeHbStatusW(pHeartbeatStatus);
}
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;
}
