ReactOS 0.4.15-dev-8236-g99f0937
cache.c File Reference
#include "precomp.h"
#include <debug.h>
Include dependency graph for cache.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define DnsCacheLock()   do { EnterCriticalSection(&DnsCache.Lock); } while (0)
 
#define DnsCacheUnlock()   do { LeaveCriticalSection(&DnsCache.Lock); } while (0)
 

Functions

VOID DnsIntCacheInitialize (VOID)
 
VOID DnsIntCacheFree (VOID)
 
VOID DnsIntCacheRemoveEntryItem (PRESOLVER_CACHE_ENTRY CacheEntry)
 
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)
 
BOOL DnsIntCacheRemoveEntryByName (LPCWSTR Name)
 
VOID DnsIntCacheAddEntry (_In_ PDNS_RECORDW Record, _In_ BOOL bHostsFileEntry)
 
DNS_STATUS DnsIntCacheGetEntries (_Out_ DNS_CACHE_ENTRY **ppCacheEntries)
 

Variables

static RESOLVER_CACHE DnsCache
 
static BOOL DnsCacheInitialized = FALSE
 

Macro Definition Documentation

◆ DnsCacheLock

#define DnsCacheLock ( )    do { EnterCriticalSection(&DnsCache.Lock); } while (0)

Definition at line 17 of file cache.c.

◆ DnsCacheUnlock

#define DnsCacheUnlock ( )    do { LeaveCriticalSection(&DnsCache.Lock); } while (0)

Definition at line 18 of file cache.c.

◆ NDEBUG

#define NDEBUG

Definition at line 11 of file cache.c.

Function Documentation

◆ DnsIntCacheAddEntry()

VOID DnsIntCacheAddEntry ( _In_ PDNS_RECORDW  Record,
_In_ BOOL  bHostsFileEntry 
)

Definition at line 233 of file cache.c.

236{
238
239 DPRINT("DnsIntCacheAddEntry(%p %u)\n",
240 Record, bHostsFileEntry);
241
242 DPRINT("Name: %S\n", Record->pName);
243 DPRINT("TTL: %lu\n", Record->dwTtl);
244
245 /* Lock the cache */
246 DnsCacheLock();
247
248 /* Match the Id with all the entries in the List */
249 Entry = (PRESOLVER_CACHE_ENTRY)HeapAlloc(GetProcessHeap(), 0, sizeof(*Entry));
250 if (!Entry)
251 return;
252
253 Entry->bHostsFileEntry = bHostsFileEntry;
255
256 /* Insert it to our List */
258
259 /* Release the cache */
261}
#define DnsCacheUnlock()
Definition: cache.c:18
static RESOLVER_CACHE DnsCache
Definition: cache.c:14
#define DnsCacheLock()
Definition: cache.c:17
struct _RESOLVER_CACHE_ENTRY * PRESOLVER_CACHE_ENTRY
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
PDNS_RECORD WINAPI DnsRecordSetCopyEx(PDNS_RECORD src_set, DNS_CHARSET in, DNS_CHARSET out)
Definition: record.c:712
#define InsertTailList(ListHead, Entry)
#define DPRINT
Definition: sndvol32.h:73
base of all file and directory entries
Definition: entries.h:83
Definition: precomp.h:28
LIST_ENTRY RecordList
Definition: precomp.h:36
@ DnsCharSetUnicode
Definition: windns.h:111
_In_ struct _KBUGCHECK_REASON_CALLBACK_RECORD * Record
Definition: ketypes.h:268

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

◆ DnsIntCacheFlush()

DNS_STATUS DnsIntCacheFlush ( _In_ ULONG  ulFlags)

Definition at line 69 of file cache.c.

71{
72 PLIST_ENTRY Entry, NextEntry;
73 PRESOLVER_CACHE_ENTRY CacheEntry;
74
75 DPRINT("DnsIntCacheFlush(%lu)\n", ulFlags);
76
77 /* Lock the cache */
79
80 /* Loop every entry */
82 while (Entry != &DnsCache.RecordList)
83 {
84 NextEntry = Entry->Flink;
85
86 /* Get this entry */
87 CacheEntry = CONTAINING_RECORD(Entry, RESOLVER_CACHE_ENTRY, CacheLink);
88
89 /* Remove it from list */
90 if (((ulFlags & CACHE_FLUSH_HOSTS_FILE_ENTRIES) && (CacheEntry->bHostsFileEntry != FALSE)) ||
91 ((ulFlags & CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES) && (CacheEntry->bHostsFileEntry == FALSE)))
93
94 /* Move to the next entry */
95 Entry = NextEntry;
96 }
97
98 /* Unlock the cache */
100
101 return ERROR_SUCCESS;
102}
VOID DnsIntCacheRemoveEntryItem(PRESOLVER_CACHE_ENTRY CacheEntry)
Definition: cache.c:54
#define CACHE_FLUSH_NON_HOSTS_FILE_ENTRIES
Definition: precomp.h:48
#define CACHE_FLUSH_HOSTS_FILE_ENTRIES
Definition: precomp.h:47
#define ERROR_SUCCESS
Definition: deptool.c:10
#define FALSE
Definition: types.h:117
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
BOOL bHostsFileEntry
Definition: precomp.h:30
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by DnsIntCacheFree(), and R_ResolverFlushCache().

