dnslib.h File Reference

#include <ws2atm.h>

Include dependency graph for dnslib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_DNS_IPV6_ADDRESS
struct	_DNS_ADDRESS
struct	_DNS_ARRAY
struct	_DNS_BLOB
struct	_DNS_FAMILY_INFO
struct	_FLATBUFF

Macros
#define	IpV4Address   3

Typedefs
typedef enum _DNS_STRING_TYPE	DNS_STRING_TYPE
typedef struct _DNS_IPV6_ADDRESS	DNS_IPV6_ADDRESS
typedef struct _DNS_IPV6_ADDRESS *	PDNS_IPV6_ADDRESS
typedef struct _DNS_ADDRESS	DNS_ADDRESS
typedef struct _DNS_ADDRESS *	PDNS_ADDRESS
typedef struct _DNS_ARRAY	DNS_ARRAY
typedef struct _DNS_ARRAY *	PDNS_ARRAY
typedef struct _DNS_BLOB	DNS_BLOB
typedef struct _DNS_BLOB *	PDNS_BLOB
typedef struct _DNS_FAMILY_INFO	DNS_FAMILY_INFO
typedef struct _DNS_FAMILY_INFO *	PDNS_FAMILY_INFO
typedef struct _FLATBUFF	FLATBUFF
typedef struct _FLATBUFF *	PFLATBUFF

Enumerations
enum	_DNS_STRING_TYPE { UnicodeString = 1 , Utf8String , AnsiString }

Functions
VOID WINAPI	Dns_Free (IN PVOID Address)
PVOID WINAPI	Dns_AllocZero (IN SIZE_T Size)
PDNS_FAMILY_INFO WINAPI	FamilyInfo_GetForFamily (IN WORD AddressFamily)
VOID WINAPI	DnsAddr_BuildFromIp4 (IN PDNS_ADDRESS DnsAddress, IN IN_ADDR Address, IN WORD Unknown)
VOID WINAPI	DnsAddr_BuildFromIp6 (IN PDNS_ADDRESS DnsAddress, IN PIN6_ADDR Address, IN ULONG ScopeId, IN WORD Port)
PDNS_ARRAY WINAPI	DnsAddrArray_Create (ULONG Count)
BOOL WINAPI	DnsAddrArray_AddAddr (IN PDNS_ARRAY DnsAddrArray, IN PDNS_ADDRESS DnsAddress, IN WORD AddressFamily OPTIONAL, IN DWORD AddressType OPTIONAL)
VOID WINAPI	DnsAddrArray_Free (IN PDNS_ARRAY DnsAddrArray)
BOOL WINAPI	DnsAddrArray_AddIp4 (IN PDNS_ARRAY DnsAddrArray, IN IN_ADDR Address, IN DWORD AddressType)
BOOL WINAPI	DnsAddrArray_ContainsAddr (IN PDNS_ARRAY DnsAddrArray, IN PDNS_ADDRESS DnsAddress, IN DWORD AddressType)
BOOLEAN WINAPI	DnsAddr_BuildFromDnsRecord (IN PDNS_RECORD DnsRecord, OUT PDNS_ADDRESS DnsAddr)
PHOSTENT WINAPI	Hostent_Init (IN PVOID *Buffer, IN WORD AddressFamily, IN ULONG AddressSize, IN ULONG AddressCount, IN ULONG AliasCount)
VOID WINAPI	Hostent_ConvertToOffsets (IN PHOSTENT Hostent)
VOID WINAPI	FlatBuf_Init (IN PFLATBUFF FlatBuffer, IN PVOID Buffer, IN SIZE_T Size)
PVOID WINAPI	FlatBuf_Arg_CopyMemory (IN OUT PULONG_PTR Position, IN OUT PSIZE_T FreeSize, IN PVOID Buffer, IN SIZE_T Size, IN ULONG Align)
PVOID WINAPI	FlatBuf_Arg_Reserve (IN OUT PULONG_PTR Position, IN OUT PSIZE_T FreeSize, IN SIZE_T Size, IN ULONG Align)
PVOID WINAPI	FlatBuf_Arg_WriteString (IN OUT PULONG_PTR Position, IN OUT PSIZE_T FreeSize, IN PVOID String, IN BOOLEAN IsUnicode)
PDNS_BLOB WINAPI	SaBlob_Create (IN ULONG Count)
PDNS_BLOB WINAPI	SaBlob_CreateFromIp4 (IN LPWSTR Name, IN ULONG Count, IN PIN_ADDR AddressArray)
VOID WINAPI	SaBlob_Free (IN PDNS_BLOB Blob)
PHOSTENT WINAPI	SaBlob_CreateHostent (IN OUT PULONG_PTR BufferPosition, IN OUT PSIZE_T RemainingBufferSpace, IN OUT PSIZE_T HostEntrySize, IN PDNS_BLOB Blob, IN DWORD StringType, IN BOOLEAN Relative, IN BOOLEAN BufferAllocated)
INT WINAPI	SaBlob_WriteNameOrAlias (IN PDNS_BLOB Blob, IN LPWSTR String, IN BOOLEAN IsAlias)
PDNS_BLOB WINAPI	SaBlob_Query (IN LPWSTR Name, IN WORD DnsType, IN ULONG Flags, IN PVOID *Reserved, IN DWORD AddressFamily)
ULONG WINAPI	Dns_StringCopy (OUT PVOID Destination, IN OUT PULONG DestinationSize, IN PVOID String, IN ULONG StringSize OPTIONAL, IN DWORD InputType, IN DWORD OutputType)
LPWSTR WINAPI	Dns_CreateStringCopy_W (IN LPWSTR Name)
ULONG WINAPI	Dns_GetBufferLengthForStringCopy (IN PVOID String, IN ULONG Size OPTIONAL, IN DWORD InputType, IN DWORD OutputType)
BOOLEAN WINAPI	Dns_StringToAddressW (OUT PVOID Address, IN OUT PULONG AddressSize, IN LPWSTR AddressName, IN OUT PDWORD AddressFamily)
LPWSTR WINAPI	Dns_Ip4AddressToReverseName_W (OUT LPWSTR Name, IN IN_ADDR Address)
LPWSTR WINAPI	Dns_Ip6AddressToReverseName_W (OUT LPWSTR Name, IN IN6_ADDR Address)
BOOLEAN WINAPI	Dns_ReverseNameToDnsAddr_W (OUT PDNS_ADDRESS DnsAddr, IN LPWSTR Name)
BOOLEAN WINAPI	Dns_Ip4ReverseNameToAddress_W (OUT PIN_ADDR Address, IN LPWSTR Name)

