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; }