+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS DNS Shared Library
+ * FILE: lib/dnslib/sablob.c
+ * PURPOSE: Functions for the Saved Answer Blob Implementation
+ */
+
+/* INCLUDES ******************************************************************/
+#include "precomp.h"
+
+/* DATA **********************************************************************/
+
+/* FUNCTIONS *****************************************************************/
+
+PVOID
+WINAPI
+FlatBuf_Arg_ReserveAlignPointer(IN PVOID Position,
+ IN PSIZE_T FreeSize,
+ IN SIZE_T Size)
+{
+ /* Just a little helper that we use */
+ return FlatBuf_Arg_Reserve(Position, FreeSize, Size, sizeof(PVOID));
+}
+
+PDNS_BLOB
+WINAPI
+SaBlob_Create(IN ULONG Count)
+{
+ PDNS_BLOB Blob;
+ PDNS_ARRAY DnsAddrArray;
+
+ /* Allocate the blob */
+ Blob = Dns_AllocZero(sizeof(DNS_BLOB));
+ if (Blob)
+ {
+ /* Check if it'll hold any addresses */
+ if (Count)
+ {
+ /* Create the DNS Address Array */
+ DnsAddrArray = DnsAddrArray_Create(Count);
+ if (!DnsAddrArray)
+ {
+ /* Failure, free the blob */
+ SaBlob_Free(Blob);
+ SetLastError(ERROR_OUTOFMEMORY);
+ }
+ else
+ {
+ /* Link it with the blob */
+ Blob->DnsAddrArray = DnsAddrArray;
+ }
+ }
+ }
+
+ /* Return the blob */
+ return Blob;
+}
+
+PDNS_BLOB
+WINAPI
+SaBlob_CreateFromIp4(IN LPWSTR Name,
+ IN ULONG Count,
+ IN PIN_ADDR AddressArray)
+{
+ PDNS_BLOB Blob;
+ LPWSTR NameCopy;
+ ULONG i;
+
+ /* Create the blob */
+ Blob = SaBlob_Create(Count);
+ if (!Blob) goto Quickie;
+
+ /* If we have a name */
+ if (Name)
+ {
+ /* Create a copy of it */
+ NameCopy = Dns_CreateStringCopy_W(Name);
+ if (!NameCopy) goto Quickie;
+
+ /* Save the pointer to the name */
+ Blob->Name = NameCopy;
+ }
+
+ /* Loop all the addresses */
+ for (i = 0; i < Count; i++)
+ {
+ /* Add an entry for this address */
+ DnsAddrArray_AddIp4(Blob->DnsAddrArray, AddressArray[i], IpV4Address);
+ }
+
+ /* Return the blob */
+ return Blob;
+
+Quickie:
+ /* Free the blob, set error and fail */
+ SaBlob_Free(Blob);
+ SetLastError(ERROR_OUTOFMEMORY);
+ return NULL;
+}
+
+VOID
+WINAPI
+SaBlob_Free(IN PDNS_BLOB Blob)
+{
+ /* Make sure we got a blob */
+ if (Blob)
+ {
+ /* Free the name */
+ Dns_Free(Blob->Name);
+
+ /* Loop the aliases */
+ while (Blob->AliasCount)
+ {
+ /* Free the alias */
+ Dns_Free(Blob->Aliases[Blob->AliasCount]);
+
+ /* Decrease number of aliases */
+ Blob->AliasCount--;
+ }
+
+ /* Free the DNS Address Array */
+ DnsAddrArray_Free(Blob->DnsAddrArray);
+
+ /* Free the blob itself */
+ Dns_Free(Blob);
+ }
+}
+
+PHOSTENT
+WINAPI
+SaBlob_CreateHostent(IN OUT PULONG_PTR BufferPosition,
+ IN OUT PSIZE_T FreeBufferSpace,
+ IN OUT PSIZE_T HostEntrySize,
+ IN PDNS_BLOB Blob,
+ IN DWORD StringType,
+ IN BOOLEAN Relative,
+ IN BOOLEAN BufferAllocated)
+{
+ PDNS_ARRAY DnsAddrArray = Blob->DnsAddrArray;
+ ULONG AliasCount = Blob->AliasCount;
+ WORD AddressFamily = AF_UNSPEC;
+ ULONG AddressCount = 0, AddressSize = 0, TotalSize, NamePointerSize;
+ ULONG AliasPointerSize;
+ PDNS_FAMILY_INFO FamilyInfo = NULL;
+ ULONG StringLength = 0;
+ ULONG i;
+ ULONG HostentSize = 0;
+ PHOSTENT Hostent = NULL;
+ ULONG_PTR HostentPtr;
+ PVOID CurrentAddress;
+
+ /* Check if we actually have any addresses */
+ if (DnsAddrArray)
+ {
+ /* Get the address family */
+ AddressFamily = DnsAddrArray->Addresses[0].AddressFamily;
+
+ /* Get family information */
+ FamilyInfo = FamilyInfo_GetForFamily(AddressFamily);
+
+ /* Save the current address count and their size */
+ AddressCount = DnsAddrArray->UsedAddresses;
+ AddressSize = FamilyInfo->AddressSize;
+ }
+
+ /* Calculate total size for all the addresses, and their pointers */
+ TotalSize = AddressSize * AddressCount;
+ NamePointerSize = AddressCount * sizeof(PVOID) + sizeof(PVOID);
+
+ /* Check if we have a name */
+ if (Blob->Name)
+ {
+ /* Find out the size we'll need for a copy */
+ StringLength = (Dns_GetBufferLengthForStringCopy(Blob->Name,
+ 0,
+ UnicodeString,
+ StringType) + 1) & ~1;
+ }
+
+ /* Now do the same for the aliases */
+ for (i = AliasCount; i; i--)
+ {
+ /* Find out the size we'll need for a copy */
+ HostentSize += (Dns_GetBufferLengthForStringCopy(Blob->Aliases[i],
+ 0,
+ UnicodeString,
+ StringType) + 1) & ~1;
+ }
+
+ /* Find out how much the pointers will take */
+ AliasPointerSize = AliasCount * sizeof(PVOID) + sizeof(PVOID);
+
+ /* Calculate Hostent Size */
+ HostentSize += TotalSize +
+ NamePointerSize +
+ AliasPointerSize +
+ StringLength +
+ sizeof(HOSTENT);
+
+ /* Check if we already have a buffer */
+ if (!BufferAllocated)
+ {
+ /* We don't, allocate space ourselves */
+ HostentPtr = (ULONG_PTR)Dns_AllocZero(HostentSize);
+ }
+ else
+ {
+ /* We do, so allocate space in the buffer */
+ HostentPtr = (ULONG_PTR)FlatBuf_Arg_ReserveAlignPointer(BufferPosition,
+ FreeBufferSpace,
+ HostentSize);
+ }
+
+ /* Make sure we got space */
+ if (HostentPtr)
+ {
+ /* Initialize it */
+ Hostent = Hostent_Init((PVOID)&HostentPtr,
+ AddressFamily,
+ AddressSize,
+ AddressCount,
+ AliasCount);
+ }
+
+ /* Loop the addresses */
+ for (i = 0; i < AddressCount; i++)
+ {
+ /* Get the pointer of the current address */
+ CurrentAddress = (PVOID)((ULONG_PTR)&DnsAddrArray->Addresses[i] +
+ FamilyInfo->AddressOffset);
+
+ /* Write the pointer */
+ Hostent->h_addr_list[i] = (PCHAR)HostentPtr;
+
+ /* Copy the address */
+ RtlCopyMemory((PVOID)HostentPtr, CurrentAddress, AddressSize);
+
+ /* Advance the buffer */
+ HostentPtr += AddressSize;
+ }
+
+ /* Check if we have a name */
+ if (Blob->Name)
+ {
+ /* Align our current position */
+ HostentPtr += 1 & ~1;
+
+ /* Save our name here */
+ Hostent->h_name = (LPSTR)HostentPtr;
+
+ /* Now copy it in the blob */
+ HostentPtr += Dns_StringCopy((PVOID)HostentPtr,
+ NULL,
+ Blob->Name,
+ 0,
+ UnicodeString,
+ StringType);
+ }
+
+ /* Loop the Aliases */
+ for (i = AliasCount; i; i--)
+ {
+ /* Align our current position */
+ HostentPtr += 1 & ~1;
+
+ /* Save our alias here */
+ Hostent->h_aliases[i] = (LPSTR)HostentPtr;
+
+ /* Now copy it in the blob */
+ HostentPtr += Dns_StringCopy((PVOID)HostentPtr,
+ NULL,
+ Blob->Aliases[i],
+ 0,
+ UnicodeString,
+ StringType);
+ }
+
+ /* Check if the caller didn't have a buffer */
+ if (!BufferAllocated)
+ {
+ /* Return the size; not needed if we had a blob, since it's internal */
+ *HostEntrySize = *BufferPosition - (ULONG_PTR)HostentPtr;
+ }
+
+ /* Convert to Offsets if requested */
+ if(Relative) Hostent_ConvertToOffsets(Hostent);
+
+ /* Return the full, complete, hostent */
+ return Hostent;
+}
+
+INT
+WINAPI
+SaBlob_WriteNameOrAlias(IN PDNS_BLOB Blob,
+ IN LPWSTR String,
+ IN BOOLEAN IsAlias)
+{
+ /* Check if this is an alias */
+ if (!IsAlias)
+ {
+ /* It's not. Simply create a copy of the string */
+ Blob->Name = Dns_CreateStringCopy_W(String);
+ if (!Blob->Name) return GetLastError();
+ }
+ else
+ {
+ /* Does it have a name, and less then 8 aliases? */
+ if ((Blob->Name) && (Blob->AliasCount <= 8))
+ {
+ /* Yup, create a copy of the string and increase the alias count */
+ Blob->Aliases[Blob->AliasCount] = Dns_CreateStringCopy_W(String);
+ Blob->AliasCount++;
+ }
+ else
+ {
+ /* Invalid request! */
+ return ERROR_MORE_DATA;
+ }
+ }
+
+ /* Return Success */
+ return ERROR_SUCCESS;
+}
+
+INT
+WINAPI
+SaBlob_WriteAddress(IN PDNS_BLOB Blob,
+ OUT PDNS_ADDRESS DnsAddr)
+{
+ /* Check if we have an array yet */
+ if (!Blob->DnsAddrArray)
+ {
+ /* Allocate one! */
+ Blob->DnsAddrArray = DnsAddrArray_Create(1);
+ if (!Blob->DnsAddrArray) return ERROR_OUTOFMEMORY;
+ }
+
+ /* Add this address */
+ return DnsAddrArray_AddAddr(Blob->DnsAddrArray, DnsAddr, AF_UNSPEC, 0) ?
+ ERROR_SUCCESS:
+ ERROR_MORE_DATA;
+}
+
+BOOLEAN
+WINAPI
+SaBlob_IsSupportedAddrType(WORD DnsType)
+{
+ /* Check for valid Types that we support */
+ return (DnsType == DNS_TYPE_A ||
+ DnsType == DNS_TYPE_ATMA ||
+ DnsType == DNS_TYPE_AAAA);
+}
+
+INT
+WINAPI
+SaBlob_WriteRecords(OUT PDNS_BLOB Blob,
+ IN PDNS_RECORD DnsRecord,
+ IN BOOLEAN DoAlias)
+{
+ DNS_ADDRESS DnsAddress;
+ INT ErrorCode = STATUS_INVALID_PARAMETER;
+ BOOLEAN WroteOnce = FALSE;
+
+ /* Zero out the Address */
+ RtlZeroMemory(&DnsAddress, sizeof(DnsAddress));
+
+ /* Loop through all the Records */
+ while (DnsRecord)
+ {
+ /* Is this not an answer? */
+ if (DnsRecord->Flags.S.Section != DNSREC_ANSWER)
+ {
+ /* Then simply move on to the next DNS Record */
+ DnsRecord = DnsRecord->pNext;
+ continue;
+ }
+
+ /* Check the type of thsi record */
+ switch(DnsRecord->wType)
+ {
+ /* Regular IPv4, v6 or ATM Record */
+ case DNS_TYPE_A:
+ case DNS_TYPE_AAAA:
+ case DNS_TYPE_ATMA:
+
+ /* Create a DNS Address from the record */
+ DnsAddr_BuildFromDnsRecord(DnsRecord, &DnsAddress);
+
+ /* Add it to the DNS Blob */
+ ErrorCode = SaBlob_WriteAddress(Blob, &DnsAddress);
+
+ /* Add the name, if needed */
+ if ((DoAlias) &&
+ (!WroteOnce) &&
+ (!Blob->Name) &&
+ (DnsRecord->pName))
+ {
+ /* Write the name from the DNS Record */
+ ErrorCode = SaBlob_WriteNameOrAlias(Blob,
+ DnsRecord->pName,
+ FALSE);
+ WroteOnce = TRUE;
+ }
+ break;
+
+ case DNS_TYPE_CNAME:
+
+ /* Just write the alias name */
+ ErrorCode = SaBlob_WriteNameOrAlias(Blob,
+ DnsRecord->pName,
+ TRUE);
+ break;
+
+ case DNS_TYPE_PTR:
+
+ /* Check if we already have a name */
+ if (Blob->Name)
+ {
+ /* We don't, so add this as a name */
+ ErrorCode = SaBlob_WriteNameOrAlias(Blob,
+ DnsRecord->pName,
+ FALSE);
+ }
+ else
+ {
+ /* We do, so add it as an alias */
+ ErrorCode = SaBlob_WriteNameOrAlias(Blob,
+ DnsRecord->pName,
+ TRUE);
+ }
+ break;
+ default:
+ break;
+ }
+
+ /* Next record */
+ DnsRecord = DnsRecord->pNext;
+ }
+
+ /* Return error code */
+ return ErrorCode;
+}
+
+PDNS_BLOB
+WINAPI
+SaBlob_CreateFromRecords(IN PDNS_RECORD DnsRecord,
+ IN BOOLEAN DoAliases,
+ IN DWORD DnsType)
+{
+ PDNS_RECORD LocalDnsRecord;
+ ULONG ProcessedCount = 0;
+ PDNS_BLOB DnsBlob;
+ INT ErrorCode;
+ DNS_ADDRESS DnsAddress;
+
+ /* Find out how many DNS Addresses to allocate */
+ LocalDnsRecord = DnsRecord;
+ while (LocalDnsRecord)
+ {
+ /* Make sure this record is an answer */
+ if ((LocalDnsRecord->Flags.S.Section == DNSREC_ANSWER) &&
+ (SaBlob_IsSupportedAddrType(LocalDnsRecord->wType)))
+ {
+ /* Increase number of records to process */
+ ProcessedCount++;
+ }
+
+ /* Move to the next record */
+ LocalDnsRecord = LocalDnsRecord->pNext;
+ }
+
+ /* Create the DNS Blob */
+ DnsBlob = SaBlob_Create(ProcessedCount);
+ if (!DnsBlob)
+ {
+ /* Fail */
+ ErrorCode = GetLastError();
+ goto Quickie;
+ }
+
+ /* Write the record to the DNS Blob */
+ ErrorCode = SaBlob_WriteRecords(DnsBlob, DnsRecord, TRUE);
+ if (ErrorCode != NO_ERROR)
+ {
+ /* We failed... but do we still have valid data? */
+ if ((DnsBlob->Name) || (DnsBlob->AliasCount))
+ {
+ /* We'll just assume success then */
+ ErrorCode = NO_ERROR;
+ }
+ else
+ {
+ /* Ok, last chance..do you have a DNS Address Array? */
+ if ((DnsBlob->DnsAddrArray) &&
+ (DnsBlob->DnsAddrArray->UsedAddresses))
+ {
+ /* Boy are you lucky! */
+ ErrorCode = NO_ERROR;
+ }
+ }
+
+ /* Buh-bye! */
+ goto Quickie;
+ }
+
+ /* Check if this is a PTR record */
+ if ((DnsRecord->wType == DNS_TYPE_PTR) ||
+ ((DnsType == DNS_TYPE_PTR) &&
+ (DnsRecord->wType == DNS_TYPE_CNAME) &&
+ (DnsRecord->Flags.S.Section == DNSREC_ANSWER)))
+ {
+ /* Get a DNS Address Structure */
+ if (Dns_ReverseNameToDnsAddr_W(&DnsAddress, DnsRecord->pName))
+ {
+ /* Add it to the Blob */
+ if (SaBlob_WriteAddress(DnsBlob, &DnsAddress)) ErrorCode = NO_ERROR;
+ }
+ }
+
+ /* Ok...do we still not have a name? */
+ if (!(DnsBlob->Name) && (DoAliases) && (LocalDnsRecord))
+ {
+ /* We have an local DNS Record, so just use it to write the name */
+ ErrorCode = SaBlob_WriteNameOrAlias(DnsBlob,
+ LocalDnsRecord->pName,
+ FALSE);
+ }
+
+Quickie:
+ /* Check error code */
+ if (ErrorCode != NO_ERROR)
+ {
+ /* Free the blob and set the error */
+ SaBlob_Free(DnsBlob);
+ DnsBlob = NULL;
+ SetLastError(ErrorCode);
+ }
+
+ /* Return */
+ return DnsBlob;
+}
+
+PDNS_BLOB
+WINAPI
+SaBlob_Query(IN LPWSTR Name,
+ IN WORD DnsType,
+ IN ULONG Flags,
+ IN PVOID *Reserved,
+ IN DWORD AddressFamily)
+{
+ PDNS_RECORD DnsRecord = NULL;
+ INT ErrorCode;
+ PDNS_BLOB DnsBlob = NULL;
+ LPWSTR LocalName, LocalNameCopy;
+
+ /* If they want reserved data back, clear it out in case we fail */
+ if (Reserved) *Reserved = NULL;
+
+ /* Query DNS */
+ ErrorCode = DnsQuery_W(Name,
+ DnsType,
+ Flags,
+ NULL,
+ &DnsRecord,
+ Reserved);
+ if (ErrorCode != ERROR_SUCCESS)
+ {
+ /* We failed... did the caller use reserved data? */
+ if (Reserved && *Reserved)
+ {
+ /* He did, and it was valid. Free it */
+ DnsApiFree(*Reserved);
+ *Reserved = NULL;
+ }
+
+ /* Normalize error code */
+ if (ErrorCode == RPC_S_SERVER_UNAVAILABLE) ErrorCode = WSATRY_AGAIN;
+ goto Quickie;
+ }
+
+ /* Now create the Blob from the DNS Records */
+ DnsBlob = SaBlob_CreateFromRecords(DnsRecord, TRUE, DnsType);
+ if (!DnsBlob)
+ {
+ /* Failed, get error code */
+ ErrorCode = GetLastError();
+ goto Quickie;
+ }
+
+ /* Make sure it has a name */
+ if (!DnsBlob->Name)
+ {
+ /* It doesn't, fail */
+ ErrorCode = DNS_INFO_NO_RECORDS;
+ goto Quickie;
+ }
+
+ /* Check if the name is local or loopback */
+ if (!(DnsNameCompare_W(DnsBlob->Name, L"localhost")) &&
+ !(DnsNameCompare_W(DnsBlob->Name, L"loopback")))
+ {
+ /* Nothing left to do, exit! */
+ goto Quickie;
+ }
+
+ /* This is a local name...query it */
+ LocalName = DnsQueryConfigAllocEx(DnsConfigFullHostName_W, NULL, NULL);
+ if (LocalName)
+ {
+ /* Create a copy for the caller */
+ LocalNameCopy = Dns_CreateStringCopy_W(LocalName);
+ if (LocalNameCopy)
+ {
+ /* Overwrite the one in the blob */
+ DnsBlob->Name = LocalNameCopy;
+ }
+ else
+ {
+ /* We failed to make a copy, free memory */
+ DnsApiFree(LocalName);
+ }
+ }
+
+Quickie:
+ /* Free the DNS Record if we have one */
+ if (DnsRecord) DnsRecordListFree(DnsRecord, DnsFreeRecordList);
+
+ /* Check if this is a failure path with an active blob */
+ if ((ErrorCode != ERROR_SUCCESS) && (DnsBlob))
+ {
+ /* Free the blob */
+ SaBlob_Free(DnsBlob);
+ DnsBlob = NULL;
+ }
+
+ /* Set the last error and return */
+ SetLastError(ErrorCode);
+ return DnsBlob;
+}
+
projects / reactos.git / commitdiff