Macro Definition Documentation

IpV4Address

#define IpV4Address   3

Definition at line 22 of file dnslib.h.

Typedef Documentation

DNS_ADDRESS

typedef struct _DNS_ADDRESS DNS_ADDRESS

DNS_ARRAY

typedef struct _DNS_ARRAY DNS_ARRAY

DNS_BLOB

typedef struct _DNS_BLOB DNS_BLOB

DNS_FAMILY_INFO

typedef struct _DNS_FAMILY_INFO DNS_FAMILY_INFO

DNS_IPV6_ADDRESS

typedef struct _DNS_IPV6_ADDRESS DNS_IPV6_ADDRESS

DNS_STRING_TYPE

typedef enum _DNS_STRING_TYPE DNS_STRING_TYPE

FLATBUFF

typedef struct _FLATBUFF FLATBUFF

PDNS_ADDRESS

typedef struct _DNS_ADDRESS * PDNS_ADDRESS

PDNS_ARRAY

typedef struct _DNS_ARRAY * PDNS_ARRAY

PDNS_BLOB

typedef struct _DNS_BLOB * PDNS_BLOB

PDNS_FAMILY_INFO

typedef struct _DNS_FAMILY_INFO * PDNS_FAMILY_INFO

PDNS_IPV6_ADDRESS

typedef struct _DNS_IPV6_ADDRESS * PDNS_IPV6_ADDRESS

PFLATBUFF

typedef struct _FLATBUFF * PFLATBUFF

Enumeration Type Documentation

_DNS_STRING_TYPE

enum _DNS_STRING_TYPE

Enumerator
UnicodeString
Utf8String
AnsiString

Definition at line 15 of file dnslib.h.

{
    UnicodeString = 1,
    Utf8String,
    AnsiString,
} DNS_STRING_TYPE;

Function Documentation

Dns_AllocZero()

PVOID WINAPI Dns_AllocZero

(

IN SIZE_T

Size

)

Definition at line 42 of file memory.c.

