DWORD
VmDnsCopyPtrRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD pDest
)
{
DWORD dwError = 0;
PVMDNS_PTR_DATAA pData = NULL;
pData = &pDest->Data.PTR;
VmDnsAllocateStringA(pSrc->pszName, &pDest->pszName);
BAIL_ON_VMDNS_ERROR(dwError);
pDest->iClass = pSrc->iClass;
pDest->dwTtl = pSrc->dwTtl;
pDest->dwType = pSrc->dwType;
VmDnsAllocateStringA(pSrc->Data.PTR.pNameHost, &pData->pNameHost);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
if (pDest)
{
VmDnsClearRecord(pDest);
}
goto cleanup;
}
DWORD VmDnsCopySrvRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD pDest
)
{
DWORD dwError = 0;
PVMDNS_SRV_DATAA pData = NULL;
pData = &pDest->Data.SRV;
VmDnsAllocateStringA(pSrc->pszName, &pDest->pszName);
BAIL_ON_VMDNS_ERROR(dwError);
pDest->iClass = pSrc->iClass;
pDest->dwTtl = pSrc->dwTtl;
pDest->dwType = pSrc->dwType;
pData->wPort = pSrc->Data.SRV.wPort;
pData->wPriority = pSrc->Data.SRV.wPriority;
pData->wWeight = pSrc->Data.SRV.wWeight;
VmDnsAllocateStringA(pSrc->Data.SRV.pNameTarget, &pData->pNameTarget);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
VmDnsClearRecord(pDest);
goto cleanup;
}
DWORD
VmDnsCreateSoaRecord(
PVMDNS_ZONE_INFO pZoneInfo,
PVMDNS_RECORD* ppRecord
)
{
DWORD dwError = 0;
PVMDNS_RECORD pRecord = NULL;
PSTR pszName = NULL;
PSTR pszPrimaryDnsName = NULL;
PSTR pszRName = NULL;
BAIL_ON_VMDNS_INVALID_POINTER(pZoneInfo, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppRecord, dwError);
dwError = VmDnsAllocateMemory(sizeof(VMDNS_RECORD), (void**)&pRecord);
BAIL_ON_VMDNS_ERROR(dwError);
pRecord->dwType = VMDNS_RR_TYPE_SOA;
dwError = VmDnsAllocateStringA(VMDNS_SOA_RECORD_NAME, &pszName);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAllocateStringA(pZoneInfo->pszPrimaryDnsSrvName,
&pszPrimaryDnsName);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAllocateStringA(pZoneInfo->pszRName, &pszRName);
BAIL_ON_VMDNS_ERROR(dwError);
pRecord->pszName = pszName;
pRecord->iClass = VMDNS_CLASS_IN;
pRecord->Data.SOA.pNameAdministrator = pszRName;
pRecord->Data.SOA.pNamePrimaryServer = pszPrimaryDnsName;
pRecord->Data.SOA.dwDefaultTtl = pZoneInfo->minimum;
pRecord->Data.SOA.dwExpire = pZoneInfo->expire;
pRecord->Data.SOA.dwRefresh = pZoneInfo->refreshInterval;
pRecord->Data.SOA.dwRetry = pZoneInfo->retryInterval;
pRecord->Data.SOA.dwSerialNo = pZoneInfo->serial;
pszName = NULL;
pszRName = NULL;
*ppRecord = pRecord;
cleanup:
return dwError;
error:
VmDnsFreeMemory(pszName);
VmDnsFreeMemory(pszRName);
VMDNS_FREE_RECORD(pRecord);
goto cleanup;
}
DWORD
VmDnsPtrRecordGetCN(
PVMDNS_RECORD pRecord,
PSTR* ppStr
)
{
return VmDnsAllocateStringA(pRecord->pszName, ppStr);
}
DWORD
VmDnsGetForwarderAtIndex(
PVMDNS_FORWARDER_CONTEXT pForwarder,
DWORD dwIndex,
PSTR* ppszForwarder
)
{
DWORD dwError = 0;
PSTR pszForwarder = NULL;
BOOL bLocked = FALSE;
BAIL_ON_VMDNS_INVALID_POINTER(pForwarder, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppszForwarder, dwError);
VMDNS_LOCKREAD(pForwarder->pLock);
bLocked = TRUE;
if (dwIndex >= pForwarder->dwCount)
{
dwError = ERROR_INVALID_INDEX;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateStringA(
pForwarder->pForwarderEntries[dwIndex]->pszForwarder,
&pszForwarder
);
BAIL_ON_VMDNS_ERROR(dwError);
*ppszForwarder = pszForwarder;
cleanup:
if (bLocked)
{
VMDNS_UNLOCKREAD(pForwarder->pLock);
}
return dwError;
error:
if (ppszForwarder)
{
*ppszForwarder = NULL;
}
VMDNS_SAFE_FREE_STRINGA(pszForwarder);
goto cleanup;
}
DWORD
VmDnsForwarderAppend(
PVMDNS_FORWARDER_CONTEXT pForwarder,
PCSTR pszForwarder
)
{
DWORD dwError = ERROR_SUCCESS;
PSTR szForwarderCopy = NULL;
DWORD dwCount = pForwarder->dwCount;
if (dwCount >= VMDNS_MAX_NUM_FORWARDS)
{
dwError = ERROR_OUT_OF_RANGE;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateStringA(pszForwarder, &szForwarderCopy);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAllocateMemory(
sizeof(VMDNS_FORWARDER_ENTRY),
(void**)&pForwarder->pForwarderEntries[dwCount]);
BAIL_ON_VMDNS_ERROR(dwError);
pForwarder->pForwarderEntries[dwCount]->pszForwarder = szForwarderCopy;
szForwarderCopy = NULL;
dwError = VmDnsForwarderMetricsInit(pForwarder->pForwarderEntries[dwCount]);
BAIL_ON_VMDNS_ERROR(dwError);
pForwarder->dwCount++;
cleanup:
return dwError;
error:
if (dwCount < VMDNS_MAX_NUM_FORWARDS && pForwarder->pForwarderEntries[dwCount])
{
VmDnsFreeForwarderEntry(pForwarder->pForwarderEntries[dwCount]);
}
VMDNS_SAFE_FREE_STRINGA(szForwarderCopy);
goto cleanup;
}
DWORD
VmDnsGetForwarders_inlock(
PVMDNS_FORWARDER_CONTEXT pForwarder,
PSTR** pppszForwarders,
PDWORD pdwCount
)
{
DWORD dwError = 0;
PSTR* pszForwarders = NULL;
DWORD dwCount = 0, i = 0;
BAIL_ON_VMDNS_INVALID_POINTER(pForwarder, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(pppszForwarders, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(pdwCount, dwError);
dwCount = pForwarder->dwCount;
dwError = VmDnsAllocateMemory(
(dwCount + 1) * sizeof(PSTR),
(PVOID*)&pszForwarders);
BAIL_ON_VMDNS_ERROR(dwError);
for (; i < dwCount; ++i)
{
dwError = VmDnsAllocateStringA(
pForwarder->pForwarderEntries[i]->pszForwarder,
&pszForwarders[i]);
BAIL_ON_VMDNS_ERROR(dwError);
}
*pdwCount = dwCount;
*pppszForwarders = pszForwarders;
cleanup:
return dwError;
error:
VmDnsFreeStringArrayA(pszForwarders);
goto cleanup;
}
DWORD
VmDnsSrvRecordGetCN(
PVMDNS_RECORD pRecord,
PSTR* ppStr
)
{
DWORD dwError = ERROR_SUCCESS;
PSTR pStr = NULL;
dwError = VmDnsAllocateStringA(pRecord->pszName, &pStr);
BAIL_ON_VMDNS_ERROR(dwError);
*ppStr = pStr;
cleanup:
return dwError;
error:
VMDNS_SAFE_FREE_STRINGA(pStr);
goto cleanup;
}
DWORD
VmDnsParseServiceProtocol(
PSTR pszServiceType,
VMDNS_SERVICE_PROTOCOL* pProtocol,
PSTR* ppszName
)
{
DWORD idx = 0;
DWORD dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_INVALID_POINTER(pszServiceType, dwError);
for (; idx < gProtocolNameMapSize; ++idx)
{
if (!VmDnsStringCompareA(pszServiceType,
gProtocolNameMap[idx].pszUserFriendlyName,
FALSE))
{
dwError = ERROR_SUCCESS;
if (pProtocol)
{
*pProtocol = gProtocolNameMap[idx].protocol;
}
if (ppszName)
{
dwError = VmDnsAllocateStringA(gProtocolNameMap[idx].pszName, ppszName);
}
break;
}
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsReadDomainNameFromBuffer(
PVMDNS_MESSAGE_BUFFER pVmDnsBuffer,
PSTR *ppszDomainName
)
{
DWORD dwError = 0;
DWORD dwTotalStringLength = 0;
DWORD dwLabelLength = 0;
PSTR pszTempString = NULL;
PSTR pszTempStringCursor = NULL;
PSTR pszLabels = NULL;
PSTR pszDomainName = NULL;
if (!pVmDnsBuffer||
!ppszDomainName
)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateMemory(
256,
(PVOID *)&pszTempString
);
BAIL_ON_VMDNS_ERROR(dwError);
pszTempStringCursor = pszTempString;
do
{
dwError = VmDnsReadStringFromBuffer(
pVmDnsBuffer,
&pszLabels,
&dwLabelLength
);
BAIL_ON_VMDNS_ERROR(dwError);
if (dwLabelLength)
{
dwError = VmDnsCopyMemory(
pszTempStringCursor,
255 - dwTotalStringLength,
pszLabels,
dwLabelLength
);
BAIL_ON_VMDNS_ERROR(dwError);
pszTempStringCursor[dwLabelLength]='.';
dwLabelLength++;
}
pszTempStringCursor = &pszTempStringCursor[dwLabelLength];
VMDNS_SAFE_FREE_STRINGA(pszLabels);
dwTotalStringLength += dwLabelLength;
if (dwTotalStringLength > 255)
{
dwError = ERROR_LABEL_TOO_LONG;
BAIL_ON_VMDNS_ERROR(dwError);
}
}while(dwLabelLength);
if (dwTotalStringLength > 0)
{
pszTempString[dwTotalStringLength - 1] = 0;
}
dwError = VmDnsAllocateStringA(
pszTempString,
&pszDomainName
);
BAIL_ON_VMDNS_ERROR(dwError);
*ppszDomainName = pszDomainName;
cleanup:
VMDNS_SAFE_FREE_STRINGA(pszTempString);
VMDNS_SAFE_FREE_STRINGA(pszLabels);
return dwError;
error:
if (ppszDomainName)
{
*ppszDomainName = NULL;
}
goto cleanup;
}
DWORD
VmDnsWriteDomainNameLabelsToBuffer(
PSTR pszDomainName,
PVMDNS_MESSAGE_BUFFER pVmDnsBuffer
)
{
DWORD dwError = 0;
PSTR pszTempString = NULL;
PSTR pToken = NULL;
PSTR pNextToken = NULL;
DWORD dwTotalStringLength = 0;
if (!pszDomainName ||
!pVmDnsBuffer
)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateStringA(
pszDomainName,
&pszTempString
);
BAIL_ON_VMDNS_ERROR(dwError);
pToken = VmDnsStringTokA(
pszTempString,
".",
&pNextToken
);
while(pToken)
{
DWORD dwStringLength = 0;
dwStringLength = VmDnsStringLenA(pToken);
if (dwStringLength > VMDNS_LABEL_LENGTH_MAX)
{
dwError = ERROR_LABEL_TOO_LONG;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsWriteStringToBuffer(
pToken,
dwStringLength,
pVmDnsBuffer
);
BAIL_ON_VMDNS_ERROR(dwError);
dwTotalStringLength += dwStringLength+1;
if (dwTotalStringLength > VMDNS_NAME_LENGTH_MAX)
{
dwError = ERROR_LABEL_TOO_LONG;
BAIL_ON_VMDNS_ERROR(dwError);
}
pToken = VmDnsStringTokA(
NULL,
".",
&pNextToken
);
}
if (++dwTotalStringLength > VMDNS_NAME_LENGTH_MAX)
{
dwError = ERROR_LABEL_TOO_LONG;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsWriteCharToBuffer(
0,
pVmDnsBuffer
);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
VMDNS_SAFE_FREE_STRINGA(pszTempString);
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsGetDomainNameLength(
PSTR pszDomainName,
PUINT16 puSize,
BOOL bTokenizeDomainName
)
{
DWORD dwError = 0;
PSTR pszTempString = NULL;
PSTR pToken = NULL;
PSTR pNextToken = NULL;
UINT16 uTotalStringLength = 0;
if (!puSize)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (bTokenizeDomainName)
{
dwError = VmDnsAllocateStringA(
pszDomainName,
&pszTempString
);
BAIL_ON_VMDNS_ERROR(dwError);
pToken = VmDnsStringTokA(
pszTempString,
".",
&pNextToken
);
while(++uTotalStringLength && pToken)
{
UINT16 uStringLength = 0;
uStringLength = VmDnsStringLenA(pToken);
uTotalStringLength += uStringLength;
pToken = VmDnsStringTokA(
NULL,
".",
&pNextToken
);
}
}
else
{
uTotalStringLength = VmDnsStringLenA(pszDomainName) + 1;
}
*puSize = uTotalStringLength;
cleanup:
VMDNS_SAFE_FREE_STRINGA(pszTempString);
return dwError;
error:
if (puSize)
{
*puSize = 0;
}
goto cleanup;
}
static
DWORD
VmDnsCliCreatePrimaryZone(
PVM_DNS_CLI_CONTEXT pContext
)
{
DWORD dwError = 0;
PSTR pszMboxDomain = NULL;
VMDNS_ZONE_INFO zoneInfo = { 0 };
VMDNS_RECORD nsRecord = {0};
VMDNS_RECORD addrRecord = {0};
PSTR pszTargetFQDN = NULL;
int ret = 0;
int af = AF_INET;
unsigned char buf[sizeof(struct in6_addr)];
if (IsNullOrEmptyString(pContext->pszZone))
{
fprintf(stderr, "Error: DNS Zone is not specified\n");
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (IsNullOrEmptyString(pContext->pszNSHost)
|| VmDnsCheckIfIPV4AddressA(pContext->pszNSHost)
|| VmDnsCheckIfIPV6AddressA(pContext->pszNSHost))
{
fprintf(stderr, "Error: Primary Nameserver host is not specified or the format is invalid\n");
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (pContext->dwZoneType == VMDNS_ZONE_TYPE_FORWARD &&
IsNullOrEmptyString(pContext->pszNSIp))
{
fprintf(stderr, "Error: Primary Nameserver IP Address is not specified\n");
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (IsNullOrEmptyString(pContext->pszMboxDomain))
{
dwError = VmDnsAllocateStringA("hostmaster", &pszMboxDomain);
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsMakeFQDN(pContext->pszNSHost,
pContext->pszZone,
&pszTargetFQDN);
BAIL_ON_VMDNS_ERROR(dwError);
zoneInfo.pszName = pContext->pszZone;
zoneInfo.pszPrimaryDnsSrvName = pszTargetFQDN;
zoneInfo.pszRName = pszMboxDomain ? pszMboxDomain : pContext->pszMboxDomain;
zoneInfo.serial = 1;
zoneInfo.refreshInterval = VMDNS_DEFAULT_REFRESH_INTERVAL;
zoneInfo.retryInterval = VMDNS_DEFAULT_RETRY_INTERVAL;
zoneInfo.expire = VMDNS_DEFAULT_EXPIRE;
zoneInfo.minimum = VMDNS_DEFAULT_TTL;
zoneInfo.dwFlags = 0;
zoneInfo.dwZoneType = pContext->dwZoneType;
dwError = VmDnsCreateZoneA(pContext->pServerContext, &zoneInfo);
BAIL_ON_VMDNS_ERROR(dwError);
if (!IsNullOrEmptyString(pContext->pszNSHost))
{
nsRecord.pszName = pContext->pszZone;
nsRecord.Data.NS.pNameHost = pszTargetFQDN;
nsRecord.iClass = VMDNS_CLASS_IN;
nsRecord.pszName = pContext->pszZone;
nsRecord.dwType = VMDNS_RR_TYPE_NS;
nsRecord.dwTtl = pContext->record.dwTtl;
dwError = VmDnsAddRecordA(
pContext->pServerContext,
pContext->pszZone,
&nsRecord);
BAIL_ON_VMDNS_ERROR(dwError);
}
if (!IsNullOrEmptyString(pContext->pszNSHost) &&
!IsNullOrEmptyString(pContext->pszNSIp) &&
pContext->dwZoneType == VMDNS_ZONE_TYPE_FORWARD)
{
addrRecord.iClass = VMDNS_CLASS_IN;
addrRecord.pszName = pszTargetFQDN;
addrRecord.dwType = VMDNS_RR_TYPE_A;
addrRecord.dwTtl = pContext->record.dwTtl;
if (VmDnsStringChrA(pContext->pszNSIp, ':'))
{
af = AF_INET6;
}
ret = inet_pton(af, pContext->pszNSIp, buf);
if (ret <= 0)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (af == AF_INET)
{
addrRecord.Data.A.IpAddress =
(VMDNS_IP4_ADDRESS)ntohl(((struct in_addr *)buf)->s_addr);
}
else if (af == AF_INET6)
{
addrRecord.dwType = VMDNS_RR_TYPE_AAAA;
dwError = VmDnsCopyMemory(
addrRecord.Data.AAAA.Ip6Address.IP6Byte,
sizeof(addrRecord.Data.AAAA.Ip6Address.IP6Byte),
#ifdef _WIN32
((struct in6_addr*)buf)->u.Byte,
#else
((struct in6_addr*)buf)->s6_addr,
#endif
sizeof(addrRecord.Data.AAAA.Ip6Address.IP6Byte));
BAIL_ON_VMDNS_ERROR(dwError);
}
else
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAddRecordA(
pContext->pServerContext,
pContext->pszZone,
&addrRecord);
BAIL_ON_VMDNS_ERROR(dwError);
}
if (!IsNullOrEmptyString(pContext->pszNSHost) &&
!IsNullOrEmptyString(pContext->pszNSIp) &&
pContext->dwZoneType == VMDNS_ZONE_TYPE_REVERSE)
{
addrRecord.iClass = VMDNS_CLASS_IN;
addrRecord.dwType = VMDNS_RR_TYPE_PTR;
addrRecord.dwTtl = VMDNS_DEFAULT_TTL;
addrRecord.Data.PTR.pNameHost = pszTargetFQDN;
dwError = VmDnsGeneratePtrNameFromIp(pContext->pszNSIp,&addrRecord.pszName);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAddRecordA(
pContext->pServerContext,
pContext->pszZone,
&addrRecord
);
BAIL_ON_VMDNS_ERROR(dwError);
}
cleanup:
if (pszMboxDomain)
{
VmDnsFreeStringA(pszMboxDomain);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
_GetForwarders(
PVMDNS_SERVER_CONTEXT pServerContext,
PCSTR pszZone,
PVMDNS_FORWARDERS* ppForwarders
)
{
DWORD dwError = 0;
PVMDNS_FORWARDERS pDnsForwarders = NULL;
PVMDNS_FORWARDERS pDnsForwardersOutput = NULL;
PSTR* ppszForwarders = NULL;
DWORD dwCount = 0;
dwError = VmDnsValidateContext(pServerContext);
BAIL_ON_VMDNS_ERROR(dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppForwarders, dwError);
DCETHREAD_TRY
{
if (pszZone)
{
dwError = VmDnsRpcGetZoneForwarders(
pServerContext->hBinding,
(PDNS_STRING)pszZone,
&pDnsForwarders);
}
else
{
dwError = VmDnsRpcGetForwarders(
pServerContext->hBinding,
&pDnsForwarders);
}
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
dwError = VmDnsRpcGetErrorCode(THIS_CATCH);
}
DCETHREAD_ENDTRY;
BAIL_ON_VMDNS_ERROR(dwError);
if (pDnsForwarders)
{
DWORD i = 0;
PSTR szTemp = NULL;
if (pDnsForwarders->dwCount > 0)
{
dwError = VmDnsAllocateMemory(
pDnsForwarders->dwCount * sizeof(PSTR),
(PVOID*)&ppszForwarders);
BAIL_ON_VMDNS_ERROR(dwError);
for (i = 0; i < pDnsForwarders->dwCount; ++i)
{
dwError = VmDnsAllocateStringA(
pDnsForwarders->ppszName[i],
&szTemp
);
BAIL_ON_VMDNS_ERROR(dwError);
ppszForwarders[i] = szTemp;
++dwCount;
}
}
dwError = VmDnsAllocateMemory(
sizeof(VMDNS_FORWARDERS),
(PVOID*)&pDnsForwardersOutput);
BAIL_ON_VMDNS_ERROR(dwError);
pDnsForwardersOutput->dwCount = pDnsForwarders->dwCount;
pDnsForwardersOutput->ppszName = ppszForwarders;
}
*ppForwarders = pDnsForwardersOutput;
cleanup:
if (pDnsForwarders)
{
VmDnsRpcFreeForwarders(pDnsForwarders);
}
return dwError;
error:
if (ppszForwarders)
{
VmDnsFreeStringCountedArrayA(ppszForwarders, dwCount);
}
if (pDnsForwardersOutput)
{
VMDNS_SAFE_FREE_MEMORY(pDnsForwardersOutput);
}
goto cleanup;
}
int
main(
int argc,
char * argv[])
{
DWORD dwError = 0;
int logLevel = VMDNS_LOG_LEVEL_INFO;
PCSTR pszLogFile = NULL;
BOOLEAN bEnableSysLog = FALSE;
//dwError = VmDnsSrvUpdateConfig();
//BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsParseArgs(
argc,
argv,
&logLevel,
&pszLogFile,
&gVmdnsGlobals.iListenPort,
&bEnableSysLog,
NULL);
if(dwError != ERROR_SUCCESS)
{
ShowUsage( argv[0] );
BAIL_ON_VMDNS_ERROR(dwError);
}
vmdns_syslog_level = logLevel;
if( bEnableSysLog != FALSE )
{
vmdns_syslog = 1;
}
if (pszLogFile)
{
dwError = VmDnsAllocateStringA(
pszLogFile,
&gVmdnsGlobals.pszLogFile);
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsConfigGetDword(VMDNS_KEY_VALUE_LOG_CAP, &gVmdnsGlobals.dwMaximumOldFiles);
if (dwError)
{
gVmdnsGlobals.dwMaximumOldFiles = VMDNS_DEFAULT_LOG_CAP;
}
dwError = VmDnsConfigGetDword(VMDNS_KEY_VALUE_LOG_SIZE, &gVmdnsGlobals.dwMaxLogSizeBytes);
if (dwError)
{
gVmdnsGlobals.dwMaxLogSizeBytes = VMDNS_DEFAULT_LOG_SIZE;
}
dwError = VmDnsLogInitialize(gVmdnsGlobals.pszLogFile,
gVmdnsGlobals.dwMaximumOldFiles,
gVmdnsGlobals.dwMaxLogSizeBytes);
BAIL_ON_VMDNS_ERROR(dwError);
VmDnsLog(VMDNS_LOG_LEVEL_INFO, "Vmdnsd: start" );
VmDnsBlockSelectedSignals();
dwError = VmDnsInit();
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsNotifyLikewiseServiceManager();
BAIL_ON_VMDNS_ERROR(dwError);
VmDnsdStateSet(VMDNSD_RUNNING);
// main thread waits on signals
dwError = VmDnsHandleSignals();
BAIL_ON_VMDNS_ERROR(dwError);
VmDnsLog( VMDNS_LOG_LEVEL_INFO, "Vmdnsd exiting..." );
cleanup:
VmDnsdStateSet(VMDNS_SHUTDOWN);
VmDnsShutdown();
VmDnsLog( VMDNS_LOG_LEVEL_INFO, "Vmdnsd: stop" );
VmDnsLogTerminate();
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsGenerateReversZoneNameFromNetworkId(
PCSTR pszNetworkId,
PSTR* ppszZone
)
{
DWORD dwError = 0;
PSTR pszPtrName = NULL;
PSTR pszZone = NULL;
PCHAR pLength = NULL;
int length = 0;
int family = AF_INET;
BAIL_ON_VMDNS_INVALID_POINTER(pszNetworkId, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppszZone, dwError);
pLength = VmDnsStringChrA(pszNetworkId, '/');
if (!pLength || !*(pLength + 1))
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
*pLength = '\0';
++pLength;
length = atoi(pLength);
dwError = VmDnsGenerateRtrNameFromIp(pszNetworkId, &family, &pszPtrName);
BAIL_ON_VMDNS_ERROR(dwError);
if (family != AF_INET && family != AF_INET6)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (family == AF_INET)
{
if (length != 8 && length != 16 && length != 24)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
pszZone = pszPtrName;
while (length < 32 && *pszZone)
{
pszZone = VmDnsStringChrA(pszZone, '.');
if (!pszZone)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
++pszZone;
length += 8;
}
if (!*pszZone)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
}
else
{
if (length >= 128 || length <= 0)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
pszZone = pszPtrName + 64 - length/2;
}
dwError = VmDnsAllocateStringA(pszZone, ppszZone);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
