precomp.h File Reference

#include <stdarg.h>
#include <stdio.h>
#include <windef.h>
#include <winbase.h>
#include <winnls.h>
#include <winreg.h>
#include <winsvc.h>
#include <windns.h>
#include <windns_undoc.h>
#include <ndk/rtlfuncs.h>
#include <ndk/obfuncs.h>
#include <dnsrslvr_s.h>
#include <strsafe.h>

Include dependency graph for precomp.h:

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

Go to the source code of this file.

Classes
struct	_RESOLVER_CACHE_ENTRY
struct	_RESOLVER_CACHE

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NTOS_MODE_USER
#define	CACHE_FLUSH_HOSTS_FILE_ENTRIES   0x00000001
#define	CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES   0x00000002
#define	CACHE_FLUSH_ALL   0x00000003

Typedefs
typedef struct _RESOLVER_CACHE_ENTRY	RESOLVER_CACHE_ENTRY
typedef struct _RESOLVER_CACHE_ENTRY *	PRESOLVER_CACHE_ENTRY
typedef struct _RESOLVER_CACHE	RESOLVER_CACHE
typedef struct _RESOLVER_CACHE *	PRESOLVER_CACHE

Functions
VOID	DnsIntCacheInitialize (VOID)
VOID	DnsIntCacheRemoveEntryItem (PRESOLVER_CACHE_ENTRY CacheEntry)
VOID	DnsIntCacheFree (VOID)
DNS_STATUS	DnsIntCacheFlush (_In_ ULONG ulFlags)
DNS_STATUS	DnsIntFlushCacheEntry (_In_ LPCWSTR pszName, _In_ WORD wType)
DNS_STATUS	DnsIntCacheGetEntryByName (LPCWSTR Name, WORD wType, DWORD dwFlags, PDNS_RECORDW *Record)
VOID	DnsIntCacheAddEntry (_In_ PDNS_RECORDW Record, _In_ BOOL bHostsFileEntry)
BOOL	DnsIntCacheRemoveEntryByName (_In_ LPCWSTR Name)
DNS_STATUS	DnsIntCacheGetEntries (_Out_ DNS_CACHE_ENTRY **ppCacheEntries)
BOOL	ReadHostsFile (VOID)

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 8 of file precomp.h.

CACHE_FLUSH_ALL

#define CACHE_FLUSH_ALL   0x00000003

Definition at line 49 of file precomp.h.

CACHE_FLUSH_HOSTS_FILE_ENTRIES

#define CACHE_FLUSH_HOSTS_FILE_ENTRIES   0x00000001

Definition at line 47 of file precomp.h.

CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES

#define CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES   0x00000002

Definition at line 48 of file precomp.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 9 of file precomp.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 19 of file precomp.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 7 of file precomp.h.

Typedef Documentation

PRESOLVER_CACHE

typedef struct _RESOLVER_CACHE * PRESOLVER_CACHE

PRESOLVER_CACHE_ENTRY

typedef struct _RESOLVER_CACHE_ENTRY * PRESOLVER_CACHE_ENTRY

RESOLVER_CACHE

typedef struct _RESOLVER_CACHE RESOLVER_CACHE

RESOLVER_CACHE_ENTRY

typedef struct _RESOLVER_CACHE_ENTRY RESOLVER_CACHE_ENTRY

Function Documentation

DnsIntCacheAddEntry()

VOID DnsIntCacheAddEntry	(	_In_ PDNS_RECORDW	Record,
		_In_ BOOL	bHostsFileEntry
	)

Definition at line 233 of file cache.c.

{
    PRESOLVER_CACHE_ENTRY Entry;
 
    DPRINT("DnsIntCacheAddEntry(%p %u)\n",
           Record, bHostsFileEntry);
 
    DPRINT("Name: %S\n", Record->pName);
    DPRINT("TTL: %lu\n", Record->dwTtl);
 
    /* Lock the cache */
    DnsCacheLock();
 
    /* Match the Id with all the entries in the List */
    Entry = (PRESOLVER_CACHE_ENTRY)HeapAlloc(GetProcessHeap(), 0, sizeof(*Entry));
    if (!Entry)
        return;
 
    Entry->bHostsFileEntry = bHostsFileEntry;
    Entry->Record = DnsRecordSetCopyEx(Record, DnsCharSetUnicode, DnsCharSetUnicode);
 
    /* Insert it to our List */
    InsertTailList(&DnsCache.RecordList, &Entry->CacheLink);
 
    /* Release the cache */
    DnsCacheUnlock();
}