{
    PVOID Buffer;
 
    /* Check if whoever imported us specified a special allocation function */
    if (pDnsAllocFunction)
    {
        /* Use it to allocate the memory */
        Buffer = pDnsAllocFunction(Size);
        if (Buffer)
        {
            /* Zero it out */
            RtlZeroMemory(Buffer, Size);
        }
    }
    else
    {
        /* Use our default */
        Buffer = LocalAlloc(LMEM_ZEROINIT, Size);
    }
 
    /* Return the allocate pointer */
    return Buffer;
}

Referenced by Dns_CreateStringCopy_W(), DnsAddrArray_Create(), SaBlob_Create(), and SaBlob_CreateHostent().

Dns_CreateStringCopy_W()

LPWSTR WINAPI Dns_CreateStringCopy_W

(

IN LPWSTR

Name

)

Definition at line 141 of file string.c.

{
    SIZE_T StringLength;
    LPWSTR NameCopy;
 
    /* Make sure that we have a name */
    if (!Name)
    {
        /* Fail */
        SetLastError(ERROR_INVALID_PARAMETER);
        return NULL;
    }
 
    /* Find out the size of the string */
    StringLength = (wcslen(Name) + 1) * sizeof(WCHAR);
 
    /* Allocate space for the copy */
    NameCopy = Dns_AllocZero(StringLength);
    if (NameCopy)
    {
        /* Copy it */
        RtlCopyMemory(NameCopy, Name, StringLength);
    }
    else
    {
        /* Fail */
        SetLastError(ERROR_NOT_ENOUGH_MEMORY);
    }
 
    /* Return the copy */
    return NameCopy;
}

Referenced by SaBlob_CreateFromIp4(), SaBlob_Query(), and SaBlob_WriteNameOrAlias().

Dns_Free()

VOID WINAPI Dns_Free

(

IN PVOID

Address

)

Definition at line 25 of file memory.c.

{
    /* Check if whoever imported us specified a special free function */
    if (pDnsFreeFunction)
    {
        /* Use it */
        pDnsFreeFunction(Address);
    }
    else
    {
        /* Use our own */
        LocalFree(Address);
    }
}

Referenced by DnsAddrArray_Free(), and SaBlob_Free().

Dns_GetBufferLengthForStringCopy()

ULONG WINAPI Dns_GetBufferLengthForStringCopy	(	IN PVOID	String,
		IN ULONG Size	OPTIONAL,
		IN DWORD	InputType,
		IN DWORD	OutputType
	)

Definition at line 176 of file string.c.

{
    ULONG OutputSize = 0;
 
    /* Check what kind of string this is */
    if (InputType == UnicodeString)
    {
        /* Check if we have a size */
        if (!Size)
        {
            /* Get it ourselves */
            Size = (ULONG)wcslen(String);
        }
 
        /* Check the output type */
        if (OutputType == UnicodeString)
        {
            /* Convert the size to bytes */
            OutputSize = (Size + 1) * sizeof(WCHAR);
        }
        else if (OutputType == Utf8String)
        {
            /* FIXME */
            OutputSize = 0;
        }
        else
        {
            /* Find out how much it will be in ANSI bytes */
            OutputSize = WideCharToMultiByte(CP_ACP,
                                             0,
                                             String,
                                             Size,
                                             NULL,
                                             0,
                                             NULL,
                                             NULL) + 1;
        }
    }
    else if (InputType == AnsiString)
    {
        /* Check if we have a size */
        if (!Size)
        {
            /* Get it ourselves */
            Size = (ULONG)strlen(String);
        }
 
        /* Check the output type */
        if (OutputType == AnsiString)
        {
            /* Just add a byte for the null char */
            OutputSize = Size + 1;
        }
        else if (OutputType == UnicodeString)
        {
            /* Calculate the bytes for a Unicode string */
            OutputSize = (MultiByteToWideChar(CP_ACP,
                                              0,
                                              String,
                                              Size,
                                              NULL,
                                              0) + 1) * sizeof(WCHAR);
        }
        else if (OutputType == Utf8String)
        {
            /* FIXME */
            OutputSize = 0;
        }
    }
    else if (InputType == Utf8String)
    {
        /* FIXME */
        OutputSize = 0;
    }
 
    /* Return the size required */
    return OutputSize;
}

Referenced by Dns_StringCopy(), and SaBlob_CreateHostent().

Dns_Ip4AddressToReverseName_W()

LPWSTR WINAPI Dns_Ip4AddressToReverseName_W	(	OUT LPWSTR	Name,
		IN IN_ADDR	Address
	)

Definition at line 26 of file straddr.c.

