DWORD
DNSUpdateCreateUpdateRequest(
PDNS_UPDATE_REQUEST * ppDNSRequest
)
{
DWORD dwError = 0;
PDNS_UPDATE_REQUEST pDNSRequest = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_UPDATE_REQUEST),
(PVOID *)&pDNSRequest);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSGenerateIdentifier(&pDNSRequest->wIdentification);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSRequest->wParameter = 0x2800;
*ppDNSRequest = pDNSRequest;
cleanup:
return dwError;
error:
if (pDNSRequest){
DNSUpdateFreeRequest(pDNSRequest);
}
*ppDNSRequest = NULL;
goto cleanup;
}
DWORD
DNSUpdateSendUpdateRequest2(
HANDLE hDNSServer,
PDNS_UPDATE_REQUEST pDNSRequest
)
{
DWORD dwError = 0;
DWORD dwBytesSent = 0;
HANDLE hSendBuffer = (HANDLE)NULL;
dwError = DNSUpdateBuildRequestMessage(
pDNSRequest,
&hSendBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSSendBufferContext(
hDNSServer,
hSendBuffer,
&dwBytesSent);
BAIL_ON_LWDNS_ERROR(dwError);
cleanup:
if (hSendBuffer)
{
DNSFreeSendBufferContext(hSendBuffer);
}
return dwError;
error:
goto cleanup;
}
static
DWORD
DNSUpdateMarshallAdditionalSection(
HANDLE hSendBuffer,
PDNS_RR_RECORD * ppDNSAdditionalsRRRecords,
WORD wAdditionals
)
{
DWORD dwError = 0;
DWORD i = 0;
for (i = 0; i < wAdditionals; i++)
{
PDNS_RR_RECORD pDNSAdditionalRRRecord = NULL;
pDNSAdditionalRRRecord = *(ppDNSAdditionalsRRRecords + i);
dwError = DNSMarshallRRHeader(
hSendBuffer,
pDNSAdditionalRRRecord);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSMarshallRData(
hSendBuffer,
pDNSAdditionalRRRecord);
BAIL_ON_LWDNS_ERROR(dwError);
}
error:
return dwError;
}
DWORD
DNSUnmarshallRRHeader(
HANDLE hRecvBuffer,
PDNS_RR_HEADER pRRHeader
)
{
DWORD dwError = 0;
DWORD dwRead = 0;
WORD wnType = 0;
WORD wnClass = 0;
WORD wnRDataSize = 0;
DWORD dwnTTL = 0;
dwError = DNSUnmarshallDomainName(
hRecvBuffer,
&pRRHeader->pDomainName);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnType,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pRRHeader->wType = ntohs(wnType);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnClass,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pRRHeader->wClass = ntohs(wnClass);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&dwnTTL,
sizeof(DWORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pRRHeader->dwTTL = ntohl(dwnTTL);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnRDataSize,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pRRHeader->wRDataSize = htons(wnRDataSize);
error:
return dwError;
}
DWORD
DNSOpen(
PCSTR pszNameServer,
DWORD dwType,
PHANDLE phDNSServer
)
{
DWORD dwError = 0;
HANDLE hDNSServer = (HANDLE)NULL;
if (IsNullOrEmptyString(pszNameServer))
{
dwError = LWDNS_ERROR_INVALID_PARAMETER;
BAIL_ON_LWDNS_ERROR(dwError);
}
switch (dwType)
{
case DNS_TCP:
dwError = DNSTCPOpen(
pszNameServer,
&hDNSServer
);
break;
case DNS_UDP:
dwError = DNSUDPOpen(
pszNameServer,
&hDNSServer
);
break;
default:
dwError = LWDNS_ERROR_INVALID_PARAMETER;
}
BAIL_ON_LWDNS_ERROR(dwError);
*phDNSServer = hDNSServer;
cleanup:
return dwError;
error:
*phDNSServer = (HANDLE)NULL;
goto cleanup;
}
DWORD
DNSTCPReceiveBufferContext(
HANDLE hDNSHandle,
HANDLE hDNSRecvBuffer,
PDWORD pdwBytesRead
)
{
DWORD dwError = 0;
DWORD dwRead = 0;
WORD wBytesToRead = 0;
WORD wnBytesToRead = 0;
PDNS_CONNECTION_CONTEXT pDNSContext = NULL;
PDNS_RECEIVEBUFFER_CONTEXT pDNSRecvContext = NULL;
pDNSContext = (PDNS_CONNECTION_CONTEXT)hDNSHandle;
pDNSRecvContext = (PDNS_RECEIVEBUFFER_CONTEXT)hDNSRecvBuffer;
dwRead = recv(
pDNSContext->s,
(char *)&wnBytesToRead,
sizeof(WORD),
0);
if (dwRead == SOCKET_ERROR) {
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
wBytesToRead = ntohs(wnBytesToRead);
dwRead = recv(
pDNSContext->s,
(char *)pDNSRecvContext->pRecvBuffer,
wBytesToRead,
0);
if (dwRead == SOCKET_ERROR) {
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
pDNSRecvContext->dwBytesRecvd = dwRead;
*pdwBytesRead = (DWORD)dwRead;
cleanup:
return dwError;
error:
goto cleanup;
}
DWORD
DNSDLinkedListPrepend(
PDNSDLINKEDLIST* ppList,
PVOID pItem
)
{
DWORD dwError = 0;
PDNSDLINKEDLIST pList = NULL;
dwError = DNSAllocateMemory(sizeof(DNSDLINKEDLIST), (PVOID*)&pList);
BAIL_ON_LWDNS_ERROR(dwError);
pList->pItem = pItem;
if (*ppList) {
(*ppList)->pPrev = pList;
pList->pNext = *ppList;
*ppList = pList;
} else {
*ppList = pList;
}
cleanup:
return dwError;
error:
if (pList) {
DNSFreeMemory(pList);
}
goto cleanup;
}
DWORD
DNSUpdateAddPRSection(
PDNS_UPDATE_REQUEST pDNSRequest,
PDNS_RR_RECORD pDNSRecord
)
{
DWORD dwError = 0;
DWORD dwNumPRs = 0;
dwNumPRs = pDNSRequest->wPRs;
dwError = DNSReallocMemory(
pDNSRequest->ppPRRRSet,
(PVOID *)&pDNSRequest->ppPRRRSet,
(dwNumPRs + 1) *sizeof(PDNS_RR_RECORD));
BAIL_ON_LWDNS_ERROR(dwError);
*(pDNSRequest->ppPRRRSet + dwNumPRs) = pDNSRecord;
pDNSRequest->wPRs += 1;
error:
return dwError;
}
DWORD
DNSUpdateAddUpdateSection(
PDNS_UPDATE_REQUEST pDNSRequest,
PDNS_RR_RECORD pDNSRecord
)
{
DWORD dwError = 0;
WORD wNumUpdates = 0;
wNumUpdates = pDNSRequest->wUpdates;
dwError = DNSReallocMemory(
pDNSRequest->ppUpdateRRSet,
(PVOID *)&pDNSRequest->ppUpdateRRSet,
(wNumUpdates + 1) * sizeof(PDNS_RR_RECORD));
BAIL_ON_LWDNS_ERROR(dwError);
*(pDNSRequest->ppUpdateRRSet + wNumUpdates) = pDNSRecord;
pDNSRequest->wUpdates += 1;
error:
return dwError;
}
DWORD
DNSUpdateAddZoneSection(
PDNS_UPDATE_REQUEST pDNSRequest,
PDNS_ZONE_RECORD pDNSZone
)
{
DWORD dwError = 0;
DWORD dwNumZones = 0;
dwNumZones = pDNSRequest->wZones;
dwError = DNSReallocMemory(
(PBYTE)pDNSRequest->ppZoneRRSet,
(PVOID *)&pDNSRequest->ppZoneRRSet,
(dwNumZones + 1)*sizeof(PDNS_ZONE_RECORD));
BAIL_ON_LWDNS_ERROR(dwError);
*(pDNSRequest->ppZoneRRSet + dwNumZones) = pDNSZone;
pDNSRequest->wZones += 1;
error:
return dwError;
}
static
DWORD
DNSUpdateAllocateResponse(
PDNS_UPDATE_RESPONSE * ppDNSResponse
)
{
DWORD dwError = 0;
PDNS_UPDATE_RESPONSE pDNSResponse = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_UPDATE_RESPONSE),
(PVOID *)&pDNSResponse);
BAIL_ON_LWDNS_ERROR(dwError);
*ppDNSResponse = pDNSResponse;
cleanup:
return(dwError);
error:
*ppDNSResponse = NULL;
goto cleanup;
}
static
DWORD
DNSStdAllocateResponse(
PDNS_RESPONSE * ppDNSResponse
)
{
DWORD dwError = 0;
PDNS_RESPONSE pDNSResponse = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_RESPONSE),
(PVOID *)&pDNSResponse);
BAIL_ON_LWDNS_ERROR(dwError);
*ppDNSResponse = pDNSResponse;
cleanup:
return dwError;
error:
*ppDNSResponse = NULL;
if (pDNSResponse)
{
DNSStdFreeResponse(pDNSResponse);
}
goto cleanup;
}
DWORD
DNSUDPOpen(
PCSTR pszNameServer,
PHANDLE phDNSServer
)
{
DWORD dwError = 0;
unsigned long ulAddress;
struct hostent *pHost = NULL;
PDNS_CONNECTION_CONTEXT pDNSContext = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_CONNECTION_CONTEXT),
(PVOID *)&pDNSContext);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSContext->hType = DNS_UDP;
ulAddress = inet_addr (pszNameServer);
if (INADDR_NONE == ulAddress)
{
pHost = gethostbyname (pszNameServer);
if (NULL == pHost)
{
dwError = h_errno;
BAIL_ON_HERRNO_ERROR(dwError);
}
memcpy((char*)&ulAddress, pHost->h_addr, pHost->h_length);
}
// Create a socket for sending data
pDNSContext->s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
//-------------------------------------------
// Set up the RecvAddr structure with the IP address of
// the receiver (in this example case "123.456.789.1")
// and the specified port number.
//
pDNSContext->RecvAddr.sin_family = AF_INET;
pDNSContext->RecvAddr.sin_port = htons(DNS_UDP_PORT);
pDNSContext->RecvAddr.sin_addr.s_addr = ulAddress;
*phDNSServer = (HANDLE)pDNSContext;
cleanup:
return dwError;
error:
*phDNSServer = (HANDLE)NULL;
if (pDNSContext)
{
DNSClose((HANDLE)pDNSContext);
}
goto cleanup;
}
DWORD
DNSGetNetworkInterfaces(
PLW_INTERFACE_INFO* ppInterfaceInfoArray,
PDWORD pdwNumInterfaces
)
{
DWORD dwError = 0;
PLW_INTERFACE_INFO pInterfaceInfoArray = NULL;
DWORD dwNumInterfaces = 0;
PLW_DLINKED_LIST pInterfaceList = NULL;
dwError = DNSGatherInterfaceInfo(
&pInterfaceList);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSBuildInterfaceArray(
pInterfaceList,
&pInterfaceInfoArray,
&dwNumInterfaces);
BAIL_ON_LWDNS_ERROR(dwError);
*ppInterfaceInfoArray = pInterfaceInfoArray;
*pdwNumInterfaces = dwNumInterfaces;
cleanup:
if (pInterfaceList)
{
DNSFreeInterfaceLinkedList(pInterfaceList);
}
return dwError;
error:
if (pInterfaceInfoArray)
{
DNSFreeNetworkInterfaces(
pInterfaceInfoArray,
dwNumInterfaces);
}
*ppInterfaceInfoArray = NULL;
*pdwNumInterfaces = 0;
goto cleanup;
}
static
DWORD
DNSUpdateMarshallZoneSection(
HANDLE hSendBuffer,
PDNS_ZONE_RECORD * ppDNSZoneRecords,
WORD wZones
)
{
DWORD dwError = 0;
DWORD i = 0;
for (i = 0; i < wZones; i++)
{
PDNS_ZONE_RECORD pDNSZoneRecord = NULL;
DWORD dwRead = 0;
WORD wnZoneType = 0;
WORD wnZoneClass = 0;
pDNSZoneRecord = *(ppDNSZoneRecords + i);
dwError = DNSMarshallDomainName(
hSendBuffer,
pDNSZoneRecord->pDomainName);
BAIL_ON_LWDNS_ERROR(dwError);
wnZoneType = htons(pDNSZoneRecord->wZoneType);
dwError = DNSMarshallBuffer(
hSendBuffer,
(PBYTE)&wnZoneType,
(DWORD)sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wnZoneClass = htons(pDNSZoneRecord->wZoneClass);
dwError = DNSMarshallBuffer(
hSendBuffer,
(PBYTE)&wnZoneClass,
(DWORD)sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
}
error:
return dwError;
}
DWORD
DNSCreateSendBuffer(
HANDLE * phDNSSendBuffer
)
{
DWORD dwError = 0;
PDNS_SENDBUFFER_CONTEXT pDNSContext = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_SENDBUFFER_CONTEXT),
(PVOID *)&pDNSContext);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateMemory(
SENDBUFFER_SIZE,
(PVOID *)&pDNSContext->pSendBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSContext->dwBufferSize = SENDBUFFER_SIZE;
//
// We will offset into the buffer by 2 bytes
// If we are doing a TCP write; we will fill in these
// two bytes and send + 2 bytes
// If we are doing a UDP write; we will start our send
// +2 bytes and only send dwWritten;
//
pDNSContext->dwBufferOffset += 2;
*phDNSSendBuffer = (HANDLE)pDNSContext;
cleanup:
return dwError;
error:
if (pDNSContext) {
DNSFreeSendBuffer((HANDLE)pDNSContext);
}
*phDNSSendBuffer = (HANDLE)NULL;
goto cleanup;
}
DWORD
DNSGetPtrNameForAddr(
PSTR* ppszRecordName,
PSOCKADDR_IN pAddr
)
{
DWORD dwError = 0;
PSTR pszRecordName = NULL;
DWORD dwIPV4Addr = ntohl(pAddr->sin_addr.s_addr);
if (pAddr->sin_family != AF_INET)
{
dwError = LWDNS_ERROR_INVALID_IP_ADDRESS;
BAIL_ON_LWDNS_ERROR(dwError);
}
dwError = LwRtlCStringAllocatePrintf(
&pszRecordName,
"%d.%d.%d.%d.in-addr.arpa",
(dwIPV4Addr >> 0) & 255,
(dwIPV4Addr >> 8) & 255,
(dwIPV4Addr >> 16) & 255,
(dwIPV4Addr >> 24) & 255
);
if (dwError)
{
dwError = ENOMEM;
BAIL_ON_LWDNS_ERROR(dwError);
}
*ppszRecordName = pszRecordName;
cleanup:
return dwError;
error:
*ppszRecordName = NULL;
LwRtlCStringFree(&pszRecordName);
goto cleanup;
}
DWORD
DNSUnmarshallRData(
HANDLE hRecvBuffer,
DWORD dwSize,
PBYTE* ppRData,
PDWORD pdwRead
)
{
DWORD dwError = 0;
PBYTE pMemory = NULL;
dwError = DNSAllocateMemory(
dwSize,
(PVOID *)&pMemory);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)pMemory,
dwSize,
pdwRead);
BAIL_ON_LWDNS_ERROR(dwError);
*ppRData = pMemory;
cleanup:
return(dwError);
error:
if (pMemory) {
DNSFreeMemory(pMemory);
}
*ppRData = NULL;
goto cleanup;
}
DWORD
DNSMarshallBuffer(
HANDLE hDNSSendBuffer,
PBYTE pDNSSendBuffer,
DWORD dwBufferSize,
PDWORD pdwBytesWritten
)
{
DWORD dwError = 0;
PBYTE pTemp = NULL;
PDNS_SENDBUFFER_CONTEXT pDNSContext = NULL;
DWORD dwRemaining = 0;
pDNSContext = (PDNS_SENDBUFFER_CONTEXT)hDNSSendBuffer;
dwRemaining = pDNSContext->dwBufferSize - pDNSContext->dwBufferOffset;
if (dwRemaining < dwBufferSize)
{
DWORD dwNewSize =
(pDNSContext->dwBufferSize +
(dwBufferSize - dwRemaining) + 256);
dwError = DNSReallocMemory(
pDNSContext->pSendBuffer,
(PVOID*)&pDNSContext->pSendBuffer,
dwNewSize);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSContext->dwBufferSize = dwNewSize;
}
pTemp = pDNSContext->pSendBuffer + pDNSContext->dwBufferOffset;
memcpy(pTemp, pDNSSendBuffer, dwBufferSize);
pDNSContext->dwBytesWritten += dwBufferSize;
pDNSContext->dwBufferOffset += dwBufferSize;
*pdwBytesWritten = dwBufferSize;
cleanup:
return dwError;
error:
*pdwBytesWritten = 0;
goto cleanup;
}
DWORD
DNSUnmarshallBuffer(
HANDLE hDNSRecvBuffer,
PBYTE pDNSRecvBuffer,
DWORD dwBufferSize,
PDWORD pdwBytesRead
)
{
DWORD dwError = 0;
PBYTE pTemp = NULL;
PDNS_RECEIVEBUFFER_CONTEXT pDNSContext = NULL;
DWORD dwRemaining = 0;
pDNSContext = (PDNS_RECEIVEBUFFER_CONTEXT)hDNSRecvBuffer;
dwRemaining = pDNSContext->dwBufferSize - pDNSContext->dwBytesRead;
if (dwRemaining < dwBufferSize)
{
DWORD dwNewSize =
(pDNSContext->dwBufferSize +
(dwBufferSize - dwRemaining) + 256);
dwError = DNSReallocMemory(
pDNSContext->pRecvBuffer,
(PVOID*)&pDNSContext->pRecvBuffer,
dwNewSize);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSContext->dwBufferSize = dwNewSize;
}
pTemp = pDNSContext->pRecvBuffer + pDNSContext->dwBytesRead;
memcpy(pDNSRecvBuffer, pTemp, dwBufferSize);
pDNSContext->dwBytesRead += dwBufferSize;
*pdwBytesRead = dwBufferSize;
cleanup:
return dwError;
error:
*pdwBytesRead = 0;
goto cleanup;
}
DWORD
DNSCreateReceiveBuffer(
HANDLE * phDNSRecvBuffer
)
{
DWORD dwError = 0;
PDNS_RECEIVEBUFFER_CONTEXT pDNSContext = NULL;
dwError = DNSAllocateMemory(
sizeof(DNS_RECEIVEBUFFER_CONTEXT),
(PVOID *)&pDNSContext);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateMemory(
RECVBUFFER_SIZE,
(PVOID *)&pDNSContext->pRecvBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSContext->dwBufferSize = RECVBUFFER_SIZE;
*phDNSRecvBuffer = (HANDLE)pDNSContext;
cleanup:
return dwError;
error:
if (pDNSContext) {
DNSFreeReceiveBufferContext((HANDLE)pDNSContext);
}
*phDNSRecvBuffer = (HANDLE)NULL;
goto cleanup;
}
DWORD
DNSSendUDPRequest(
HANDLE hDNSHandle,
PBYTE pDNSSendBuffer,
DWORD dwBufferSize,
PDWORD pdwBytesSent
)
{
DWORD dwError = 0;
DWORD dwBytesSent = 0;
PDNS_CONNECTION_CONTEXT pDNSContext = NULL;
pDNSContext = (PDNS_CONNECTION_CONTEXT)hDNSHandle;
dwBytesSent = sendto(
pDNSContext->s,
pDNSSendBuffer,
dwBufferSize,
0,
(SOCKADDR *)&pDNSContext->RecvAddr,
sizeof(pDNSContext->RecvAddr));
if (dwBytesSent == SOCKET_ERROR)
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
*pdwBytesSent = dwBytesSent;
cleanup:
return dwError;
error:
*pdwBytesSent = 0;
goto cleanup;
}
static
DWORD
DNSStdUnmarshallAdditionalSection(
HANDLE hReceiveBuffer,
WORD wAdditionals,
PDNS_RR_RECORD ** pppDNSAdditionalsRRRecords
)
{
DWORD dwError = 0;
DWORD i = 0;
PDNS_RR_RECORD pDNSRRRecord = NULL;
PDNS_RR_RECORD * ppDNSAdditionalRRRecords = NULL;
PBYTE pRData = NULL;
DNS_RR_HEADER RRHeader = {0};
PDNS_RR_HEADER pRRHeader = &RRHeader;
dwError = DNSAllocateMemory(
wAdditionals * sizeof(PDNS_RR_RECORD),
(PVOID *)&ppDNSAdditionalRRRecords);
BAIL_ON_LWDNS_ERROR(dwError);
for (i = 0; i < wAdditionals; i++)
{
DWORD dwRead = 0;
memset(pRRHeader, 0, sizeof(DNS_RR_HEADER));
dwError = DNSUnmarshallRRHeader(
hReceiveBuffer,
pRRHeader);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallRData(
hReceiveBuffer,
pRRHeader->wRDataSize,
&pRData,
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateMemory(
sizeof(DNS_RR_RECORD),
(PVOID *)&pDNSRRRecord);
BAIL_ON_LWDNS_ERROR(dwError);
memcpy(&pDNSRRRecord->RRHeader, pRRHeader, sizeof(DNS_RR_HEADER));
pRRHeader->pDomainName = NULL;
pDNSRRRecord->pRData = pRData;
pRData = NULL;
*(ppDNSAdditionalRRRecords + i) = pDNSRRRecord;
pDNSRRRecord = NULL;
}
*pppDNSAdditionalsRRRecords = ppDNSAdditionalRRRecords;
cleanup:
return dwError;
error:
if (pRData)
{
DNSFreeMemory(pRData);
}
if (pDNSRRRecord)
{
DNSFreeRecord(pDNSRRRecord);
}
if (pRRHeader && pRRHeader->pDomainName)
{
DNSFreeDomainName(pRRHeader->pDomainName);
}
if (ppDNSAdditionalRRRecords)
{
DNSFreeRecordList(
ppDNSAdditionalRRRecords,
wAdditionals);
}
*pppDNSAdditionalsRRRecords = NULL;
goto cleanup;
}
static
DWORD
DNSBuildInterfaceArray(
PLW_DLINKED_LIST pInterfaceList,
PLW_INTERFACE_INFO* ppInterfaceInfoArray,
PDWORD pdwNumInterfaces
)
{
DWORD dwError = 0;
DWORD dwNumInterfaces = 0;
PLW_INTERFACE_INFO pInterfaceInfoArray = NULL;
PLW_DLINKED_LIST pIter = NULL;
DWORD i = 0;
for (pIter = pInterfaceList; pIter; pIter = pIter->pNext)
{
dwNumInterfaces++;
}
if (!dwNumInterfaces)
{
goto done;
}
dwError = DNSAllocateMemory(
sizeof(LW_INTERFACE_INFO) * dwNumInterfaces,
(PVOID*)&pInterfaceInfoArray);
BAIL_ON_LWDNS_ERROR(dwError);
for (pIter = pInterfaceList; pIter; pIter = pIter->pNext, i++)
{
PLW_INTERFACE_INFO pSrcInfo = NULL;
PLW_INTERFACE_INFO pDstInfo = NULL;
pSrcInfo = (PLW_INTERFACE_INFO)pIter->pItem;
pDstInfo = &pInterfaceInfoArray[i];
memcpy(pDstInfo, pSrcInfo, sizeof(LW_INTERFACE_INFO));
memset(pSrcInfo, 0, sizeof(LW_INTERFACE_INFO));
}
done:
*ppInterfaceInfoArray = pInterfaceInfoArray;
*pdwNumInterfaces = dwNumInterfaces;
cleanup:
return dwError;
error:
if (pInterfaceInfoArray)
{
DNSFreeNetworkInterfaces(
pInterfaceInfoArray,
dwNumInterfaces);
}
*ppInterfaceInfoArray = NULL;
*pdwNumInterfaces = 0;
goto cleanup;
}
static
DWORD
DNSGetInfoUsingIoctl(
PLW_DLINKED_LIST* ppInterfaceList
)
{
DWORD dwError = 0;
SOCKET fd = -1;
DWORD dwBufLen = 0;
DWORD dwLastBufLen = 0;
PBYTE pBuffer = NULL;
PBYTE pIter = NULL;
struct ifconf ifc = {0};
PLW_DLINKED_LIST pInterfaceList = NULL;
PLW_INTERFACE_INFO pInterfaceInfo = NULL;
fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd < 0)
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
dwBufLen = 64 * sizeof(struct ifreq);
dwError = DNSAllocateMemory(
dwBufLen,
(PVOID*)&pBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
do
{
DWORD dwNewSize = 0;
ifc.ifc_len = dwBufLen;
ifc.ifc_buf = (caddr_t)pBuffer;
// On some systems, the ioctl returns success
// even if the buffer is insufficient. So, we
// retry until the buffer length consolidates
if (ioctl(fd, SIOCGIFCONF, &ifc) < 0)
{
if ((errno != EINVAL) || (dwLastBufLen))
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
}
else
{
if (dwLastBufLen == ifc.ifc_len)
{
break;
}
dwLastBufLen = ifc.ifc_len;
}
dwNewSize = dwLastBufLen + 32 * sizeof(struct ifreq);
dwError = DNSReallocMemory(
pBuffer,
(PVOID*)&pBuffer,
dwNewSize);
BAIL_ON_LWDNS_ERROR(dwError);
dwBufLen = dwNewSize;
} while (TRUE);
for (pIter = pBuffer; pIter < pBuffer + dwBufLen;)
{
CHAR szItfName[IFNAMSIZ+1];
PSTR pszIpAddress = NULL;
DWORD dwFlags = 0;
struct ifreq* pInterfaceRecord = NULL;
struct ifreq interfaceRecordCopy;
struct sockaddr * pSA = NULL;
DWORD dwLen = 0;
#ifdef LW_SKIP_ALIASED_INTERFACES
PSTR pszIndex = NULL;
#endif
pInterfaceRecord = (struct ifreq*)pIter;
#ifdef AF_LINK
if (pInterfaceRecord->ifr_addr.sa_family == AF_LINK)
{
#if defined(__LWI_AIX__)
dwLen = DNS_MAX(sizeof(struct sockaddr_dl), ((struct sockaddr_dl*)&pInterfaceRecord->ifr_addr)->sdl_len);
#else /* Solaris etc. */
dwLen = sizeof(struct sockaddr_dl);
#endif
}
else
{
#endif
switch (pInterfaceRecord->ifr_addr.sa_family)
{
#ifdef HAVE_SOCKADDR_SA_LEN
dwLen = DNS_MAX(sizeof(struct sockaddr), pInterfaceRecord->ifr_addr.sa_len);
#else
#ifdef AF_INET6
case AF_INET6:
#ifdef __LWI_HP_UX__
dwLen = sizeof(short) + sizeof(short) + sizeof(uint32_t) + (sizeof(uint8_t) * 16);
#else
dwLen = sizeof(struct sockaddr_in6);
#endif
break;
#endif
case AF_INET:
default:
dwLen = sizeof(struct sockaddr);
break;
}
#endif /* HAVE_SOCKADDR_SA_LEN */
#ifdef AF_LINK
}
#endif
pIter += sizeof(pInterfaceRecord->ifr_name) + dwLen;
#ifdef LW_SKIP_ALIASED_INTERFACES
// On Solaris, the name for an aliased interface contains
// a colon.
if ((pszIndex = strchr(pInterfaceRecord->ifr_name, ':')))
{
*pszIndex = '\0';
}
#endif
memset(szItfName, 0, sizeof(szItfName));
memcpy(szItfName, pInterfaceRecord->ifr_name, IFNAMSIZ);
LWDNS_LOG_VERBOSE("Considering network interface [%s]", szItfName);
pSA = (struct sockaddr*)&pInterfaceRecord->ifr_addr;
if (pSA->sa_family != AF_INET)
{
LWDNS_LOG_VERBOSE("Skipping network interface [%s] [family:%d] because it is not AF_INET family", szItfName, pSA->sa_family);
continue;
}
interfaceRecordCopy = *pInterfaceRecord;
if (ioctl(fd, SIOCGIFFLAGS, &interfaceRecordCopy) < 0)
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
dwFlags = interfaceRecordCopy.ifr_flags;
if (dwFlags & IFF_LOOPBACK)
{
LWDNS_LOG_VERBOSE("Skipping loopback network interface [%s]", szItfName);
continue;
}
if (!(dwFlags & IFF_UP))
{
LWDNS_LOG_VERBOSE("Skipping in-active network interface [%s]", szItfName);
continue;
}
#ifdef LW_SKIP_ALIASED_INTERFACES
if (DNSInterfaceIsInList(szItfName, pInterfaceList))
{
LWDNS_LOG_VERBOSE("Skipping aliased network interface [%s]",
IsNullOrEmptyString(szItfName) ? "" : szItfName);
continue;
}
#endif
dwError = DNSAllocateMemory(
sizeof(LW_INTERFACE_INFO),
(PVOID*)&pInterfaceInfo);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateMemory(
IF_NAMESIZE,
(PVOID*)&pInterfaceInfo->pszName);
BAIL_ON_LWDNS_ERROR(dwError);
strncpy(pInterfaceInfo->pszName,
pInterfaceRecord->ifr_name,
IF_NAMESIZE-1);
pInterfaceInfo->dwFlags = dwFlags;
if (ioctl(fd, SIOCGIFADDR, &interfaceRecordCopy, sizeof(struct ifreq)) < 0)
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
// From the above logic, we consider only
// AF_INET addresses at this point.
memcpy(&pInterfaceInfo->ipAddr,
&pInterfaceRecord->ifr_addr,
sizeof(struct sockaddr_in));
dwError = LwDLinkedListAppend(
&pInterfaceList,
pInterfaceInfo);
BAIL_ON_LWDNS_ERROR(dwError);
pszIpAddress = inet_ntoa(((struct sockaddr_in*)&pInterfaceInfo->ipAddr)->sin_addr);
LWDNS_LOG_VERBOSE("Added network interface [Name:%s; Address:%s] to list",
(IsNullOrEmptyString(pInterfaceInfo->pszName) ? "" : pInterfaceInfo->pszName),
(IsNullOrEmptyString(pszIpAddress) ? "" : pszIpAddress));
pInterfaceInfo = NULL;
}
*ppInterfaceList = pInterfaceList;
cleanup:
if (fd >= 0)
{
close(fd);
}
if (pBuffer)
{
DNSFreeMemory(pBuffer);
}
return dwError;
error:
if (pInterfaceInfo)
{
DNSFreeNetworkInterface(pInterfaceInfo);
}
if (pInterfaceList)
{
DNSFreeInterfaceLinkedList(pInterfaceList);
}
goto cleanup;
}
static
DWORD
DNSGetInfoUsingGetIfAddrs(
PLW_DLINKED_LIST* ppInterfaceList
)
{
DWORD dwError = 0;
PLW_DLINKED_LIST pInterfaceList = NULL;
struct ifaddrs* pInterfaces = NULL;
struct ifaddrs* pIter = NULL;
PLW_INTERFACE_INFO pInterfaceInfo = NULL;
if (getifaddrs(&pInterfaces) < 0)
{
dwError = errno;
BAIL_ON_LWDNS_ERROR(dwError);
}
for (pIter = pInterfaces; pIter; pIter = pIter->ifa_next)
{
if (IsNullOrEmptyString(pIter->ifa_name))
{
LWDNS_LOG_VERBOSE("Skipping network interface with no name");
continue;
}
LWDNS_LOG_VERBOSE("Considering network interface [%s]",
pIter->ifa_name);
if (pIter->ifa_addr->sa_family != AF_INET)
{
if (pIter->ifa_addr->sa_family != AF_INET6)
{
LWDNS_LOG_VERBOSE("Skipping network interface [%s] because it is not AF_INET/AF_INET6 family", pIter->ifa_name);
continue;
}
}
if (!(pIter->ifa_flags & IFF_UP))
{
LWDNS_LOG_VERBOSE("Skipping in-active network interface [%s]",
pIter->ifa_name);
continue;
}
if (pIter->ifa_flags & IFF_LOOPBACK)
{
LWDNS_LOG_VERBOSE("Skipping loopback network interface [%s]",
pIter->ifa_name);
continue;
}
#ifdef LW_SKIP_ALIASED_INTERFACES
if (DNSInterfaceIsInList(pIter->ifa_name, pInterfaceList))
{
LWDNS_LOG_VERBOSE("Skipping aliased network interface [%s]",
pIter->ifa_name);
continue;
}
#endif
dwError = DNSAllocateMemory(
sizeof(LW_INTERFACE_INFO),
(PVOID*)&pInterfaceInfo);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateString(
pIter->ifa_name,
&pInterfaceInfo->pszName);
BAIL_ON_LWDNS_ERROR(dwError);
if (pIter->ifa_addr)
{
if (pIter->ifa_addr->sa_family == AF_INET)
{
memcpy(&pInterfaceInfo->ipAddr,
pIter->ifa_addr,
sizeof(*pIter->ifa_addr));
}
#ifndef HAVE_HPUX_OS
else if (pIter->ifa_addr->sa_family == AF_INET6)
{
pInterfaceInfo->bIPV6Enabled = TRUE;
memcpy(&pInterfaceInfo->ipv6Addr,
pIter->ifa_addr,
sizeof(struct sockaddr_in6));
}
#endif
}
pInterfaceInfo->dwFlags = pIter->ifa_flags;
dwError = LwDLinkedListAppend(
&pInterfaceList,
pInterfaceInfo);
BAIL_ON_LWDNS_ERROR(dwError);
LWDNS_LOG_VERBOSE("Added network interface [Name:%s] to list",
pInterfaceInfo->pszName);
pInterfaceInfo = NULL;
}
*ppInterfaceList = pInterfaceList;
cleanup:
if (pInterfaces)
{
freeifaddrs(pInterfaces);
}
return dwError;
error:
if (pInterfaceList)
{
DNSFreeInterfaceLinkedList(pInterfaceList);
}
if (pInterfaceInfo)
{
DNSFreeNetworkInterface(pInterfaceInfo);
}
*ppInterfaceList = NULL;
goto cleanup;
}
DWORD
DNSStdReceiveStdResponse(
HANDLE hDNSHandle,
PDNS_RESPONSE* ppDNSResponse
)
{
PDNS_RESPONSE pDNSResponse = NULL;
DWORD dwError = 0;
WORD wnIdentification,wIdentification = 0;
WORD wnParameter, wParameter = 0;
WORD wnQuestions, wQuestions = 0;
WORD wnAnswers, wAnswers = 0;
WORD wnAdditionals, wAdditionals = 0;
WORD wnAuthoritys, wAuthoritys = 0;
DWORD dwRead = 0;
PDNS_RR_RECORD * ppDNSAnswerRecords = NULL;
PDNS_RR_RECORD * ppDNSAdditionalRecords = NULL;
PDNS_RR_RECORD * ppDNSAuthorityRecords = NULL;
PDNS_QUESTION_RECORD * ppDNSQuestionRecords = NULL;
HANDLE hRecvBuffer = (HANDLE)NULL;
dwError = DNSCreateReceiveBuffer(&hRecvBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSReceiveBufferContext(
hDNSHandle,
hRecvBuffer,
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSDumpRecvBufferContext(hRecvBuffer);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnIdentification,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wIdentification = ntohs(wnIdentification);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnParameter,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wParameter = ntohs(wnParameter);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnQuestions,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wQuestions = ntohs(wnQuestions);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnAnswers,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wAnswers = ntohs(wnAnswers);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnAuthoritys,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wAuthoritys = ntohs(wnAuthoritys);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)&wnAdditionals,
sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wAdditionals = ntohs(wnAdditionals);
if (wQuestions)
{
dwError = DNSStdUnmarshallQuestionSection(
hRecvBuffer,
wQuestions,
&ppDNSQuestionRecords);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (wAnswers)
{
dwError = DNSStdUnmarshallAnswerSection(
hRecvBuffer,
wAnswers,
&ppDNSAnswerRecords);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (wAuthoritys)
{
dwError = DNSStdUnmarshallAuthoritySection(
hRecvBuffer,
wAuthoritys,
&ppDNSAuthorityRecords);
BAIL_ON_LWDNS_ERROR(dwError);
}
if (wAdditionals)
{
dwError = DNSStdUnmarshallAdditionalSection(
hRecvBuffer,
wAdditionals,
&ppDNSAdditionalRecords);
BAIL_ON_LWDNS_ERROR(dwError);
}
dwError = DNSStdAllocateResponse(&pDNSResponse);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSResponse->wIdentification = wIdentification;
pDNSResponse->wParameter = wParameter;
pDNSResponse->wQuestions = wQuestions;
pDNSResponse->wAnswers = wAnswers;
pDNSResponse->wAuthoritys = wAuthoritys;
pDNSResponse->wAdditionals = wAdditionals;
pDNSResponse->ppQuestionRRSet = ppDNSQuestionRecords;
pDNSResponse->ppAnswerRRSet = ppDNSAnswerRecords;
pDNSResponse->ppAuthorityRRSet = ppDNSAuthorityRecords;
pDNSResponse->ppAdditionalRRSet = ppDNSAdditionalRecords;
*ppDNSResponse = pDNSResponse;
cleanup:
if (hRecvBuffer != (HANDLE)NULL)
{
DNSFreeReceiveBufferContext(hRecvBuffer);
}
return dwError;
error:
if (ppDNSAnswerRecords)
{
DNSFreeRecordList(
ppDNSAnswerRecords,
wAnswers);
}
if (ppDNSAdditionalRecords)
{
DNSFreeRecordList(
ppDNSAdditionalRecords,
wAdditionals);
}
if (ppDNSAuthorityRecords)
{
DNSFreeRecordList(
ppDNSAuthorityRecords,
wAuthoritys);
}
if (ppDNSQuestionRecords)
{
DNSFreeQuestionRecordList(
ppDNSQuestionRecords,
wQuestions);
}
*ppDNSResponse = NULL;
goto cleanup;
}
static
DWORD
DNSStdUnmarshallQuestionSection(
HANDLE hReceiveBuffer,
WORD wQuestions,
PDNS_QUESTION_RECORD ** pppDNSQuestionRecords
)
{
DWORD dwError = 0;
DWORD i = 0;
PDNS_QUESTION_RECORD pDNSQuestionRecord = NULL;
PDNS_QUESTION_RECORD * ppDNSQuestionRecords = NULL;
dwError = DNSAllocateMemory(
wQuestions * sizeof(PDNS_QUESTION_RECORD),
(PVOID *)&ppDNSQuestionRecords);
BAIL_ON_LWDNS_ERROR(dwError);
for (i = 0; i < wQuestions; i++)
{
DWORD dwRead = 0;
WORD wnQueryClass = 0;
WORD wnQueryType = 0;
dwError = DNSAllocateMemory(
sizeof(DNS_QUESTION_RECORD),
(PVOID *)&pDNSQuestionRecord);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallDomainName(
hReceiveBuffer,
&pDNSQuestionRecord->pDomainName);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallBuffer(
hReceiveBuffer,
(PBYTE)&wnQueryType,
(DWORD)sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSQuestionRecord->wQueryType = ntohs(wnQueryType);
dwError = DNSUnmarshallBuffer(
hReceiveBuffer,
(PBYTE)&wnQueryClass,
(DWORD)sizeof(WORD),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
pDNSQuestionRecord->wQueryClass = ntohs(wnQueryClass);
*(ppDNSQuestionRecords + i) = pDNSQuestionRecord;
pDNSQuestionRecord = NULL;
}
*pppDNSQuestionRecords = ppDNSQuestionRecords;
cleanup:
return dwError;
error:
if (ppDNSQuestionRecords)
{
DNSFreeQuestionRecordList(
ppDNSQuestionRecords,
wQuestions);
}
if (pDNSQuestionRecord)
{
DNSFreeQuestionRecord(pDNSQuestionRecord);
}
*pppDNSQuestionRecords = NULL;
goto cleanup;
}
/*
* Note: This function reads the string without updating the index
*/
static
DWORD
DNSUnmarshallDomainNameAtOffset(
HANDLE hRecvBuffer,
WORD wOffset,
PDNS_DOMAIN_LABEL * ppDomainLabel
)
{
DWORD dwError = 0;
PDNS_DOMAIN_LABEL pLabel = NULL;
BYTE uLen = 0;
DWORD dwCurrent = 0;
PDNS_RECEIVEBUFFER_CONTEXT pRecvContext = NULL;
CHAR szLabel[65];
pRecvContext = (PDNS_RECEIVEBUFFER_CONTEXT)hRecvBuffer;
dwCurrent = wOffset;
memcpy(&uLen, pRecvContext->pRecvBuffer+dwCurrent, sizeof(char));
switch (uLen & 0xC0)
{
case 0x00:
dwCurrent++;
memset(szLabel, 0, sizeof(szLabel));
memcpy(szLabel, pRecvContext->pRecvBuffer+dwCurrent, uLen);
dwCurrent += uLen;
dwError = DNSAllocateMemory(
sizeof(DNS_DOMAIN_LABEL),
(PVOID *)&pLabel);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateString(szLabel, &pLabel->pszLabel);
BAIL_ON_LWDNS_ERROR(dwError);
break;
default:
dwError = LWDNS_ERROR_BAD_RESPONSE;
BAIL_ON_LWDNS_ERROR(dwError);
break;
}
*ppDomainLabel = pLabel;
cleanup:
return dwError;
error:
*ppDomainLabel = NULL;
if (pLabel)
{
DNSFreeLabel(pLabel);
}
goto cleanup;
}
DWORD
DNSUnmarshallDomainName(
HANDLE hRecvBuffer,
PDNS_DOMAIN_NAME * ppDomainName
)
{
DWORD dwError = 0;
PDNS_DOMAIN_LABEL pLabel = NULL;
PDNS_DOMAIN_NAME pDomainName = NULL;
BYTE uLen = 0;
DWORD dwRead = 0;
BYTE uLen1, uLen2 = 0;
WORD wOffset = 0;
BOOLEAN bDone = FALSE;
dwError = DNSAllocateMemory(
sizeof(DNS_DOMAIN_NAME),
(PVOID *)&pDomainName);
BAIL_ON_LWDNS_ERROR(dwError);
do
{
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
&uLen1,
sizeof(char),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
switch (uLen1 & 0xC0)
{
case 0xC0: /* pointer to string */
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
&uLen2,
sizeof(char),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
wOffset = ntohs((((WORD)(uLen1) << 8)|uLen2) & 0x3FFF);
dwError = DNSUnmarshallDomainNameAtOffset(
hRecvBuffer,
wOffset,
&pLabel);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAppendLabel(
pDomainName->pLabelList,
pLabel,
&pDomainName->pLabelList);
BAIL_ON_LWDNS_ERROR(dwError);
pLabel = NULL;
break;
case 0x00: /* string component */
{
CHAR szLabel[65];
dwError = DNSReceiveBufferMoveBackIndex(hRecvBuffer, 1);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
&uLen,
sizeof(char),
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
if (uLen == 0)
{
bDone = TRUE;
break;
}
memset(szLabel, 0, sizeof(szLabel));
dwError = DNSUnmarshallBuffer(
hRecvBuffer,
(PBYTE)szLabel,
uLen,
&dwRead);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateMemory(
sizeof(DNS_DOMAIN_LABEL),
(PVOID *)&pLabel);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAllocateString(szLabel, &pLabel->pszLabel);
BAIL_ON_LWDNS_ERROR(dwError);
dwError = DNSAppendLabel(
pDomainName->pLabelList,
pLabel,
&pDomainName->pLabelList);
BAIL_ON_LWDNS_ERROR(dwError);
pLabel = NULL;
}
break;
default: /* unexpected */
dwError = LWDNS_ERROR_BAD_RESPONSE;
BAIL_ON_LWDNS_ERROR(dwError);
break;
}
} while (!bDone);
*ppDomainName = pDomainName;
cleanup:
return(dwError);
error:
if (pDomainName)
{
DNSFreeDomainName(pDomainName);
}
if (pLabel)
{
DNSFreeLabel(pLabel);
}
*ppDomainName = NULL;
goto cleanup;
}