Referenced by AddIpv4HostEntries(), AddIpv6HostEntries(), and R_ResolverQuery().

DnsIntCacheFlush()

DNS_STATUS DnsIntCacheFlush

(

_In_ ULONG

ulFlags

)

Definition at line 69 of file cache.c.

{
    PLIST_ENTRY Entry, NextEntry;
    PRESOLVER_CACHE_ENTRY CacheEntry;
 
    DPRINT("DnsIntCacheFlush(%lu)\n", ulFlags);
 
    /* Lock the cache */
    DnsCacheLock();
 
    /* Loop every entry */
    Entry = DnsCache.RecordList.Flink;
    while (Entry != &DnsCache.RecordList)
    {
        NextEntry = Entry->Flink;
 
        /* Get this entry */
        CacheEntry = CONTAINING_RECORD(Entry, RESOLVER_CACHE_ENTRY, CacheLink);
 
        /* Remove it from list */
        if (((ulFlags & CACHE_FLUSH_HOSTS_FILE_ENTRIES) && (CacheEntry->bHostsFileEntry != FALSE)) ||
            ((ulFlags & CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES) && (CacheEntry->bHostsFileEntry == FALSE)))
            DnsIntCacheRemoveEntryItem(CacheEntry);
 
        /* Move to the next entry */
        Entry = NextEntry;
    }
 
    /* Unlock the cache */
    DnsCacheUnlock();
 
    return ERROR_SUCCESS;
}

Referenced by DnsIntCacheFree(), and R_ResolverFlushCache().

DnsIntCacheFree()

VOID DnsIntCacheFree

(

VOID

)

Definition at line 36 of file cache.c.

{
    DPRINT("DnsIntCacheFree()\n");
 
    /* Check if we're initialized */
    if (!DnsCacheInitialized)
        return;
 
    if (!DnsCache.RecordList.Flink)
        return;
 
    DnsIntCacheFlush(CACHE_FLUSH_ALL);
 
    DeleteCriticalSection(&DnsCache.Lock);
    DnsCacheInitialized = FALSE;
}

Referenced by ServiceControlHandler(), and ServiceMain().

DnsIntCacheGetEntries()

DNS_STATUS DnsIntCacheGetEntries

(

_Out_ DNS_CACHE_ENTRY **

ppCacheEntries

)

Definition at line 264 of file cache.c.

{
    PRESOLVER_CACHE_ENTRY CacheEntry;
    PLIST_ENTRY NextEntry;
    PDNS_CACHE_ENTRY pLastEntry = NULL, pNewEntry;
 
    /* Lock the cache */
    DnsCacheLock();
 
    *ppCacheEntries = NULL;
 
    NextEntry = DnsCache.RecordList.Flink;
    while (NextEntry != &DnsCache.RecordList)
    {
        /* Get the Current Entry */
        CacheEntry = CONTAINING_RECORD(NextEntry, RESOLVER_CACHE_ENTRY, CacheLink);
 
        DPRINT("1 %S %lu\n", CacheEntry->Record->pName, CacheEntry->Record->wType);
        if (CacheEntry->Record->pNext)
        {
            DPRINT("2 %S %lu\n", CacheEntry->Record->pNext->pName, CacheEntry->Record->pNext->wType);
        }
 
        pNewEntry = midl_user_allocate(sizeof(DNS_CACHE_ENTRY));
        if (pNewEntry == NULL)
        {
            return ERROR_OUTOFMEMORY;
        }
 
        pNewEntry->pszName = midl_user_allocate((wcslen(CacheEntry->Record->pName) + 1) * sizeof(WCHAR));
        if (pNewEntry->pszName == NULL)
        {
            return ERROR_OUTOFMEMORY;
        }
 
        wcscpy(pNewEntry->pszName, CacheEntry->Record->pName);
        pNewEntry->wType1 = CacheEntry->Record->wType;
        pNewEntry->wType2 = 0;
        pNewEntry->wFlags = 0;
 
        if (pLastEntry == NULL)
            *ppCacheEntries = pNewEntry;
        else
            pLastEntry->pNext = pNewEntry;
        pLastEntry = pNewEntry;
 
        NextEntry = NextEntry->Flink;
    }
 
    /* Release the cache */
    DnsCacheUnlock();
 
    return ERROR_SUCCESS;
}