{
    /* Simply append the ARPA string */
    return Name + (wsprintfW(Name,
                             L"%u.%u.%u.%u.in-addr.arpa.",
                             Address.S_un.S_addr >> 24,
                             Address.S_un.S_addr >> 10,
                             Address.S_un.S_addr >> 8,
                             Address.S_un.S_addr) * sizeof(WCHAR));
}

Dns_Ip4ReverseNameToAddress_W()

BOOLEAN WINAPI Dns_Ip4ReverseNameToAddress_W	(	OUT PIN_ADDR	Address,
		IN LPWSTR	Name
	)

Definition at line 136 of file straddr.c.

{
    CHAR AnsiName[32];
    ULONG Size = sizeof(AnsiName);
    INT ErrorCode;
 
    /* Make a copy of the name in ANSI */
    ErrorCode = Dns_StringCopy(&AnsiName,
                               &Size,
                               Name,
                               0,
                               UnicodeString,
                               AnsiString);
    if (ErrorCode)
    {
        /* Copy made sucesfully, now convert it */
        ErrorCode = Dns_Ip4ReverseNameToAddress_A(Address, AnsiName);
    }
 
    /* Return either 0 bytes copied (failure == false) or conversion status */
    return ErrorCode;
}

Dns_Ip6AddressToReverseName_W()

LPWSTR WINAPI Dns_Ip6AddressToReverseName_W	(	OUT LPWSTR	Name,
		IN IN6_ADDR	Address
	)

Definition at line 17 of file straddr.c.

{
    /* FIXME */
    return NULL;
}

Dns_ReverseNameToDnsAddr_W()

BOOLEAN WINAPI Dns_ReverseNameToDnsAddr_W	(	OUT PDNS_ADDRESS	DnsAddr,
		IN LPWSTR	Name
	)

Definition at line 452 of file straddr.c.

{
    /* Call the common API */
    return Dns_StringToDnsAddrEx(DnsAddr,
                                 Name,
                                 AF_UNSPEC,
                                 TRUE,
                                 TRUE);
}

Referenced by SaBlob_CreateFromRecords().

Dns_StringCopy()

ULONG WINAPI Dns_StringCopy	(	OUT PVOID	Destination,
		IN OUT PULONG	DestinationSize,
		IN PVOID	String,
		IN ULONG StringSize	OPTIONAL,
		IN DWORD	InputType,
		IN DWORD	OutputType
	)

Definition at line 17 of file string.c.

{
    ULONG DestSize;
    ULONG OutputSize = 0;
 
    /* Check if the caller already gave us the string size */
    if (!StringSize)
    {
        /* He didn't, get the input type */
        if (InputType == UnicodeString)
        {
            /* Unicode string, calculate the size */
            StringSize = (ULONG)wcslen((LPWSTR)String);
        }
        else
        {
            /* ANSI or UTF-8 sting, get the size */
            StringSize = (ULONG)strlen((LPSTR)String);
        }
    }
 
    /* Check if we have a limit on the desination size */
    if (DestinationSize)
    {
        /* Make sure that we can respect it */
        DestSize = Dns_GetBufferLengthForStringCopy(String,
                                                    StringSize,
                                                    InputType,
                                                    OutputType);
        if (*DestinationSize < DestSize)
        {
            /* Fail due to missing buffer space */
            SetLastError(ERROR_MORE_DATA);
 
            /* Return how much data we actually need */
            *DestinationSize = DestSize;
            return 0;
        }
        else if (!DestSize)
        {
            /* Fail due to invalid data */
            SetLastError(ERROR_INVALID_DATA);
            return 0;
        }
 
        /* Return how much data we actually need */
        *DestinationSize = DestSize;
    }
 
    /* Now check if this is a Unicode String as input */
    if (InputType == UnicodeString)
    {
        /* Check if the output is ANSI */
        if (OutputType == AnsiString)
        {
            /* Convert and return the final desination size */
            OutputSize = WideCharToMultiByte(CP_ACP,
                                             0,
                                             String,
                                             StringSize,
                                             Destination,
                                             -1,
                                             NULL,
                                             NULL) + 1;
        }
        else if (OutputType == UnicodeString)
        {
            /* Copy the string */
            StringSize = StringSize * sizeof(WCHAR);
            RtlMoveMemory(Destination, String, StringSize);
 
            /* Return output length */
            OutputSize = StringSize + 2;
        }
        else if (OutputType == Utf8String)
        {
            /* FIXME */
            OutputSize = 0;
        }
    }
    else if (InputType == AnsiString)
    {
        /* It's ANSI, is the output ansi too? */
        if (OutputType == AnsiString)
        {
            /* Copy the string */
            RtlMoveMemory(Destination, String, StringSize);
 
            /* Return output length */
            OutputSize = StringSize + 1;
        }
        else if (OutputType == UnicodeString)
        {
            /* Convert to Unicode and return size */
            OutputSize = MultiByteToWideChar(CP_ACP,
                                             0,
                                             String,
                                             StringSize,
                                             Destination,
                                             -1) * sizeof(WCHAR) + 2;
        }
        else if (OutputType == Utf8String)
        {
            /* FIXME */
            OutputSize = 0;
        }
    }
    else if (InputType == Utf8String)
    {
        /* FIXME */
        OutputSize = 0;
    }
 
    /* Return the output size */
    return OutputSize;
}

