Пример #1
0
DWORD
VmDnsDuplicatePtrRecord(
    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 = VmDnsCopyPtrRecord(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;
}
Пример #2
0
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;
}
Пример #3
0
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;
}
Пример #4
0
VOID
VmDnsRecordObjectRelease(
    PVMDNS_RECORD_OBJECT    pRecordObj
    )
{
    if (pRecordObj)
    {
        if (0 == InterlockedDecrement(&pRecordObj->lRefCount))
        {
            VMDNS_FREE_RECORD(pRecordObj->pRecord);
            VMDNS_SAFE_FREE_MEMORY(pRecordObj);
        }
    }
}
Пример #5
0
DWORD
VmDnsReadRecordFromBuffer(
        PVMDNS_MESSAGE_BUFFER pVmDnsBuffer,
        PVMDNS_RECORD *ppDnsRecord
        )
{
    DWORD dwError = 0;
    PVMDNS_RECORD pDnsRecord = NULL;
    DWORD dwIndex =  0;

    if (!pVmDnsBuffer || !ppDnsRecord)
    {
        dwError = ERROR_INVALID_PARAMETER;
        BAIL_ON_VMDNS_ERROR(dwError);
    }

    dwError = VmDnsAllocateMemory(
                              sizeof(VMDNS_RECORD),
                              (PVOID *)&pDnsRecord
                              );
    BAIL_ON_VMDNS_ERROR(dwError);

    dwError = VmDnsReadDomainNameFromBuffer(
                              pVmDnsBuffer,
                              &pDnsRecord->pszName
                              );
    BAIL_ON_VMDNS_ERROR(dwError);

    dwError = VmDnsReadUINT16FromBuffer(
                             pVmDnsBuffer,
                             &pDnsRecord->dwType
                             );
    BAIL_ON_VMDNS_ERROR(dwError);

    dwError = VmDnsReadUINT16FromBuffer(
                             pVmDnsBuffer,
                             &pDnsRecord->iClass
                             );
    BAIL_ON_VMDNS_ERROR(dwError);

    dwError = VmDnsReadUINT32FromBuffer(
                             pVmDnsBuffer,
                             &pDnsRecord->dwTtl
                             );
    BAIL_ON_VMDNS_ERROR(dwError);

    for (; dwIndex < gRecordMethodMapSize; ++dwIndex)
    {
        if (pDnsRecord->dwType == gRecordMethods[dwIndex].type)
        {
            dwError = gRecordMethods[dwIndex].pfnDeSerialize(
                                                    pVmDnsBuffer,
                                                    &pDnsRecord->Data
                                                    );
            BAIL_ON_VMDNS_ERROR(dwError);
        }
    }

    *ppDnsRecord = pDnsRecord;

cleanup:

    return dwError;
error:

    if (ppDnsRecord)
    {
        *ppDnsRecord = NULL;
    }
    VMDNS_FREE_RECORD(pDnsRecord);
    goto cleanup;
}