DWORD
VmDnsCacheGetZoneName(
PVMDNS_ZONE_OBJECT pZoneObject,
PSTR *ppszZoneName
)
{
DWORD dwError = 0;
PSTR pszZoneName = NULL;
if (!pZoneObject)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsZoneGetName(pZoneObject, &pszZoneName);
BAIL_ON_VMDNS_ERROR(dwError);
*ppszZoneName = pszZoneName;
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsAllocateCondition(
PVMDNS_COND* ppCondition
)
{
DWORD dwError = ERROR_SUCCESS;
PVMDNS_COND pVmDnsCond = NULL;
if ( ppCondition == NULL )
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateMemory( sizeof(VMDNS_COND), ((PVOID*)&pVmDnsCond));
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsInitializeConditionContent( pVmDnsCond );
BAIL_ON_VMDNS_ERROR(dwError);
*ppCondition = pVmDnsCond;
pVmDnsCond = NULL;
error:
VMDNS_SAFE_FREE_CONDITION( pVmDnsCond );
return dwError;
}
static
int*
VmDnsGetLockKey(
pthread_key_t* pLockKey
)
{
DWORD dwError = ERROR_SUCCESS;
int* pCounter = NULL;
int* pCount = (int*)pthread_getspecific(*pLockKey);
if (!pCount)
{
dwError = VmDnsAllocateMemory(sizeof(int), (void**)&(pCounter));
BAIL_ON_VMDNS_ERROR(dwError);
dwError = pthread_setspecific(*pLockKey, pCounter);
dwError = POSIX_TO_WIN32_ERROR(dwError);
BAIL_ON_VMDNS_ERROR(dwError);
pCounter = NULL;
pCount = (int*)pthread_getspecific(*pLockKey);
}
cleanup:
return pCount;
error:
VMDNS_SAFE_FREE_MEMORY(pCounter);
goto cleanup;
}
DWORD VmDnsRpcCopySrvRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD pDest
)
{
DWORD dwError = 0;
PVMDNS_SRV_DATAA pData = NULL;
pData = &pDest->Data.SRV;
VmDnsRpcAllocateStringA(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;
VmDnsRpcAllocateStringA(pSrc->Data.SRV.pNameTarget, &pData->pNameTarget);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
VmDnsClearRecord(pDest);
goto cleanup;
}
DWORD
VmDnsAllocateRWLock(
PVMDNS_RWLOCK* ppLock
)
{
DWORD dwError = 0;
PVMDNS_RWLOCK pLock = NULL;
BAIL_ON_VMDNS_INVALID_POINTER(ppLock, dwError);
dwError = VmDnsAllocateMemory(sizeof(VMDNS_RWLOCK), (void**)&pLock);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = pthread_rwlock_init(&pLock->rwLock, NULL);
dwError = POSIX_TO_WIN32_ERROR(dwError);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = pthread_key_create(&pLock->readKey, VmDnsFreeLockCount);
dwError = POSIX_TO_WIN32_ERROR(dwError);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = pthread_key_create(&pLock->writeKey, VmDnsFreeLockCount);
dwError = POSIX_TO_WIN32_ERROR(dwError);
BAIL_ON_VMDNS_ERROR(dwError);
*ppLock = pLock;
cleanup:
return dwError;
error:
VMDNS_SAFE_FREE_MEMORY(pLock);
goto cleanup;
}
DWORD
VmDnsThreadJoin(
PVMDNS_THREAD pThread,
PDWORD pRetVal
)
{
DWORD dwError = ERROR_SUCCESS;
union
{
DWORD dwError;
PVOID pvRet;
} retVal = { 0 };
if(pThread == NULL)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = pthread_join(
(*pThread),
((pRetVal != NULL) ? &(retVal.pvRet) : NULL)
);
BAIL_ON_VMDNS_ERROR(dwError);
if( pRetVal != NULL )
{
// our ThreadFunction returns error code
*pRetVal = retVal.dwError;
}
error:
return dwError;
}
DWORD
VmDnsAllocateMutex(
PVMDNS_MUTEX* ppMutex
)
{
DWORD dwError = ERROR_SUCCESS;
PVMDNS_MUTEX pVmDnsMutex = NULL;
if ( ppMutex == NULL )
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateMemory( sizeof(VMDNS_MUTEX), ((PVOID*)&pVmDnsMutex));
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsInitializeMutexContent( pVmDnsMutex );
BAIL_ON_VMDNS_ERROR(dwError);
*ppMutex = pVmDnsMutex;
pVmDnsMutex = NULL;
error:
VMDNS_SAFE_FREE_MUTEX( pVmDnsMutex );
return dwError;
}
DWORD
VmDnsDuplicateNSRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD *ppDest
)
{
DWORD dwError = 0;
PVMDNS_RECORD pRecord = NULL;
BAIL_ON_VMDNS_INVALID_POINTER(pSrc, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppDest, dwError);
dwError = VmDnsAllocateMemory(sizeof(VMDNS_RECORD), (void**)&pRecord);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsCopyNSRecord(pSrc, pRecord);
BAIL_ON_VMDNS_ERROR(dwError);
*ppDest = pRecord;
pRecord = NULL;
cleanup:
return dwError;
error:
VMDNS_FREE_RECORD(pRecord);
if (ppDest)
{
*ppDest = NULL;
}
goto cleanup;
}
DWORD
VmDnsCacheRemoveZone(
PVMDNS_CACHE_CONTEXT pContext,
PVMDNS_ZONE_OBJECT pZoneObject
)
{
DWORD dwError = 0;
BOOL bLocked = FALSE;
if (!pZoneObject)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
VmDnsLockWrite(pContext->pLock);
bLocked = TRUE;
dwError = VmDnsZoneListRemoveZone(pContext->pZoneList, pZoneObject);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
if (bLocked)
{
VmDnsUnlockWrite(pContext->pLock);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
VmDnsCliCreateZone(
PVM_DNS_CLI_CONTEXT pContext
)
{
DWORD dwError = 0;
if (pContext->dwZoneType == VMDNS_ZONE_TYPE_FORWARDER)
{
dwError = VmDnsCliCreateForwarderZone(pContext);
BAIL_ON_VMDNS_ERROR(dwError);
}
else
{
dwError = VmDnsCliCreatePrimaryZone(pContext);
BAIL_ON_VMDNS_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsCachePurgeRecordProc(
PVOID pData,
PCSTR pszZone,
PCSTR pszNode
)
{
PVMDNS_CACHE_CONTEXT pCacheContext = (PVMDNS_CACHE_CONTEXT) pData;
PVMDNS_ZONE_OBJECT pZoneObject = NULL;
DWORD dwError = 0;
dwError = VmDnsCacheFindZone(
pCacheContext,
pszZone,
&pZoneObject
);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsCachePurgeRecord(pZoneObject, pszNode, CACHE_PURGE_REPLICATION);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
VmDnsZoneObjectRelease(pZoneObject);
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsForwarderInit(
PVMDNS_FORWARDER_CONTEXT* ppForwarder
)
{
DWORD dwError = ERROR_SUCCESS;
PVMDNS_FORWARDER_CONTEXT pForwarderContext = NULL;
BAIL_ON_VMDNS_INVALID_POINTER(ppForwarder, dwError);
dwError = VmDnsAllocateMemory(
sizeof(VMDNS_FORWARDER_CONTEXT),
(PVOID*)&pForwarderContext);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAllocateRWLock(&pForwarderContext->pLock);
BAIL_ON_VMDNS_ERROR(dwError);
*ppForwarder = pForwarderContext;
cleanup:
return dwError;
error:
if (pForwarderContext)
{
VmDnsForwarderCleanup(pForwarderContext);
}
goto cleanup;
}
DWORD
VmDnsRpcCopyPtrRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD pDest
)
{
DWORD dwError = 0;
PVMDNS_PTR_DATAA pData = NULL;
pData = &pDest->Data.PTR;
VmDnsRpcAllocateStringA(pSrc->pszName, &pDest->pszName);
BAIL_ON_VMDNS_ERROR(dwError);
pDest->iClass = pSrc->iClass;
pDest->dwTtl = pSrc->dwTtl;
pDest->dwType = pSrc->dwType;
VmDnsRpcAllocateStringA(pSrc->Data.PTR.pNameHost, &pData->pNameHost);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
VmDnsRpcClearPtrRecord(pDest);
goto cleanup;
}
DWORD
VmDnsRpcDuplicatePtrRecord(
PVMDNS_RECORD pSrc,
PVMDNS_RECORD *ppDest
)
{
DWORD dwError = 0;
PVMDNS_RECORD pRecord = NULL;
BAIL_ON_VMDNS_INVALID_POINTER(pSrc, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(ppDest, dwError);
dwError = VmDnsRpcAllocateMemory(sizeof(VMDNS_RECORD), (PVOID*)&pRecord);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsRpcCopyPtrRecord(pSrc, pRecord);
BAIL_ON_VMDNS_ERROR(dwError);
*ppDest = pRecord;
pRecord = NULL;
cleanup:
return dwError;
error:
VmDnsRpcClearPtrRecord(pRecord);
VmDnsRpcFreeMemory(pRecord);
if (ppDest)
{
*ppDest = NULL;
}
goto cleanup;
}
DWORD
VmDnsCacheSyncZones(
DWORD dwLastChangedUSN,
PVMDNS_CACHE_CONTEXT pCacheContext
)
{
DWORD dwError = 0;
dwError = VmDnsStoreSyncDeleted(
dwLastChangedUSN,
VmDnsCacheRemoveZoneProc,
(PVOID) pCacheContext
);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsStoreSyncNewObjects(
dwLastChangedUSN,
VmDnsCacheSyncZoneProc,
VmDnsCachePurgeRecordProc,
(PVOID) pCacheContext
);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
static
DWORD
VmDnsCacheStopRefreshThread(
PVMDNS_CACHE_CONTEXT pContext
)
{
DWORD dwError = 0;
if (!pContext->pRefreshEvent ||
!pContext->pRefreshThread)
{
dwError = ERROR_INVALID_STATE;
BAIL_ON_VMDNS_ERROR(dwError);
}
pContext->bShutdown = TRUE;
dwError = VmDnsConditionSignal(pContext->pRefreshEvent);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsThreadJoin(pContext->pRefreshThread, &dwError);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsCacheCleanupRefreshThread(pContext);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsConditionWait(
PVMDNS_COND pCondition,
PVMDNS_MUTEX pMutex
)
{
DWORD dwError = ERROR_SUCCESS;
if ( ( pCondition == NULL )
||
( pCondition->bInitialized == FALSE )
||
( pMutex == NULL )
||
( pMutex->bInitialized == FALSE )
)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = pthread_cond_wait(
&(pCondition->cond),
&(pMutex->critSect)
);
BAIL_ON_VMDNS_ERROR(dwError);
error:
return dwError;
}
static
DWORD
VmDnsCliDelForwarder(
PVM_DNS_CLI_CONTEXT pContext
)
{
DWORD dwError = 0;
if (pContext->pszZone)
{
dwError = VmDnsDeleteZoneForwarderA(
pContext->pServerContext,
pContext->pszForwarder,
pContext->pszZone);
BAIL_ON_VMDNS_ERROR(dwError);
}
else
{
dwError = VmDnsDeleteForwarderA(
pContext->pServerContext,
pContext->pszForwarder);
BAIL_ON_VMDNS_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsPropertyListAddList(
PVMDNS_PROPERTY_LIST pDestList,
PVMDNS_PROPERTY_LIST pSrcList
)
{
DWORD dwError = 0;
DWORD i = 0;
DWORD dwPropertyListSize = 0;
BAIL_ON_VMDNS_INVALID_POINTER(pDestList, dwError);
BAIL_ON_VMDNS_INVALID_POINTER(pSrcList, dwError);
if (pSrcList->dwCurrentSize == 0)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwPropertyListSize = VmDnsPropertyListGetSize(pSrcList);
for (i = 0; i < dwPropertyListSize; i++)
{
dwError = VmDnsPropertyListAdd(pDestList, pSrcList->ppProperties[i]);
BAIL_ON_VMDNS_ERROR(dwError);
}
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsCreateThread(
PVMDNS_THREAD pThread,
BOOLEAN bDetached,
VmDnsStartRoutine* pStartRoutine,
PVOID pArgs
)
{
DWORD dwError = ERROR_SUCCESS;
PVMDNS_THREAD_START_INFO pThreadStartInfo = NULL;
pthread_attr_t thrAttr;
BOOLEAN bThreadAttrInited = FALSE;
if ( ( pThread == NULL ) || ( pStartRoutine == NULL ) )
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if( bDetached != FALSE )
{
pthread_attr_init(&thrAttr);
bThreadAttrInited = TRUE;
pthread_attr_setdetachstate(&thrAttr, PTHREAD_CREATE_DETACHED);
}
dwError = VmDnsAllocateMemory(
sizeof(VMDNS_THREAD_START_INFO),
((PVOID*)&pThreadStartInfo)
);
BAIL_ON_VMDNS_ERROR(dwError);
pThreadStartInfo->pStartRoutine = pStartRoutine;
pThreadStartInfo->pArgs = pArgs;
dwError = pthread_create(
pThread,
((bDetached == FALSE) ? NULL : &thrAttr),
ThreadFunction,
pThreadStartInfo
);
BAIL_ON_VMDNS_ERROR(dwError);
// we started successfully -> pThreadStartInfo is now owned by
// ThreadFunction
pThreadStartInfo = NULL;
error:
if(bThreadAttrInited != FALSE)
{
pthread_attr_destroy(&thrAttr);
}
VMDNS_SAFE_FREE_MEMORY( pThreadStartInfo );
return dwError;
}
/**
* @brief Creates a Event queue to be used for detecting events on sockets
*
* @param[in,optional] iEventQueueSize
* specifies the event queue size.
* This value can be (-1) to use the default value
* @param[out] ppQueue Pointer to accept created event queue
*
* @return 0 on success
*/
DWORD
VmDnsSockWinCreateEventQueue(
int iEventQueueSize,
PVM_SOCK_EVENT_QUEUE* ppQueue
)
{
DWORD dwError = 0;
int sockError = 0;
PVM_SOCK_EVENT_QUEUE pQueue = NULL;
if (!ppQueue)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
if (iEventQueueSize <= 0)
{
iEventQueueSize = VM_SOCK_WINDOWS_DEFAULT_QUEUE_SIZE;
}
dwError = VmDnsAllocateMemory(sizeof(*pQueue), (PVOID*)&pQueue);
BAIL_ON_VMDNS_ERROR(dwError);
pQueue->hIOCP = CreateIoCompletionPort(
INVALID_HANDLE_VALUE,
NULL,
0,
0);
if (!pQueue->hIOCP)
{
dwError = GetLastError();
BAIL_ON_VMDNS_ERROR(dwError);
}
pQueue->hEventListen = WSACreateEvent();
if (pQueue->hEventListen == WSA_INVALID_EVENT)
{
dwError = WSAGetLastError();
BAIL_ON_VMDNS_ERROR(dwError);
}
*ppQueue = pQueue;
cleanup:
return dwError;
error:
if (ppQueue)
{
*ppQueue = NULL;
}
VmDnsSockWinCloseEventQueue(pQueue);
goto cleanup;
}
VMDNS_API
DWORD
VmDnsListRecordsA(
PVMDNS_SERVER_CONTEXT pServerContext,
PSTR pszZone,
PVMDNS_RECORD_ARRAY* ppRecordArray
)
{
DWORD dwError = 0;
PVMDNS_RECORD_ARRAY pRecordArray = NULL;
PVMDNS_RECORD_ARRAY pRpcRecordArray = NULL;
if (!pServerContext ||
!pServerContext->hBinding ||
!ppRecordArray)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
DCETHREAD_TRY
{
dwError = VmDnsRpcListRecords(
pServerContext->hBinding,
pszZone,
&pRpcRecordArray
);
}
DCETHREAD_CATCH_ALL(THIS_CATCH)
{
dwError = VmDnsRpcGetErrorCode(THIS_CATCH);
}
DCETHREAD_ENDTRY;
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsAllocateFromRpcRecordArray(
pRpcRecordArray,
&pRecordArray
);
BAIL_ON_VMDNS_ERROR(dwError);
*ppRecordArray = pRecordArray;
cleanup:
if (pRpcRecordArray)
{
VmDnsRpcClientFreeRpcRecordArray(pRpcRecordArray);
}
return dwError;
error:
VMDNS_FREE_RECORD_ARRAY(pRecordArray);
goto cleanup;
}
DWORD
VmDnsCacheLoadZoneFromStore(
PVMDNS_CACHE_CONTEXT pContext,
PCSTR pZoneName
)
{
DWORD dwError = 0;
PVMDNS_RECORD_LIST pList = NULL;
PVMDNS_ZONE_OBJECT pZoneObject = NULL;
BOOL bLocked = FALSE;
PVMDNS_PROPERTY_LIST pPropertyList = NULL;
if (IsNullOrEmptyString(pZoneName))
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
VmDnsLockWrite(pContext->pLock);
bLocked = TRUE;
dwError = VmDnsStoreGetProperties(pZoneName, &pPropertyList);
if (dwError && dwError != ERROR_NOT_FOUND)
{
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsStoreGetRecords(pZoneName, pZoneName, &pList);
if (dwError && dwError != ERROR_NOT_FOUND)
{
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsZoneCreateFromRecordList(pZoneName, pList, pPropertyList, &pZoneObject);
BAIL_ON_VMDNS_ERROR(dwError);
VmDnsZoneListAddZone(pContext->pZoneList, pZoneObject);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
if (bLocked)
{
VmDnsUnlockWrite(pContext->pLock);
}
VmDnsRecordListRelease(pList);
VmDnsPropertyListRelease(pPropertyList);
VmDnsZoneObjectRelease(pZoneObject);
return dwError;
error:
goto cleanup;
}
DWORD
VmDnsDeserializeDnsRecord(
PBYTE pBytes,
DWORD dwSize,
PVMDNS_RECORD *ppDnsRecord,
BOOL bTokenizeDomainName
)
{
DWORD dwError = 0;
PVMDNS_RECORD pDnsRecord = NULL;
PVMDNS_MESSAGE_BUFFER pVmDnsBuffer = NULL;
if (!pBytes ||
!dwSize ||
!ppDnsRecord)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
dwError = VmDnsAllocateBufferStreamWithBuffer(
pBytes,
dwSize,
0,
FALSE,
&pVmDnsBuffer
);
BAIL_ON_VMDNS_ERROR(dwError);
pVmDnsBuffer->bTokenizeDomainName = bTokenizeDomainName;
dwError = VmDnsReadRecordFromBuffer(
pVmDnsBuffer,
&pDnsRecord
);
BAIL_ON_VMDNS_ERROR(dwError);
*ppDnsRecord = pDnsRecord;
cleanup:
if (pVmDnsBuffer)
{
VmDnsFreeBufferStream(pVmDnsBuffer);
}
return dwError;
error:
if (ppDnsRecord)
{
*ppDnsRecord = NULL;
}
VMDNS_FREE_RECORD(pDnsRecord);
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;
}
static
DWORD
VmDnsCliListForwarders(
PVM_DNS_CLI_CONTEXT pContext
)
{
DWORD dwError = 0;
PVMDNS_FORWARDERS pForwarders = NULL;
DWORD iForwarder = 0;
if (pContext->pszZone)
{
dwError = VmDnsGetZoneForwardersA(
pContext->pServerContext,
pContext->pszZone,
&pForwarders);
BAIL_ON_VMDNS_ERROR(dwError);
}
else
{
dwError = VmDnsGetForwardersA(
pContext->pServerContext,
&pForwarders);
BAIL_ON_VMDNS_ERROR(dwError);
}
if (pForwarders->dwCount > 0)
{
if (pContext->pszZone)
{
fprintf(stdout, "Forwarders for zone %s:\n", pContext->pszZone);
}
else
{
fprintf(stdout, "Forwarders:\n");
}
for (; iForwarder < pForwarders->dwCount; iForwarder++)
{
fprintf(stdout, "%s\n", pForwarders->ppszName[iForwarder]);
}
}
error:
if (pForwarders)
{
VmDnsFreeForwarders(pForwarders);
}
return dwError;
}
int
VmDnsGenOriginatingTimeStr(
char * timeStr)
{
#ifndef _WIN32
struct timespec tspec = {0};
struct tm tmTime = {0};
int retVal = 0;
retVal = clock_gettime( CLOCK_REALTIME, &tspec );
BAIL_ON_VMDNS_ERROR(retVal);
if (gmtime_r(&tspec.tv_sec, &tmTime) == NULL)
{
retVal = errno;
BAIL_ON_VMDNS_ERROR(retVal);
}
snprintf( timeStr, VMDNS_ORIG_TIME_STR_LEN, "%4d%02d%02d%02d%02d%02d.%03d",
tmTime.tm_year+1900,
tmTime.tm_mon+1,
tmTime.tm_mday,
tmTime.tm_hour,
tmTime.tm_min,
tmTime.tm_sec,
(int)(tspec.tv_nsec/NSECS_PER_MSEC));
cleanup:
return retVal;
error:
goto cleanup;
#else
int retVal = 0;
SYSTEMTIME sysTime = {0};
GetSystemTime( &sysTime );
if( _snprintf_s(
timeStr,
VMDNS_ORIG_TIME_STR_LEN,
VMDNS_ORIG_TIME_STR_LEN-1,
"%4d%02d%02d%02d%02d%02d.%03d",
sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour,
sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds
) == -1 )
{
retVal = -1;
}
return retVal;
#endif
}
DWORD
VmDnsConditionTimedWait(
PVMDNS_COND pCondition,
PVMDNS_MUTEX pMutex,
DWORD dwMilliseconds
)
{
DWORD dwError = ERROR_SUCCESS;
struct timespec ts = {0};
BOOL bLocked = FALSE;
if ( ( pCondition == NULL )
||
( pCondition->bInitialized == FALSE )
||
( pMutex == NULL )
||
( pMutex->bInitialized == FALSE )
)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
ts.tv_sec = time(NULL) + dwMilliseconds/1000;
ts.tv_nsec = 0;
dwError = VmDnsLockMutex(pMutex);
BAIL_ON_VMDNS_ERROR(dwError);
bLocked = TRUE;
dwError = pthread_cond_timedwait(
&(pCondition->cond),
&(pMutex->critSect),
&ts
);
BAIL_ON_VMDNS_ERROR(dwError);
cleanup:
if (bLocked)
{
VmDnsUnlockMutex(pMutex);
}
return dwError;
error:
goto cleanup;
}
/**
* @brief Retrieves the protocol the socket has been configured with
*
* @param[in] pSocket Pointer to socket
* @param[in,out] pdwProtocol Protocol the socket has been configured with
* This will be one of { SOCK_STREAM, SOCK_DGRAM... }
*/
DWORD
VmDnsSockWinGetProtocol(
PVM_SOCKET pSocket,
PDWORD pdwProtocol
)
{
DWORD dwError = 0;
BOOLEAN bLocked = FALSE;
DWORD dwProtocol = 0;
if (!pSocket || !pdwProtocol)
{
dwError = ERROR_INVALID_PARAMETER;
BAIL_ON_VMDNS_ERROR(dwError);
}
switch (pSocket->protocol)
{
case VM_SOCK_PROTOCOL_UDP:
dwProtocol = SOCK_DGRAM;
break;
case VM_SOCK_PROTOCOL_TCP:
dwProtocol = SOCK_STREAM;
break;
default:
dwError = ERROR_INTERNAL_ERROR;
BAIL_ON_VMDNS_ERROR(dwError);
break;
}
*pdwProtocol = dwProtocol;
cleanup:
return dwError;
error:
if (pdwProtocol)
{
*pdwProtocol = 0;
}
goto cleanup;
}
VMDNS_API
DWORD
VmDnsOpenServerWithTimeOutA(
PCSTR pszNetworkAddress,
PCSTR pszUserName,
PCSTR pszDomain,
PCSTR pszPassword,
DWORD dwFlags,
PVOID pReserved,
DWORD dwTimeOut,
PVMDNS_SERVER_CONTEXT *ppServerContext
)
{
DWORD dwError = 0;
handle_t hBinding = NULL;
PVMDNS_SERVER_CONTEXT pServerContext = NULL;
CHAR szRpcPort[] = VMDNS_RPC_TCP_END_POINT;
dwError = VmDnsAllocateMemory(
sizeof(*pServerContext),
(PVOID)&pServerContext);
BAIL_ON_VMDNS_ERROR(dwError);
dwError = VmDnsCreateBindingHandleA(
pszNetworkAddress,
szRpcPort,
pszUserName,
pszDomain,
pszPassword,
&hBinding);
BAIL_ON_VMDNS_ERROR(dwError);
pServerContext->hBinding = hBinding;
hBinding = NULL;
rpc_mgmt_set_com_timeout(pServerContext->hBinding, dwTimeOut, &dwError);
BAIL_ON_VMDNS_ERROR(dwError);
*ppServerContext = pServerContext;
pServerContext = NULL;
cleanup:
return dwError;
error:
VmDnsCloseServer(pServerContext);
goto cleanup;
}