Referenced by Dns_Ip4ReverseNameToAddress_W(), Dns_Ip4StringToAddress_W(), Dns_StringToAddressEx(), Dns_StringToDnsAddrEx(), and SaBlob_CreateHostent().

Dns_StringToAddressW()

BOOLEAN WINAPI Dns_StringToAddressW	(	OUT PVOID	Address,
		IN OUT PULONG	AddressSize,
		IN LPWSTR	AddressName,
		IN OUT PDWORD	AddressFamily
	)

Definition at line 303 of file straddr.c.

{
    /* Call the common API */
    return Dns_StringToAddressEx(Address,
                                 AddressSize,
                                 AddressName,
                                 AddressFamily,
                                 TRUE,
                                 FALSE);
}

DnsAddr_BuildFromDnsRecord()

BOOLEAN WINAPI DnsAddr_BuildFromDnsRecord	(	IN PDNS_RECORD	DnsRecord,
		OUT PDNS_ADDRESS	DnsAddr
	)

Definition at line 155 of file dnsaddr.c.

{
    /* Check what kind of record this is */
    switch(DnsRecord->wType)
    {
        /* IPv4 */
        case DNS_TYPE_A:
            /* Create the DNS Address */
            DnsAddr_BuildFromIp4(DnsAddr,
                                 *(PIN_ADDR)&DnsRecord->Data.A.IpAddress,
                                 0);
            break;
 
        /* IPv6 */
        case DNS_TYPE_AAAA:
            /* Create the DNS Address */
            DnsAddr_BuildFromIp6(DnsAddr,
                                 (PIN6_ADDR)&DnsRecord->Data.AAAA.Ip6Address,
                                 DnsRecord->dwReserved,
                                 0);
            break;
 
        /* ATM */
        case DNS_TYPE_ATMA:
            /* Create the DNS Address */
            DnsAddr_BuildFromAtm(DnsAddr,
                                 DnsRecord->Data.Atma.AddressType,
                                 &DnsRecord->Data.Atma.Address);
            break;
    }
 
    /* Done! */
    return TRUE;
}

Referenced by SaBlob_WriteRecords().

DnsAddr_BuildFromIp4()

VOID WINAPI DnsAddr_BuildFromIp4	(	IN PDNS_ADDRESS	DnsAddress,
		IN IN_ADDR	Address,
		IN WORD	Unknown
	)

Definition at line 100 of file dnsaddr.c.

{
    /* Clear the address */
    RtlZeroMemory(DnsAddress, sizeof(DNS_ADDRESS));
 
    /* Write data */
    DnsAddress->Ip4Address.sin_family = AF_INET;
    DnsAddress->Ip4Address.sin_port  = Port;
    DnsAddress->Ip4Address.sin_addr = Address;
    DnsAddress->AddressLength = sizeof(SOCKADDR_IN);
}

Referenced by Dns_StringToDnsAddrEx(), DnsAddr_BuildFromDnsRecord(), and DnsAddrArray_AddIp4().

DnsAddr_BuildFromIp6()

VOID WINAPI DnsAddr_BuildFromIp6	(	IN PDNS_ADDRESS	DnsAddress,
		IN PIN6_ADDR	Address,
		IN ULONG	ScopeId,
		IN WORD	Port
	)

Definition at line 116 of file dnsaddr.c.

