自学教程：C++ BAIL_ON_VMDNS_ERROR函数代码示例

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

intVmDnsGenOriginatingTimeStr(    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}

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

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