◆ DnsIntCacheFree()

VOID DnsIntCacheFree ( VOID  )

Definition at line 36 of file cache.c.

37{
38 DPRINT("DnsIntCacheFree()\n");
39
40 /* Check if we're initialized */
42 return;
43
45 return;
46
48
51}
static BOOL DnsCacheInitialized
Definition: cache.c:15
DNS_STATUS DnsIntCacheFlush(_In_ ULONG ulFlags)
Definition: cache.c:69
#define CACHE_FLUSH_ALL
Definition: precomp.h:49
CRITICAL_SECTION Lock
Definition: precomp.h:37
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

Referenced by ServiceControlHandler(), and ServiceMain().

◆ DnsIntCacheGetEntries()

DNS_STATUS DnsIntCacheGetEntries ( _Out_ DNS_CACHE_ENTRY **  ppCacheEntries)

Definition at line 264 of file cache.c.

266{
267 PRESOLVER_CACHE_ENTRY CacheEntry;
268 PLIST_ENTRY NextEntry;
269 PDNS_CACHE_ENTRY pLastEntry = NULL, pNewEntry;
270
271 /* Lock the cache */
272 DnsCacheLock();
273
274 *ppCacheEntries = NULL;
275
276 NextEntry = DnsCache.RecordList.Flink;
277 while (NextEntry != &DnsCache.RecordList)
278 {
279 /* Get the Current Entry */
280 CacheEntry = CONTAINING_RECORD(NextEntry, RESOLVER_CACHE_ENTRY, CacheLink);
281
282 DPRINT("1 %S %lu\n", CacheEntry->Record->pName, CacheEntry->Record->wType);
283 if (CacheEntry->Record->pNext)
284 {
285 DPRINT("2 %S %lu\n", CacheEntry->Record->pNext->pName, CacheEntry->Record->pNext->wType);
286 }
287
288 pNewEntry = midl_user_allocate(sizeof(DNS_CACHE_ENTRY));
289 if (pNewEntry == NULL)
290 {
291 return ERROR_OUTOFMEMORY;
292 }
293
294 pNewEntry->pszName = midl_user_allocate((wcslen(CacheEntry->Record->pName) + 1) * sizeof(WCHAR));
295 if (pNewEntry->pszName == NULL)
296 {
297 return ERROR_OUTOFMEMORY;
298 }
299
300 wcscpy(pNewEntry->pszName, CacheEntry->Record->pName);
301 pNewEntry->wType1 = CacheEntry->Record->wType;
302 pNewEntry->wType2 = 0;
303 pNewEntry->wFlags = 0;
304
305 if (pLastEntry == NULL)
306 *ppCacheEntries = pNewEntry;
307 else
308 pLastEntry->pNext = pNewEntry;
309 pLastEntry = pNewEntry;
310
311 NextEntry = NextEntry->Flink;
312 }
313
314 /* Release the cache */
316
317 return ERROR_SUCCESS;
318}
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
#define NULL
Definition: types.h:112
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define midl_user_allocate
Definition: rpc.h:44
Definition: windns_undoc.h:9
struct _DNS_CACHE_ENTRY * pNext
Definition: windns_undoc.h:10
WORD wType
Definition: windns.h:600
LPWSTR pName
Definition: windns.h:599
struct _DnsRecordW * pNext
Definition: windns.h:598
PDNS_RECORDW Record
Definition: precomp.h:31
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by CRrReadCache().

◆ DnsIntCacheGetEntryByName()

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

Definition at line 150 of file cache.c.

155{
156 DNS_STATUS Status = DNS_INFO_NO_RECORDS;
157 PRESOLVER_CACHE_ENTRY CacheEntry;
158 PLIST_ENTRY NextEntry;
159
160 DPRINT("DnsIntCacheGetEntryByName(%S %hu 0x%lx %p)\n",
161 Name, wType, dwFlags, Record);
162
163 /* Assume failure */
164 *Record = NULL;
165
166 /* Lock the cache */
167 DnsCacheLock();
168
169 /* Match the Id with all the entries in the List */
170 NextEntry = DnsCache.RecordList.Flink;
171 while (NextEntry != &DnsCache.RecordList)
172 {
173 /* Get the Current Entry */
174 CacheEntry = CONTAINING_RECORD(NextEntry, RESOLVER_CACHE_ENTRY, CacheLink);
175
176 /* Check if this is the Catalog Entry ID we want */
177 if (_wcsicmp(CacheEntry->Record->pName, Name) == 0)
178 {
179 /* Copy the entry and return it */
182 break;
183 }
184
185 NextEntry = NextEntry->Flink;
186 }
187
188 /* Release the cache */
190
191 return Status;
192}
Status
Definition: gdiplustypes.h:25
_Check_return_ _CRTIMP int __cdecl _wcsicmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define DNS_INFO_NO_RECORDS
Definition: winerror.h:1861