{
    /* Clear the address */
    RtlZeroMemory(DnsAddress, sizeof(DNS_ADDRESS));
 
    /* Write data */
    DnsAddress->Ip6Address.sin6_family = AF_INET6;
    DnsAddress->Ip6Address.sin6_port  = Port;
    DnsAddress->Ip6Address.sin6_addr = *Address;
    DnsAddress->Ip6Address.sin6_scope_id = ScopeId;
    DnsAddress->AddressLength = sizeof(SOCKADDR_IN6);
}

Referenced by Dns_StringToDnsAddrEx(), and DnsAddr_BuildFromDnsRecord().

DnsAddrArray_AddAddr()

BOOL WINAPI DnsAddrArray_AddAddr	(	IN PDNS_ARRAY	DnsAddrArray,
		IN PDNS_ADDRESS	DnsAddress,
		IN WORD AddressFamily	OPTIONAL,
		IN DWORD AddressType	OPTIONAL
	)

Definition at line 57 of file dnsaddr.c.

{
    /* Make sure we have an array */
    if (!DnsAddrArray) return FALSE;
 
    /* Check if we should validate the Address Family */
    if (AddressFamily)
    {
        /* Validate it */
        if (AddressFamily != DnsAddress->AddressFamily) return TRUE;
    }
 
    /* Check if we should validate the Address Type */
    if (AddressType)
    {
        /* Make sure that this array contains this type of addresses */
        if (!DnsAddrArray_ContainsAddr(DnsAddrArray, DnsAddress, AddressType))
        {
            /* Won't be adding it */
            return TRUE;
        }
    }
 
    /* Make sure we have space in the array */
    if (DnsAddrArray->AllocatedAddresses < DnsAddrArray->UsedAddresses)
    {
        return FALSE;
    }
 
    /* Now add the address */
    RtlCopyMemory(&DnsAddrArray->Addresses[DnsAddrArray->UsedAddresses],
                  DnsAddress,
                  sizeof(DNS_ADDRESS));
 
    /* Return success */
    return TRUE;
}

Referenced by DnsAddrArray_AddIp4(), and SaBlob_WriteAddress().

DnsAddrArray_AddIp4()

BOOL WINAPI DnsAddrArray_AddIp4	(	IN PDNS_ARRAY	DnsAddrArray,
		IN IN_ADDR	Address,
		IN DWORD	AddressType
	)

Definition at line 42 of file dnsaddr.c.

{
    DNS_ADDRESS DnsAddress;
 
    /* Build the DNS Address */
    DnsAddr_BuildFromIp4(&DnsAddress, Address, 0);
 
    /* Add it to the array */
    return DnsAddrArray_AddAddr(DnsAddrArray, &DnsAddress, 0, AddressType);
}

Referenced by SaBlob_CreateFromIp4().

DnsAddrArray_ContainsAddr()

BOOL WINAPI DnsAddrArray_ContainsAddr	(	IN PDNS_ARRAY	DnsAddrArray,
		IN PDNS_ADDRESS	DnsAddress,
		IN DWORD	AddressType
	)

Definition at line 193 of file dnsaddr.c.

{
    /* FIXME */
    return TRUE;
}

Referenced by DnsAddrArray_AddAddr().

DnsAddrArray_Create()

PDNS_ARRAY WINAPI DnsAddrArray_Create

(

ULONG

Count

)

Definition at line 17 of file dnsaddr.c.

{
    PDNS_ARRAY DnsAddrArray;
 
    /* Allocate space for the array and the addresses within it */
    DnsAddrArray = Dns_AllocZero(sizeof(DNS_ARRAY) +
                                 (Count * sizeof(DNS_ADDRESS)));
 
    /* Write the allocated address count */
    if (DnsAddrArray) DnsAddrArray->AllocatedAddresses = Count;
 
    /* Return it */
    return DnsAddrArray;
}

Referenced by SaBlob_Create(), and SaBlob_WriteAddress().

DnsAddrArray_Free()

VOID WINAPI DnsAddrArray_Free

(

IN PDNS_ARRAY

DnsAddrArray

)

Definition at line 34 of file dnsaddr.c.

{
    /* Just free the entire array */
    Dns_Free(DnsAddrArray);
}

Referenced by SaBlob_Free().

FamilyInfo_GetForFamily()

PDNS_FAMILY_INFO WINAPI FamilyInfo_GetForFamily

(

IN WORD

AddressFamily

)

Definition at line 42 of file addr.c.