Referenced by CRrReadCache().

DnsIntCacheGetEntryByName()

DNS_STATUS DnsIntCacheGetEntryByName	(	LPCWSTR	Name,
		WORD	wType,
		DWORD	dwFlags,
		PDNS_RECORDW *	Record
	)

Definition at line 150 of file cache.c.

{
    DNS_STATUS Status = DNS_INFO_NO_RECORDS;
    PRESOLVER_CACHE_ENTRY CacheEntry;
    PLIST_ENTRY NextEntry;
 
    DPRINT("DnsIntCacheGetEntryByName(%S %hu 0x%lx %p)\n",
           Name, wType, dwFlags, Record);
 
    /* Assume failure */
    *Record = NULL;
 
    /* Lock the cache */
    DnsCacheLock();
 
    /* Match the Id with all the entries in the List */
    NextEntry = DnsCache.RecordList.Flink;
    while (NextEntry != &DnsCache.RecordList)
    {
        /* Get the Current Entry */
        CacheEntry = CONTAINING_RECORD(NextEntry, RESOLVER_CACHE_ENTRY, CacheLink);
 
        /* Check if this is the Catalog Entry ID we want */
        if (_wcsicmp(CacheEntry->Record->pName, Name) == 0)
        {
            /* Copy the entry and return it */
            *Record = DnsRecordSetCopyEx(CacheEntry->Record, DnsCharSetUnicode, DnsCharSetUnicode);
            Status = ERROR_SUCCESS;
            break;
        }
 
        NextEntry = NextEntry->Flink;
    }
 
    /* Release the cache */
    DnsCacheUnlock();
 
    return Status;
}

Referenced by R_ResolverQuery().

DnsIntCacheInitialize()

VOID DnsIntCacheInitialize

(

VOID

)

Definition at line 21 of file cache.c.

{
    DPRINT("DnsIntCacheInitialize()\n");
 
    /* Check if we're initialized */
    if (DnsCacheInitialized)
        return;
 
    /* Initialize the cache lock and namespace list */
    InitializeCriticalSection((LPCRITICAL_SECTION)&DnsCache.Lock);
    InitializeListHead(&DnsCache.RecordList);
    DnsCacheInitialized = TRUE;
}

Referenced by ServiceMain().

DnsIntCacheRemoveEntryByName()

BOOL DnsIntCacheRemoveEntryByName

(

_In_ LPCWSTR

Name

)

DnsIntCacheRemoveEntryItem()

VOID DnsIntCacheRemoveEntryItem

(

PRESOLVER_CACHE_ENTRY

CacheEntry

)

Definition at line 54 of file cache.c.

{
    DPRINT("DnsIntCacheRemoveEntryItem(%p)\n", CacheEntry);
 
    /* Remove the entry from the list */
    RemoveEntryList(&CacheEntry->CacheLink);
 
    /* Free record */
    DnsRecordListFree(CacheEntry->Record, DnsFreeRecordList);
 
    /* Delete us */
    HeapFree(GetProcessHeap(), 0, CacheEntry);
}

Referenced by DnsIntCacheFlush(), DnsIntCacheRemoveEntryByName(), and DnsIntFlushCacheEntry().

DnsIntFlushCacheEntry()

DNS_STATUS DnsIntFlushCacheEntry	(	_In_ LPCWSTR	pszName,
		_In_ WORD	wType
	)

Definition at line 106 of file cache.c.

