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