{
    /* Check which family this is */
    switch (AddressFamily)
    {
        case AF_INET:
            /* Return IPv4 Family Info */
            return &AddrFamilyTable[0];
 
        case AF_INET6:
            /* Return IPv6 Family Info */
            return &AddrFamilyTable[1];
 
        case AF_ATM:
            /* Return ATM Family Info */
            return &AddrFamilyTable[2];
 
        default:
            /* Invalid family */
            return NULL;
    }
 
}

Referenced by SaBlob_CreateHostent().

FlatBuf_Arg_CopyMemory()

PVOID WINAPI FlatBuf_Arg_CopyMemory	(	IN OUT PULONG_PTR	Position,
		IN OUT PSIZE_T	FreeSize,
		IN PVOID	Buffer,
		IN SIZE_T	Size,
		IN ULONG	Align
	)

Definition at line 60 of file flatbuf.c.

{
    PVOID Destination;
 
    /* First reserve the memory */
    Destination = FlatBuf_Arg_Reserve(Position, FreeSize, Size, Align);
    if (Destination)
    {
        /* We have space, do the copy */
        RtlCopyMemory(Destination, Buffer, Size);
    }
 
    /* Return the pointer to the data */
    return Destination;
}

FlatBuf_Arg_Reserve()

PVOID WINAPI FlatBuf_Arg_Reserve	(	IN OUT PULONG_PTR	Position,
		IN OUT PSIZE_T	FreeSize,
		IN SIZE_T	Size,
		IN ULONG	Align
	)

Definition at line 32 of file flatbuf.c.

{
    ULONG_PTR NewPosition, OldPosition = *Position;
    SIZE_T NewFreeSize = *FreeSize;
 
    /* Start by aligning our position */
    if (Align) OldPosition += (Align - 1) & ~Align;
 
    /* Update it */
    NewPosition = OldPosition + Size;
 
    /* Update Free Size */
    NewFreeSize += (OldPosition - NewPosition);
 
    /* Save new values */
    *Position = NewPosition;
    *FreeSize = NewFreeSize;
 
    /* Check if we're out of space or not */
    if (NewFreeSize > 0) return (PVOID)OldPosition;
    return NULL;
}

Referenced by FlatBuf_Arg_CopyMemory(), FlatBuf_Arg_ReserveAlignPointer(), and FlatBuf_Arg_WriteString().

FlatBuf_Arg_WriteString()

PVOID WINAPI FlatBuf_Arg_WriteString	(	IN OUT PULONG_PTR	Position,
		IN OUT PSIZE_T	FreeSize,
		IN PVOID	String,
		IN BOOLEAN	IsUnicode
	)

Definition at line 82 of file flatbuf.c.

{
    PVOID Destination;
    SIZE_T StringLength;
    ULONG Align;
 
    /* Calculate the string length */
    if (IsUnicode)
    {
        /* Get the length in bytes and use WCHAR alignment */
        StringLength = (wcslen((LPWSTR)String) + 1) * sizeof(WCHAR);
        Align = sizeof(WCHAR);
    }
    else
    {
        /* Get the length in bytes and use CHAR alignment */
        StringLength = strlen((LPSTR)String) + 1;
        Align = sizeof(CHAR);
    }
 
    /* Now reserve the memory */
    Destination = FlatBuf_Arg_Reserve(Position, FreeSize, StringLength, Align);
    if (Destination)
    {
        /* We have space, do the copy */
        RtlCopyMemory(Destination, String, StringLength);
    }
 
    /* Return the pointer to the data */
    return Destination;
}

FlatBuf_Init()

VOID WINAPI FlatBuf_Init	(	IN PFLATBUFF	FlatBuffer,
		IN PVOID	Buffer,
		IN SIZE_T	Size
	)

Definition at line 17 of file flatbuf.c.

{
    /* Set up the Flat Buffer start, current and ending position */
    FlatBuffer->Buffer = Buffer;
    FlatBuffer->BufferPos = (ULONG_PTR)Buffer;
    FlatBuffer->BufferEnd = (PVOID)(FlatBuffer->BufferPos + Size);
 
    /* Setup the current size and the available size */
    FlatBuffer->BufferSize = FlatBuffer->BufferFreeSize = Size;
}

Hostent_ConvertToOffsets()

VOID WINAPI Hostent_ConvertToOffsets

(

IN PHOSTENT

Hostent

)

Definition at line 71 of file hostent.c.