{
    PLIST_ENTRY Entry, NextEntry;
    PRESOLVER_CACHE_ENTRY CacheEntry;
 
    DPRINT("DnsIntFlushCacheEntry(%S %x)\n", pszName, wType);
 
    /* Lock the cache */
    DnsCacheLock();
 
    /* Loop every entry */
    Entry = DnsCache.RecordList.Flink;
    while (Entry != &DnsCache.RecordList)
    {
        NextEntry = Entry->Flink;
 
        /* Get this entry */
        CacheEntry = CONTAINING_RECORD(Entry, RESOLVER_CACHE_ENTRY, CacheLink);
 
        /* Remove it from the list */
        if ((_wcsicmp(CacheEntry->Record->pName, pszName) == 0) &&
            (CacheEntry->bHostsFileEntry == FALSE))
        {
            if ((wType == DNS_TYPE_ANY) ||
                (CacheEntry->Record->wType == wType))
            {
                DnsIntCacheRemoveEntryItem(CacheEntry);
            }
        }
 
        /* Move to the next entry */
        Entry = NextEntry;
    }
 
    /* Unlock the cache */
    DnsCacheUnlock();
 
    return ERROR_SUCCESS;
}

Referenced by R_ResolverFlushCacheEntry().

ReadHostsFile()

BOOL ReadHostsFile

(

VOID

)

Definition at line 291 of file hostsfile.c.

{
    CHAR szLineBuffer[512];
    FILE *pHostFile = NULL;
    CHAR *Ptr, *NameStart, *NameEnd, *AddressStart, *AddressEnd;
    struct in_addr Ipv4Address;
    struct in6_addr Ipv6Address;
    PWSTR pszHostName;
 
    pHostFile = OpenHostsFile();
    if (pHostFile == NULL)
        return FALSE;
 
    for (;;)
    {
        /* Read a line */
        if (fgets(szLineBuffer, sizeof(szLineBuffer), pHostFile) == NULL)
            break;
 
        NameStart = NameEnd = NULL;
        AddressStart = AddressEnd = NULL;
 
        /* Search for the start of the ip address */
        Ptr = szLineBuffer;
        for (;;)
        {
            if (*Ptr == 0 || *Ptr == '#')
                break;
 
            if (!isspace(*Ptr))
            {
                AddressStart = Ptr;
                Ptr = Ptr + 1;
                break;
            }
 
            Ptr = Ptr + 1;
        }
 
        /* Search for the end of the ip address */
        for (;;)
        {
            if (*Ptr == 0 || *Ptr == '#')
                break;
 
            if (isspace(*Ptr))
            {
                AddressEnd = Ptr;
                Ptr = Ptr + 1;
                break;
            }
 
            Ptr = Ptr + 1;
        }
 
        /* Search for the start of the name */
        for (;;)
        {
            if (*Ptr == 0 || *Ptr == '#')
                break;
 
            if (!isspace(*Ptr))
            {
                NameStart = Ptr;
                Ptr = Ptr + 1;
                break;
            }
 
            Ptr = Ptr + 1;
        }
 
        /* Search for the end of the name */
        for (;;)
        {
            if (*Ptr == 0 || *Ptr == '#')
                break;
 
            if (isspace(*Ptr))
            {
                NameEnd = Ptr;
                break;
            }
 
            Ptr = Ptr + 1;
        }
 
        if (AddressStart == NULL || AddressEnd == NULL ||
            NameStart == NULL || NameEnd == NULL)
            continue;
 
        *AddressEnd = 0;
        *NameEnd = 0;
 
        DPRINT("%s ==> %s\n", NameStart, AddressStart);
 
        if (ParseIpv4Address(AddressStart, &Ipv4Address))
        {
            DPRINT("IPv4: %s\n", AddressStart);
 
            pszHostName = AnsiToUnicode(NameStart);
            if (pszHostName != NULL)
            {
                AddIpv4HostEntries(pszHostName, &Ipv4Address);
                HeapFree(GetProcessHeap(), 0, pszHostName);
            }
        }
        else if (ParseIpv6Address(AddressStart, &Ipv6Address))
        {
            DPRINT("IPv6: %s\n", AddressStart);
 
            pszHostName = AnsiToUnicode(NameStart);
            if (pszHostName != NULL)
            {
                AddIpv6HostEntries(pszHostName, &Ipv6Address);
                HeapFree(GetProcessHeap(), 0, pszHostName);
            }
        }
    }
 
    fclose(pHostFile);
 
    return TRUE;
}

Referenced by ServiceMain().