DWORD
VmAfdConnectLdapWithMachineAccount(
LDAP** ppLotus
)
{
DWORD dwError = 0;
LDAP* pLotus = NULL;
PSTR pszUpn = NULL;
PVMAFD_REG_ARG pArgs = NULL;
PWSTR pwszDCName = NULL;
PSTR pszDCName = NULL;
dwError = VmAfdGetMachineInfo(&pArgs);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
dwError = VmAfSrvGetAffinitizedDC(&pwszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringAFromW(pwszDCName, &pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdAllocateStringPrintf(
&pszUpn,
"%s@%s",
pArgs->pszAccount,
pArgs->pszDomain);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdLDAPConnect(
pszDCName,
LDAP_PORT,
pszUpn,
pArgs->pszPassword,
&pLotus);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
*ppLotus = pLotus;
cleanup:
VMAFD_SAFE_FREE_STRINGA(pszUpn);
VMAFD_SAFE_FREE_STRINGA(pszDCName);
VMAFD_SAFE_FREE_STRINGW(pwszDCName);
VmAfdFreeRegArgs(pArgs);
return dwError;
error:
if (pLotus)
{
VmAfdLdapClose(pLotus);
}
goto cleanup;
}
DWORD
VmAfdCheckDomainFunctionalLevel(
int nMinMajor,
int nMinMinor
)
{
DWORD dwError = 0;
LDAP* pLotus = NULL;
PSTR pszDomainFunctionalLevel = NULL;
int nMajor = 0, nMinor = 0;
int cFields = 0;
dwError = VmAfdConnectLdapWithMachineAccount(&pLotus);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
dwError = VmAfdGetDomainFunctionLevel(pLotus, &pszDomainFunctionalLevel);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
if (IsNullOrEmptyString(pszDomainFunctionalLevel))
{
dwError = ERROR_INVALID_DATA;
BAIL_ON_VMAFD_ERROR(dwError);
}
cFields = sscanf(pszDomainFunctionalLevel, "%u.%u", &nMajor, &nMinor);
if (cFields <= 0)
{
dwError = ERROR_INVALID_DATA;
BAIL_ON_VMAFD_ERROR(dwError);
}
if ((nMajor < nMinMajor) ||
(nMajor == nMinMajor && nMinor < nMinMinor))
{
dwError = ERROR_NOT_SUPPORTED;
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
}
cleanup:
if (pLotus)
{
VmAfdLdapClose(pLotus);
}
VMAFD_SAFE_FREE_MEMORY(pszDomainFunctionalLevel);
return dwError;
error:
goto cleanup;
}
DWORD
VmAfWinCfgReadDWORDValue(
PVMAF_CFG_KEY pKey,
PCSTR pszSubkey,
PCSTR pszName,
PDWORD pdwValue
)
{
DWORD dwError = 0;
DWORD dwValue = 0;
DWORD dwValueSize = sizeof(dwValue);
dwError = RegGetValueA(
pKey->hKey,
pszSubkey,
pszName,
RRF_RT_REG_DWORD,
NULL,
(PVOID)&dwValue,
&dwValueSize);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
*pdwValue = dwValue;
cleanup:
return dwError;
error:
*pdwValue = 0;
goto cleanup;
}
DWORD
VmAfWinCfgReadStringValue(
PVMAF_CFG_KEY pKey,
PCSTR pszSubkey,
PCSTR pszName,
PSTR* ppszValue
)
{
DWORD dwError = 0;
CHAR szValue[VMAF_MAX_CONFIG_VALUE_BYTE_LENGTH] = {0};
DWORD dwszValueSize = sizeof(szValue);
PSTR pszValue = NULL;
dwError = RegGetValueA(
pKey->hKey,
pszSubkey,
pszName,
RRF_RT_REG_SZ,
NULL,
szValue,
&dwszValueSize);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
dwError = VmAfdAllocateStringA(szValue, &pszValue);
BAIL_ON_VMAFD_ERROR(dwError);
*ppszValue = pszValue;
cleanup:
return dwError;
error:
*ppszValue = NULL;
if (pszValue)
{
VmAfdFreeStringA(pszValue);
}
goto cleanup;
}
/**
* To add log entry for PCDC_DC_INFO_W
**/
DWORD
VmAfdAddCDCSuperLogEntry(
PVMSUPERLOGGING pLogger,
UINT64 iStartTime,
UINT64 iEndTime,
PCDC_DC_INFO_W pDCEntry,
CDC_DC_STATE dwState,
DWORD dwErrorCode
)
{
PVMAFD_SUPERLOG_ENTRY pLogEntry = NULL;
DWORD dwError = 0;
PSTR pszDCName = NULL;
PSTR pszDomainName = NULL;
PSTR pszSiteName = NULL;
PSTR pszDCAddress = NULL;
// AFD should not fail if super logging is disabled. This is why returning 0 here
if (!VmAfdIsSuperLoggingEnabled(pLogger))
{
dwError = ERROR_NOT_READY;
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
}
if(!pDCEntry)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
pLogEntry = (PVMAFD_SUPERLOG_ENTRY)VmAfdCircularBufferGetNextEntry(pLogger->pCircularBuffer);
if(!pLogEntry)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMAFD_ERROR(dwError);
}
memset(pLogEntry, 0, sizeof(*pLogEntry));
pLogEntry->iStartTime = iStartTime;
pLogEntry->iEndTime = iEndTime;
pLogEntry->dwErrorCode = dwErrorCode;
pLogEntry->dwState = dwState;
if(pDCEntry && pDCEntry->pszDCName)
{
dwError = VmAfdAllocateStringAFromW(pDCEntry->pszDCName, &pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdStringCpyA((PSTR)pLogEntry->pszDCName, VMAFD_MAX_DN_LEN, pszDCName);
BAIL_ON_VMAFD_ERROR(dwError);
}
if(pDCEntry && pDCEntry->pszDomainName)
{
dwError = VmAfdAllocateStringAFromW(pDCEntry->pszDomainName, &pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdStringCpyA((PSTR)pLogEntry->pszDomainName, VMAFD_MAX_DN_LEN, pszDomainName);
BAIL_ON_VMAFD_ERROR(dwError);
}
if(pDCEntry && pDCEntry->pszDcSiteName)
{
dwError = VmAfdAllocateStringAFromW(pDCEntry->pszDcSiteName, &pszSiteName);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdStringCpyA((PSTR)pLogEntry->pszSiteName, VMAFD_MAX_DN_LEN, pszSiteName);
BAIL_ON_VMAFD_ERROR(dwError);
}
if(pDCEntry && pDCEntry->pszDCAddress)
{
dwError = VmAfdAllocateStringAFromW(pDCEntry->pszDCAddress, &pszDCAddress);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfdStringCpyA((PSTR)pLogEntry->pszDCAddress, VMAFD_MAX_DN_LEN, pszDCAddress);
BAIL_ON_VMAFD_ERROR(dwError);
}
cleanup:
VMAFD_SAFE_FREE_STRINGA(pszDCName);
VMAFD_SAFE_FREE_STRINGA(pszDomainName);
VMAFD_SAFE_FREE_STRINGA(pszSiteName);
VMAFD_SAFE_FREE_STRINGA(pszDCAddress);
return dwError;
error:
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
_VmAfdConfigGetInteger(
PCSTR pszValueName, /* IN */
PDWORD pdwValue /* OUT */
)
{
DWORD dwError = 0;
PVMAF_CFG_CONNECTION pConnection = NULL;
PVMAF_CFG_KEY pRootKey = NULL;
PVMAF_CFG_KEY pParamsKey = NULL;
PCSTR pszSubKey = VMAFD_CONFIG_PARAMETER_KEY_PATH;
DWORD dwValue = 0;
BAIL_ON_VMAFD_INVALID_POINTER(pdwValue, dwError);
dwError = VmAfConfigOpenConnection(&pConnection);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigOpenRootKey(
pConnection,
"HKEY_LOCAL_MACHINE",
0,
KEY_READ,
&pRootKey);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigOpenKey(
pConnection,
pRootKey,
pszSubKey,
0,
KEY_READ,
&pParamsKey);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigReadDWORDValue(
pParamsKey,
NULL,
pszValueName,
&dwValue);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
*pdwValue = dwValue;
cleanup:
if (pParamsKey)
{
VmAfConfigCloseKey(pParamsKey);
}
if (pRootKey)
{
VmAfConfigCloseKey(pRootKey);
}
if (pConnection)
{
VmAfConfigCloseConnection(pConnection);
}
return dwError;
error:
goto cleanup;
}
DWORD
_VmAfdConfigGetString(
PCSTR pszSubKey, /* IN */
PCSTR pszValueName, /* IN */
PWSTR* ppwszValue /* OUT */
)
{
DWORD dwError = 0;
PVMAF_CFG_CONNECTION pConnection = NULL;
PVMAF_CFG_KEY pRootKey = NULL;
PVMAF_CFG_KEY pParamsKey = NULL;
PSTR pszValue = NULL;
PWSTR pwszValue = NULL;
BAIL_ON_VMAFD_INVALID_POINTER(ppwszValue, dwError);
dwError = VmAfConfigOpenConnection(&pConnection);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigOpenRootKey(
pConnection,
"HKEY_LOCAL_MACHINE",
0,
KEY_READ,
&pRootKey);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigOpenKey(
pConnection,
pRootKey,
pszSubKey,
0,
KEY_READ,
&pParamsKey);
BAIL_ON_VMAFD_ERROR(dwError);
dwError = VmAfConfigReadStringValue(
pParamsKey,
NULL,
pszValueName,
&pszValue);
BAIL_ON_VMAFD_ERROR_NO_LOG(dwError);
dwError = VmAfdAllocateStringWFromA(pszValue, &pwszValue);
BAIL_ON_VMAFD_ERROR(dwError);
*ppwszValue = pwszValue;
cleanup:
if (pParamsKey)
{
VmAfConfigCloseKey(pParamsKey);
}
if (pRootKey)
{
VmAfConfigCloseKey(pRootKey);
}
if (pConnection)
{
VmAfConfigCloseConnection(pConnection);
}
VMAFD_SAFE_FREE_STRINGA(pszValue);
return dwError;
error:
if (ppwszValue)
{
*ppwszValue = NULL;
}
goto cleanup;
}