{
    /* Do we have a name? */
    if (Hostent->h_name)
    {
        /* Update it */
        Hostent->h_name -= (ULONG_PTR)Hostent;
    }
 
    /* Do we have aliases? */
    if (Hostent->h_aliases)
    {
        /* Update the pointer */
        Hostent->h_aliases -= (ULONG_PTR)Hostent;
 
        /* Fix them up */
        Dns_PtrArrayToOffsetArray(Hostent->h_aliases, (ULONG_PTR)Hostent);
    }
 
    /* Do we have addresses? */
    if (Hostent->h_addr_list)
    {
        /* Fix them up */
        Dns_PtrArrayToOffsetArray(Hostent->h_addr_list, (ULONG_PTR)Hostent);
    }
}

Referenced by SaBlob_CreateHostent().

Hostent_Init()

PHOSTENT WINAPI Hostent_Init	(	IN PVOID *	Buffer,
		IN WORD	AddressFamily,
		IN ULONG	AddressSize,
		IN ULONG	AddressCount,
		IN ULONG	AliasCount
	)

Definition at line 17 of file hostent.c.

{
    PHOSTENT Hostent;
    ULONG_PTR BufferPosition = (ULONG_PTR)*Buffer;
 
    /* Align the hostent on the buffer's 4 byte boundary */
    BufferPosition += 3 & ~3;
 
    /* Set up the basic data */
    Hostent = (PHOSTENT)BufferPosition;
    Hostent->h_length = (WORD)AddressSize;
    Hostent->h_addrtype = AddressFamily;
 
    /* Put aliases after Hostent */
    Hostent->h_aliases = (PCHAR*)((ULONG_PTR)(Hostent + 1) & ~3);
 
    /* Zero it out */
    RtlZeroMemory(Hostent->h_aliases, AliasCount * sizeof(PCHAR));
 
    /* Put addresses after aliases */
    Hostent->h_addr_list = (PCHAR*)
                           ((ULONG_PTR)Hostent->h_aliases +
                            (AliasCount * sizeof(PCHAR)) + sizeof(PCHAR));
 
    /* Update the location */
    BufferPosition = (ULONG_PTR)Hostent->h_addr_list +
                     ((AddressCount * sizeof(PCHAR)) + sizeof(PCHAR));
 
    /* Send it back */
    *Buffer = (PVOID)BufferPosition;
 
    /* Return the hostent */
    return Hostent;
}

Referenced by SaBlob_CreateHostent().

SaBlob_Create()

PDNS_BLOB WINAPI SaBlob_Create

(

IN ULONG

Count

)

Definition at line 27 of file sablob.c.

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

Referenced by SaBlob_CreateFromIp4(), and SaBlob_CreateFromRecords().

SaBlob_CreateFromIp4()

PDNS_BLOB WINAPI SaBlob_CreateFromIp4	(	IN LPWSTR	Name,
		IN ULONG	Count,
		IN PIN_ADDR	AddressArray
	)

Definition at line 61 of file sablob.c.

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

SaBlob_CreateHostent()

PHOSTENT WINAPI SaBlob_CreateHostent	(	IN OUT PULONG_PTR	BufferPosition,
		IN OUT PSIZE_T	RemainingBufferSpace,
		IN OUT PSIZE_T	HostEntrySize,
		IN PDNS_BLOB	Blob,
		IN DWORD	StringType,
		IN BOOLEAN	Relative,
		IN BOOLEAN	BufferAllocated
	)

Definition at line 131 of file sablob.c.

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

SaBlob_Free()

VOID WINAPI SaBlob_Free

(

IN PDNS_BLOB

Blob

)

Definition at line 103 of file sablob.c.

{
    /* 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);
    }
}

Referenced by SaBlob_Create(), SaBlob_CreateFromIp4(), SaBlob_CreateFromRecords(), and SaBlob_Query().

SaBlob_Query()

PDNS_BLOB WINAPI SaBlob_Query	(	IN LPWSTR	Name,
		IN WORD	DnsType,
		IN ULONG	Flags,
		IN PVOID *	Reserved,
		IN DWORD	AddressFamily
	)

Definition at line 545 of file sablob.c.

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

SaBlob_WriteNameOrAlias()

INT WINAPI SaBlob_WriteNameOrAlias	(	IN PDNS_BLOB	Blob,
		IN LPWSTR	String,
		IN BOOLEAN	IsAlias
	)

Definition at line 294 of file sablob.c.

{
    /* 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;
}

Referenced by SaBlob_CreateFromRecords(), and SaBlob_WriteRecords().