Referenced by R_ResolverQuery().

◆ DnsIntCacheInitialize()

VOID DnsIntCacheInitialize ( VOID  )

Definition at line 21 of file cache.c.

22{
23 DPRINT("DnsIntCacheInitialize()\n");
24
25 /* Check if we're initialized */
27 return;
28
29 /* Initialize the cache lock and namespace list */
33}
#define TRUE
Definition: types.h:120
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751

Referenced by ServiceMain().

◆ DnsIntCacheRemoveEntryByName()

BOOL DnsIntCacheRemoveEntryByName ( LPCWSTR  Name)

Definition at line 195 of file cache.c.

196{
197 BOOL Ret = FALSE;
198 PRESOLVER_CACHE_ENTRY CacheEntry;
199 PLIST_ENTRY NextEntry;
200
201 DPRINT("DnsIntCacheRemoveEntryByName(%S)\n", Name);
202
203 /* Lock the cache */
204 DnsCacheLock();
205
206 /* Match the Id with all the entries in the List */
207 NextEntry = DnsCache.RecordList.Flink;
208 while (NextEntry != &DnsCache.RecordList)
209 {
210 /* Get the Current Entry */
211 CacheEntry = CONTAINING_RECORD(NextEntry, RESOLVER_CACHE_ENTRY, CacheLink);
212
213 /* Check if this is the Catalog Entry ID we want */
214 if (_wcsicmp(CacheEntry->Record->pName, Name) == 0)
215 {
216 /* Remove the entry */
217 DnsIntCacheRemoveEntryItem(CacheEntry);
218 Ret = TRUE;
219 break;
220 }
221
222 NextEntry = NextEntry->Flink;
223 }
224
225 /* Release the cache */
227
228 /* Return */
229 return Ret;
230}
unsigned int BOOL
Definition: ntddk_ex.h:94

◆ DnsIntCacheRemoveEntryItem()

VOID DnsIntCacheRemoveEntryItem ( PRESOLVER_CACHE_ENTRY  CacheEntry)

Definition at line 54 of file cache.c.

55{
56 DPRINT("DnsIntCacheRemoveEntryItem(%p)\n", CacheEntry);
57
58 /* Remove the entry from the list */
59 RemoveEntryList(&CacheEntry->CacheLink);
60
61 /* Free record */
63
64 /* Delete us */
65 HeapFree(GetProcessHeap(), 0, CacheEntry);
66}
#define HeapFree(x, y, z)
Definition: compat.h:735
VOID WINAPI DnsRecordListFree(PDNS_RECORD list, DNS_FREE_TYPE type)
Definition: record.c:526
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
LIST_ENTRY CacheLink
Definition: precomp.h:29
@ DnsFreeRecordList
Definition: windns.h:139

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

◆ DnsIntFlushCacheEntry()

DNS_STATUS DnsIntFlushCacheEntry ( _In_ LPCWSTR  pszName,
_In_ WORD  wType 
)

Definition at line 106 of file cache.c.

109{
110 PLIST_ENTRY Entry, NextEntry;
111 PRESOLVER_CACHE_ENTRY CacheEntry;
112
113 DPRINT("DnsIntFlushCacheEntry(%S %x)\n", pszName, wType);
114
115 /* Lock the cache */
116 DnsCacheLock();
117
118 /* Loop every entry */
120 while (Entry != &DnsCache.RecordList)
121 {
122 NextEntry = Entry->Flink;
123
124 /* Get this entry */
125 CacheEntry = CONTAINING_RECORD(Entry, RESOLVER_CACHE_ENTRY, CacheLink);
126
127 /* Remove it from the list */
128 if ((_wcsicmp(CacheEntry->Record->pName, pszName) == 0) &&
129 (CacheEntry->bHostsFileEntry == FALSE))
130 {
131 if ((wType == DNS_TYPE_ANY) ||
132 (CacheEntry->Record->wType == wType))
133 {
134 DnsIntCacheRemoveEntryItem(CacheEntry);
135 }
136 }
137
138 /* Move to the next entry */
139 Entry = NextEntry;
140 }
141
142 /* Unlock the cache */
144
145 return ERROR_SUCCESS;
146}
#define DNS_TYPE_ANY
Definition: windns.h:94

Referenced by R_ResolverFlushCacheEntry().

Variable Documentation

◆ DnsCache

◆ DnsCacheInitialized

BOOL DnsCacheInitialized = FALSE
static

Definition at line 15 of file cache.c.

Referenced by DnsIntCacheFree(), and DnsIntCacheInitialize().