ReactOS  0.4.14-dev-1256-g2125fec
query.c File Reference
#include "precomp.h"
#include <winreg.h>
#include <iphlpapi.h>
#include <strsafe.h>
#include <debug.h>
Include dependency graph for query.c:

Go to the source code of this file.

Macros

#define NDEBUG
 
#define CNAME_LOOP_MAX   16
 

Functions

static BOOL ParseIpv4Address (_In_ PCWSTR AddressString, _Out_ PIN_ADDR pAddress)
 
static BOOL ParseIpv6Address (_In_ PCWSTR AddressString, _Out_ PIN6_ADDR pAddress)
 
static PDNS_RECORDW CreateRecordForIpAddress (_In_ PCWSTR Name, _In_ WORD Type)
 
static PCHAR DnsWToC (const WCHAR *WideString)
 
static PWCHAR DnsCToW (const CHAR *NarrowString)
 
static PCHAR DnsWToUTF8 (const WCHAR *WideString)
 
static PWCHAR DnsUTF8ToW (const CHAR *NarrowString)
 
DNS_STATUS WINAPI DnsQuery_CodePage (UINT CodePage, LPCSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
 
DNS_STATUS WINAPI DnsQuery_A (LPCSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
 
DNS_STATUS WINAPI DnsQuery_UTF8 (LPCSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
 
DNS_STATUS WINAPI DnsQuery_W (LPCWSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
 
WCHARxstrsave (const WCHAR *str)
 
CHARxstrsaveA (const CHAR *str)
 
IP4_ADDRESS CheckForCurrentHostname (CONST CHAR *Name, PFIXED_INFO network_info)
 
DNS_STATUS WINAPI Query_Main (LPCWSTR Name, WORD Type, DWORD Options, PDNS_RECORD *QueryResultSet)
 
void DnsIntFreeRecordList (PDNS_RECORD ToDelete)
 
BOOL WINAPI DnsFlushResolverCache (VOID)
 
BOOL WINAPI DnsGetCacheDataTable (_Out_ PDNS_CACHE_ENTRY *DnsCache)
 
DWORD WINAPI GetCurrentTimeInSeconds (VOID)
 

Macro Definition Documentation

◆ CNAME_LOOP_MAX

#define CNAME_LOOP_MAX   16

◆ NDEBUG

#define NDEBUG

Definition at line 16 of file query.c.

Function Documentation

◆ CheckForCurrentHostname()

IP4_ADDRESS CheckForCurrentHostname ( CONST CHAR Name,
PFIXED_INFO  network_info 
)

Definition at line 582 of file query.c.

583 {
584  PCHAR TempName;
585  DWORD AdapterAddressesSize, Status;
586  IP4_ADDRESS ret = 0, Address;
587  PIP_ADAPTER_ADDRESSES Addresses = NULL, pip;
588  BOOL Found = FALSE;
589 
590  if (network_info->DomainName[0])
591  {
592  size_t StringLength;
593  size_t TempSize = 2;
594  StringCchLengthA(network_info->HostName, sizeof(network_info->HostName), &StringLength);
595  TempSize += StringLength;
596  StringCchLengthA(network_info->DomainName, sizeof(network_info->DomainName), &StringLength);
597  TempSize += StringLength;
598  TempName = RtlAllocateHeap(RtlGetProcessHeap(), 0, TempSize);
599  StringCchCopyA(TempName, TempSize, network_info->HostName);
600  StringCchCatA(TempName, TempSize, ".");
601  StringCchCatA(TempName, TempSize, network_info->DomainName);
602  }
603  else
604  {
605  TempName = RtlAllocateHeap(RtlGetProcessHeap(), 0, 1);
606  TempName[0] = 0;
607  }
608  Found = !stricmp(Name, network_info->HostName) || !stricmp(Name, TempName);
609  RtlFreeHeap(RtlGetProcessHeap(), 0, TempName);
610  if (!Found)
611  {
612  return 0;
613  }
614  /* get adapter info */
615  AdapterAddressesSize = 0;
616  GetAdaptersAddresses(AF_INET,
617  GAA_FLAG_SKIP_FRIENDLY_NAME | GAA_FLAG_SKIP_DNS_SERVER |
618  GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST,
619  NULL,
620  Addresses,
621  &AdapterAddressesSize);
622  if (!AdapterAddressesSize)
623  {
624  return 0;
625  }
626  Addresses = RtlAllocateHeap(RtlGetProcessHeap(), 0, AdapterAddressesSize);
627  Status = GetAdaptersAddresses(AF_INET,
628  GAA_FLAG_SKIP_FRIENDLY_NAME | GAA_FLAG_SKIP_DNS_SERVER |
629  GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST,
630  NULL,
631  Addresses,
632  &AdapterAddressesSize);
633  if (Status)
634  {
635  RtlFreeHeap(RtlGetProcessHeap(), 0, Addresses);
636  return 0;
637  }
638  for (pip = Addresses; pip != NULL; pip = pip->Next) {
639  Address = ((LPSOCKADDR_IN)pip->FirstUnicastAddress->Address.lpSockaddr)->sin_addr.S_un.S_addr;
640  if (Address != ntohl(INADDR_LOOPBACK))
641  break;
642  }
644  {
645  ret = Address;
646  }
647  RtlFreeHeap(RtlGetProcessHeap(), 0, Addresses);
648  return ret;
649 }
struct sockaddr_in * LPSOCKADDR_IN
Definition: winsock.h:489
signed char * PCHAR
Definition: retypes.h:7
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
DWORD IP4_ADDRESS
Definition: windns.h:36
#define GAA_FLAG_SKIP_FRIENDLY_NAME
unsigned int BOOL
Definition: ntddk_ex.h:94
STRSAFEAPI StringCchCatA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:320
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:82
return Found
Definition: dirsup.c:1270
_Check_return_ _CRTIMP int __cdecl stricmp(_In_z_ const char *_Str1, _In_z_ const char *_Str2)
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:81
Status
Definition: gdiplustypes.h:24
STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:145
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832
#define AF_INET
Definition: tcpip.h:117
#define INADDR_LOOPBACK
Definition: winsock.h:312
static PIP_ADAPTER_ADDRESSES
Definition: iphlpapi.c:76
#define ntohl(x)
Definition: module.h:203

Referenced by Query_Main().

◆ CreateRecordForIpAddress()

static PDNS_RECORDW CreateRecordForIpAddress ( _In_ PCWSTR  Name,
_In_ WORD  Type 
)
static

Definition at line 60 of file query.c.

63 {
64  IN_ADDR Ip4Address;
65  IN6_ADDR Ip6Address;
66  PDNS_RECORDW pRecord = NULL;
67 
68  if (Type == DNS_TYPE_A)
69  {
70  if (ParseIpv4Address(Name, &Ip4Address))
71  {
72  pRecord = RtlAllocateHeap(RtlGetProcessHeap(),
74  sizeof(DNS_RECORDW));
75  if (pRecord == NULL)
76  return NULL;
77 
78  pRecord->pName = RtlAllocateHeap(RtlGetProcessHeap(),
79  0,
80  (wcslen(Name) + 1) * sizeof(WCHAR));
81  if (pRecord == NULL)
82  {
83  RtlFreeHeap(RtlGetProcessHeap(), 0, pRecord);
84  return NULL;
85  }
86 
87  wcscpy(pRecord->pName, Name);
88  pRecord->wType = DNS_TYPE_A;
89  pRecord->wDataLength = sizeof(DNS_A_DATA);
90  pRecord->Flags.S.Section = DnsSectionQuestion;
91  pRecord->Flags.S.CharSet = DnsCharSetUnicode;
92  pRecord->dwTtl = 7 * 24 * 60 * 60;
93 
94  pRecord->Data.A.IpAddress = Ip4Address.S_un.S_addr;
95 
96  return pRecord;
97  }
98  }
99  else if (Type == DNS_TYPE_AAAA)
100  {
101  if (ParseIpv6Address(Name, &Ip6Address))
102  {
103  pRecord = RtlAllocateHeap(RtlGetProcessHeap(),
105  sizeof(DNS_RECORDW));
106  if (pRecord == NULL)
107  return NULL;
108 
109  pRecord->pName = RtlAllocateHeap(RtlGetProcessHeap(),
110  0,
111  (wcslen(Name) + 1) * sizeof(WCHAR));
112  if (pRecord == NULL)
113  {
114  RtlFreeHeap(RtlGetProcessHeap(), 0, pRecord);
115  return NULL;
116  }
117 
118  wcscpy(pRecord->pName, Name);
119  pRecord->wType = DNS_TYPE_AAAA;
120  pRecord->wDataLength = sizeof(DNS_AAAA_DATA);
121  pRecord->Flags.S.Section = DnsSectionQuestion;
122  pRecord->Flags.S.CharSet = DnsCharSetUnicode;
123  pRecord->dwTtl = 7 * 24 * 60 * 60;
124 
125  CopyMemory(&pRecord->Data.AAAA.Ip6Address,
126  &Ip6Address.u.Byte,
127  sizeof(IN6_ADDR));
128 
129  return pRecord;
130  }
131  }
132 
133  return NULL;
134 }
DNS_A_DATA A
Definition: windns.h:609
DWORD Section
Definition: windns.h:238
UCHAR Byte[16]
Definition: in6addr.h:5
Type
Definition: Type.h:6
#define DNS_TYPE_AAAA
Definition: windns.h:68
#define DNS_TYPE_A
Definition: windns.h:41
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
WORD wDataLength
Definition: windns.h:601
union in6_addr::@2897 u
DNS_AAAA_DATA AAAA
Definition: windns.h:617
smooth NULL
Definition: ftsmooth.c:416
union _DnsRecordW::@3198 Flags
IP4_ADDRESS IpAddress
Definition: windns.h:246
union _DnsRecordW::@3199 Data
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
__wchar_t WCHAR
Definition: xmlstorage.h:180
Definition: tcpip.h:125
#define CopyMemory
Definition: winbase.h:1646
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
union in_addr::@1007 S_un
WORD wType
Definition: windns.h:600
u_long S_addr
Definition: tcpip.h:131
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
static BOOL ParseIpv6Address(_In_ PCWSTR AddressString, _Out_ PIN6_ADDR pAddress)
Definition: query.c:41
DNS_IP6_ADDRESS Ip6Address
Definition: windns.h:250
DNS_RECORD_FLAGS S
Definition: windns.h:604
static BOOL ParseIpv4Address(_In_ PCWSTR AddressString, _Out_ PIN_ADDR pAddress)
Definition: query.c:21
DWORD dwTtl
Definition: windns.h:606
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
DWORD CharSet
Definition: windns.h:240
LPWSTR pName
Definition: windns.h:599

Referenced by DnsQuery_W().

◆ DnsCToW()

static PWCHAR DnsCToW ( const CHAR NarrowString)
static

Definition at line 187 of file query.c.

188 {
189  PWCHAR WideString;
190  int WideLen = MultiByteToWideChar(CP_ACP,
191  0,
192  NarrowString,
193  -1,
194  NULL,
195  0);
196  if (WideLen == 0)
197  return NULL;
198  WideString = RtlAllocateHeap(RtlGetProcessHeap(), 0, WideLen * sizeof(WCHAR));
199  if (WideString == NULL)
200  {
201  return NULL;
202  }
204  0,
205  NarrowString,
206  -1,
207  WideString,
208  WideLen);
209 
210  return WideString;
211 }
#define CP_ACP
Definition: compat.h:99
uint16_t * PWCHAR
Definition: typedefs.h:55
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MultiByteToWideChar
Definition: compat.h:100

Referenced by DnsQuery_CodePage(), and Query_Main().

◆ DnsFlushResolverCache()

BOOL WINAPI DnsFlushResolverCache ( VOID  )

Definition at line 933 of file query.c.

934 {
935  DNS_STATUS Status = ERROR_SUCCESS;
936 
937  DPRINT("DnsFlushResolverCache()\n");
938 
940  {
942  DPRINT("R_ResolverFlushCache() returned %lu\n", Status);
943  }
945  {
947  DPRINT("Exception returned %lu\n", Status);
948  }
949  RpcEndExcept;
950 
951  return (Status == ERROR_SUCCESS);
952 }
#define RpcEndExcept
Definition: rpc.h:128
#define ERROR_SUCCESS
Definition: deptool.c:10
DWORD __stdcall R_ResolverFlushCache(_In_ DNSRSLVR_HANDLE pwszServerName)
Definition: rpcserver.c:62
#define RpcTryExcept
Definition: rpc.h:126
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
#define RpcExceptionCode()
Definition: rpc.h:132
Status
Definition: gdiplustypes.h:24
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by FlushDns().

◆ DnsGetCacheDataTable()

BOOL WINAPI DnsGetCacheDataTable ( _Out_ PDNS_CACHE_ENTRY DnsCache)

Definition at line 956 of file query.c.

958 {
959  DNS_STATUS Status = ERROR_SUCCESS;
960  PDNS_CACHE_ENTRY CacheEntries = NULL;
961 
962  if (DnsCache == NULL)
963  return FALSE;
964 
966  {
968  &CacheEntries);
969  DPRINT("CRrReadCache() returned %lu\n", Status);
970  }
972  {
974  DPRINT1("Exception returned %lu\n", Status);
975  }
976  RpcEndExcept;
977 
978  if (Status != ERROR_SUCCESS)
979  return FALSE;
980 
981  if (CacheEntries == NULL)
982  return FALSE;
983 
984  *DnsCache = CacheEntries;
985 
986  return TRUE;
987 }
#define RpcEndExcept
Definition: rpc.h:128
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
#define RpcTryExcept
Definition: rpc.h:126
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
Definition: windns_undoc.h:8
smooth NULL
Definition: ftsmooth.c:416
DWORD __stdcall CRrReadCache(_In_ DNSRSLVR_HANDLE pwszServerName, _Out_ DNS_CACHE_ENTRY **ppCacheEntries)
Definition: rpcserver.c:48
void DPRINT(...)
Definition: polytest.cpp:61
#define RpcExceptionCode()
Definition: rpc.h:132
static RESOLVER_CACHE DnsCache
Definition: cache.c:14
Status
Definition: gdiplustypes.h:24
#define DPRINT1
Definition: precomp.h:8
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by DisplayDns().

◆ DnsIntFreeRecordList()

void DnsIntFreeRecordList ( PDNS_RECORD  ToDelete)

Definition at line 889 of file query.c.

890 {
891  UINT i;
892  PDNS_RECORD next = 0;
893 
894  while(ToDelete)
895  {
896  if(ToDelete->pName)
897  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->pName);
898 
899  switch(ToDelete->wType)
900  {
901  case DNS_TYPE_CNAME:
902  case DNS_TYPE_PTR:
903  case DNS_TYPE_NS:
904  case DNS_TYPE_MB:
905  case DNS_TYPE_MD:
906  case DNS_TYPE_MF:
907  case DNS_TYPE_MG:
908  case DNS_TYPE_MR:
909  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.PTR.pNameHost);
910  break;
911 
912  case DNS_TYPE_MINFO:
913  case DNS_TYPE_MX:
914  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.MX.pNameExchange);
915  break;
916 
917  case DNS_TYPE_HINFO:
918  for(i = 0; i < ToDelete->Data.TXT.dwStringCount; i++)
919  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.TXT.pStringArray[i]);
920 
921  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete->Data.TXT.pStringArray);
922  break;
923  }
924 
925  next = ToDelete->pNext;
926  RtlFreeHeap(RtlGetProcessHeap(), 0, ToDelete);
927  ToDelete = next;
928  }
929 }
#define DNS_TYPE_MG
Definition: windns.h:48
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define DNS_TYPE_HINFO
Definition: windns.h:53
#define DNS_TYPE_CNAME
Definition: windns.h:45
#define DNS_TYPE_MF
Definition: windns.h:44
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define DNS_TYPE_MD
Definition: windns.h:43
#define DNS_TYPE_MINFO
Definition: windns.h:54
#define DNS_TYPE_PTR
Definition: windns.h:52
#define DNS_TYPE_MX
Definition: windns.h:55
#define DNS_TYPE_MB
Definition: windns.h:47
#define DNS_TYPE_MR
Definition: windns.h:49
static unsigned __int64 next
Definition: rand_nt.c:6
unsigned int UINT
Definition: ndis.h:50
#define DNS_TYPE_NS
Definition: windns.h:42
#define PDNS_RECORD
Definition: windns.h:636

Referenced by DnsFree(), and DnsQuery_CodePage().

◆ DnsQuery_A()

DNS_STATUS WINAPI DnsQuery_A ( LPCSTR  Name,
WORD  Type,
DWORD  Options,
PVOID  Extra,
PDNS_RECORD QueryResultSet,
PVOID Reserved 
)

Definition at line 446 of file query.c.

452 {
453  return DnsQuery_CodePage(CP_ACP, Name, Type, Options, Extra, QueryResultSet, Reserved);
454 }
Type
Definition: Type.h:6
#define CP_ACP
Definition: compat.h:99
enum OPTION_FLAGS Options
Definition: stats.c:44
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
DNS_STATUS WINAPI DnsQuery_CodePage(UINT CodePage, LPCSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
Definition: query.c:272

Referenced by TestHostName().

◆ DnsQuery_CodePage()

DNS_STATUS WINAPI DnsQuery_CodePage ( UINT  CodePage,
LPCSTR  Name,
WORD  Type,
DWORD  Options,
PVOID  Extra,
PDNS_RECORD QueryResultSet,
PVOID Reserved 
)

Definition at line 272 of file query.c.

279 {
280  UINT i;
281  PWCHAR Buffer;
282  DNS_STATUS Status;
283  PDNS_RECORD QueryResultWide;
284  PDNS_RECORD ConvertedRecord = 0, LastRecord = 0;
285 
286  if (Name == NULL)
288  if (QueryResultSet == NULL)
290 
291  switch (CodePage)
292  {
293  case CP_ACP:
294  Buffer = DnsCToW(Name);
295  break;
296 
297  case CP_UTF8:
299  break;
300 
301  default:
303  }
304 
305  Status = DnsQuery_W(Buffer, Type, Options, Extra, &QueryResultWide, Reserved);
306 
307  while (Status == ERROR_SUCCESS && QueryResultWide)
308  {
309  switch (QueryResultWide->wType)
310  {
311  case DNS_TYPE_A:
312  case DNS_TYPE_WKS:
313  case DNS_TYPE_CNAME:
314  case DNS_TYPE_PTR:
315  case DNS_TYPE_NS:
316  case DNS_TYPE_MB:
317  case DNS_TYPE_MD:
318  case DNS_TYPE_MF:
319  case DNS_TYPE_MG:
320  case DNS_TYPE_MR:
321  ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
322  break;
323 
324  case DNS_TYPE_MINFO:
325  ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_TXT_DATA) + QueryResultWide->Data.TXT.dwStringCount);
326  break;
327 
328  case DNS_TYPE_NULL:
329  ConvertedRecord = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_NULL_DATA) + QueryResultWide->Data.Null.dwByteCount);
330  break;
331  }
332  if (ConvertedRecord == NULL)
333  {
334  /* The name */
335  RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
336  /* The result*/
337  DnsIntFreeRecordList(QueryResultWide);
338  QueryResultSet = NULL;
339  return ERROR_OUTOFMEMORY;
340  }
341 
342  if (CodePage == CP_ACP)
343  {
344  ConvertedRecord->pName = DnsWToC((PWCHAR)QueryResultWide->pName);
345  ConvertedRecord->Flags.S.CharSet = DnsCharSetAnsi;
346  }
347  else
348  {
349  ConvertedRecord->pName = DnsWToUTF8((PWCHAR)QueryResultWide->pName);
350  ConvertedRecord->Flags.S.CharSet = DnsCharSetUtf8;
351  }
352 
353  ConvertedRecord->wType = QueryResultWide->wType;
354 
355  switch (QueryResultWide->wType)
356  {
357  case DNS_TYPE_A:
358  case DNS_TYPE_WKS:
359  ConvertedRecord->wDataLength = QueryResultWide->wDataLength;
360  memcpy(&ConvertedRecord->Data, &QueryResultWide->Data, QueryResultWide->wDataLength);
361  break;
362 
363  case DNS_TYPE_CNAME:
364  case DNS_TYPE_PTR:
365  case DNS_TYPE_NS:
366  case DNS_TYPE_MB:
367  case DNS_TYPE_MD:
368  case DNS_TYPE_MF:
369  case DNS_TYPE_MG:
370  case DNS_TYPE_MR:
371  ConvertedRecord->wDataLength = sizeof(DNS_PTR_DATA);
372  if (CodePage == CP_ACP)
373  ConvertedRecord->Data.PTR.pNameHost = DnsWToC((PWCHAR)QueryResultWide->Data.PTR.pNameHost);
374  else
375  ConvertedRecord->Data.PTR.pNameHost = DnsWToUTF8((PWCHAR)QueryResultWide->Data.PTR.pNameHost);
376  break;
377 
378  case DNS_TYPE_MINFO:
379  ConvertedRecord->wDataLength = sizeof(DNS_MINFO_DATA);
380  if (CodePage == CP_ACP)
381  {
382  ConvertedRecord->Data.MINFO.pNameMailbox = DnsWToC((PWCHAR)QueryResultWide->Data.MINFO.pNameMailbox);
383  ConvertedRecord->Data.MINFO.pNameErrorsMailbox = DnsWToC((PWCHAR)QueryResultWide->Data.MINFO.pNameErrorsMailbox);
384  }
385  else
386  {
387  ConvertedRecord->Data.MINFO.pNameMailbox = DnsWToUTF8((PWCHAR)QueryResultWide->Data.MINFO.pNameMailbox);
388  ConvertedRecord->Data.MINFO.pNameErrorsMailbox = DnsWToUTF8((PWCHAR)QueryResultWide->Data.MINFO.pNameErrorsMailbox);
389  }
390  break;
391 
392  case DNS_TYPE_MX:
393  ConvertedRecord->wDataLength = sizeof(DNS_MX_DATA);
394  if (CodePage == CP_ACP)
395  ConvertedRecord->Data.MX.pNameExchange = DnsWToC((PWCHAR)QueryResultWide->Data.MX.pNameExchange);
396  else
397  ConvertedRecord->Data.MX.pNameExchange = DnsWToUTF8((PWCHAR)QueryResultWide->Data.MX.pNameExchange);
398  ConvertedRecord->Data.MX.wPreference = QueryResultWide->Data.MX.wPreference;
399  break;
400 
401  case DNS_TYPE_HINFO:
402  ConvertedRecord->wDataLength = sizeof(DNS_TXT_DATA) + (sizeof(PCHAR) * QueryResultWide->Data.TXT.dwStringCount);
403  ConvertedRecord->Data.TXT.dwStringCount = QueryResultWide->Data.TXT.dwStringCount;
404 
405  if (CodePage == CP_ACP)
406  for (i = 0; i < ConvertedRecord->Data.TXT.dwStringCount; i++)
407  ConvertedRecord->Data.TXT.pStringArray[i] = DnsWToC((PWCHAR)QueryResultWide->Data.TXT.pStringArray[i]);
408  else
409  for (i = 0; i < ConvertedRecord->Data.TXT.dwStringCount; i++)
410  ConvertedRecord->Data.TXT.pStringArray[i] = DnsWToUTF8((PWCHAR)QueryResultWide->Data.TXT.pStringArray[i]);
411 
412  break;
413 
414  case DNS_TYPE_NULL:
415  ConvertedRecord->wDataLength = sizeof(DNS_NULL_DATA) + QueryResultWide->Data.Null.dwByteCount;
416  ConvertedRecord->Data.Null.dwByteCount = QueryResultWide->Data.Null.dwByteCount;
417  memcpy(&ConvertedRecord->Data.Null.Data, &QueryResultWide->Data.Null.Data, QueryResultWide->Data.Null.dwByteCount);
418  break;
419  }
420 
421  if (LastRecord)
422  {
423  LastRecord->pNext = ConvertedRecord;
424  LastRecord = LastRecord->pNext;
425  }
426  else
427  {
428  LastRecord = *QueryResultSet = ConvertedRecord;
429  }
430 
431  QueryResultWide = QueryResultWide->pNext;
432  }
433 
434  if (LastRecord)
435  LastRecord->pNext = 0;
436 
437  /* The name */
438  RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
439  /* The result*/
440  if (QueryResultWide) DnsIntFreeRecordList(QueryResultWide);
441 
442  return Status;
443 }
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
Type
Definition: Type.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
#define DNS_TYPE_A
Definition: windns.h:41
#define CP_ACP
Definition: compat.h:99
#define DNS_TYPE_MG
Definition: windns.h:48
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define DNS_TYPE_HINFO
Definition: windns.h:53
uint16_t * PWCHAR
Definition: typedefs.h:55
#define DNS_TYPE_CNAME
Definition: windns.h:45
enum OPTION_FLAGS Options
Definition: stats.c:44
static PWCHAR DnsCToW(const CHAR *NarrowString)
Definition: query.c:187
#define DNS_TXT_DATA
Definition: windns.h:929
#define DNS_TYPE_MF
Definition: windns.h:44
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
#define CP_UTF8
Definition: nls.h:20
#define DNS_MINFO_DATA
Definition: windns.h:917
DNS_STATUS WINAPI DnsQuery_W(LPCWSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
Definition: query.c:469
smooth NULL
Definition: ftsmooth.c:416
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
Definition: bufpool.h:45
#define DNS_TYPE_MD
Definition: windns.h:43
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define DNS_TYPE_MINFO
Definition: windns.h:54
#define DNS_TYPE_PTR
Definition: windns.h:52
#define DNS_TYPE_MX
Definition: windns.h:55
static PCHAR DnsWToC(const WCHAR *WideString)
Definition: query.c:156
#define DNS_TYPE_MB
Definition: windns.h:47
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define DNS_TYPE_MR
Definition: windns.h:49
#define DNS_RECORD
Definition: windns.h:635
Status
Definition: gdiplustypes.h:24
#define DNS_TYPE_WKS
Definition: windns.h:51
#define DNS_PTR_DATA
Definition: windns.h:923
unsigned int UINT
Definition: ndis.h:50
#define DNS_TYPE_NS
Definition: windns.h:42
#define DNS_TYPE_NULL
Definition: windns.h:50
static PCHAR DnsWToUTF8(const WCHAR *WideString)
Definition: query.c:214
void DnsIntFreeRecordList(PDNS_RECORD ToDelete)
Definition: query.c:889
static PWCHAR DnsUTF8ToW(const CHAR *NarrowString)
Definition: query.c:245
#define DNS_MX_DATA
Definition: windns.h:919
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define PDNS_RECORD
Definition: windns.h:636
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13

Referenced by DnsQuery_A(), and DnsQuery_UTF8().

◆ DnsQuery_UTF8()

DNS_STATUS WINAPI DnsQuery_UTF8 ( LPCSTR  Name,
WORD  Type,
DWORD  Options,
PVOID  Extra,
PDNS_RECORD QueryResultSet,
PVOID Reserved 
)

Definition at line 457 of file query.c.

463 {
464  return DnsQuery_CodePage(CP_UTF8, Name, Type, Options, Extra, QueryResultSet, Reserved);
465 }
Type
Definition: Type.h:6
enum OPTION_FLAGS Options
Definition: stats.c:44
#define CP_UTF8
Definition: nls.h:20
_Reserved_ PVOID Reserved
Definition: winddi.h:3974
DNS_STATUS WINAPI DnsQuery_CodePage(UINT CodePage, LPCSTR Name, WORD Type, DWORD Options, PVOID Extra, PDNS_RECORD *QueryResultSet, PVOID *Reserved)
Definition: query.c:272

Referenced by TestHostName().

◆ DnsQuery_W()

DNS_STATUS WINAPI DnsQuery_W ( LPCWSTR  Name,
WORD  Type,
DWORD  Options,
PVOID  Extra,
PDNS_RECORD QueryResultSet,
PVOID Reserved 
)

Definition at line 469 of file query.c.

475 {
476  DWORD dwRecords = 0;
477  PDNS_RECORDW pRecord = NULL;
478  size_t NameLen, i;
479  DNS_STATUS Status = ERROR_SUCCESS;
480 
481  DPRINT("DnsQuery_W()\n");
482 
483  if ((Name == NULL) ||
484  (QueryResultSet == NULL))
486 
487  *QueryResultSet = NULL;
488 
489  /* Create an A or AAAA record for an IP4 or IP6 address */
490  pRecord = CreateRecordForIpAddress(Name,
491  Type);
492  if (pRecord != NULL)
493  {
494  *QueryResultSet = (PDNS_RECORD)pRecord;
495  return ERROR_SUCCESS;
496  }
497 
498  /*
499  * Check allowed characters
500  * According to RFC a-z,A-Z,0-9,-,_, but can't start or end with - or _
501  */
502  NameLen = wcslen(Name);
503  if (Name[0] == L'-' || Name[0] == L'_' || Name[NameLen - 1] == L'-' ||
504  Name[NameLen - 1] == L'_' || wcsstr(Name, L"..") != NULL)
505  {
506  return ERROR_INVALID_NAME;
507  }
508 
509  i = 0;
510  while (i < NameLen)
511  {
512  if (!((Name[i] >= L'a' && Name[i] <= L'z') ||
513  (Name[i] >= L'A' && Name[i] <= L'Z') ||
514  (Name[i] >= L'0' && Name[i] <= L'9') ||
515  Name[i] == L'-' || Name[i] == L'_' || Name[i] == L'.'))
516  {
518  }
519 
520  i++;
521  }
522 
524  {
526  Name,
527  Type,
528  Options,
529  &dwRecords,
530  (DNS_RECORDW **)QueryResultSet);
531  DPRINT("R_ResolverQuery() returned %lu\n", Status);
532  }
534  {
536  DPRINT("Exception returned %lu\n", Status);
537  }
538  RpcEndExcept;
539 
540  return Status;
541 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define RpcEndExcept
Definition: rpc.h:128
Type
Definition: Type.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
enum OPTION_FLAGS Options
Definition: stats.c:44
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
DWORD __stdcall R_ResolverQuery(_In_ DNSRSLVR_HANDLE pszServerName, _In_ LPCWSTR pszName, _In_ WORD wType, _In_ DWORD dwFlags, _Inout_ DWORD *dwRecords, _Out_ DNS_RECORDW **ppResultRecords)
Definition: rpcserver.c:75
#define RpcTryExcept
Definition: rpc.h:126
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
void DPRINT(...)
Definition: polytest.cpp:61
#define RpcExceptionCode()
Definition: rpc.h:132
unsigned long DWORD
Definition: ntddk_ex.h:95
static const WCHAR L[]
Definition: oid.c:1250
Status
Definition: gdiplustypes.h:24
static PDNS_RECORDW CreateRecordForIpAddress(_In_ PCWSTR Name, _In_ WORD Type)
Definition: query.c:60
#define DNS_ERROR_INVALID_NAME_CHAR
Definition: winerror.h:1877
#define ERROR_INVALID_NAME
Definition: compat.h:93
#define PDNS_RECORD
Definition: windns.h:636
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define RpcExcept(expr)
Definition: rpc.h:127

Referenced by DisplayDnsRecord(), DnsQuery_CodePage(), NSP_GetHostByNameHeapAllocW(), SaBlob_Query(), and TestHostName().

◆ DnsUTF8ToW()

static PWCHAR DnsUTF8ToW ( const CHAR NarrowString)
static

Definition at line 245 of file query.c.

246 {
247  PWCHAR WideString;
248  int WideLen = MultiByteToWideChar(CP_UTF8,
249  0,
250  NarrowString,
251  -1,
252  NULL,
253  0);
254  if (WideLen == 0)
255  return NULL;
256  WideString = RtlAllocateHeap(RtlGetProcessHeap(), 0, WideLen * sizeof(WCHAR));
257  if (WideString == NULL)
258  {
259  return NULL;
260  }
262  0,
263  NarrowString,
264  -1,
265  WideString,
266  WideLen);
267 
268  return WideString;
269 }
uint16_t * PWCHAR
Definition: typedefs.h:55
#define CP_UTF8
Definition: nls.h:20
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MultiByteToWideChar
Definition: compat.h:100

Referenced by DnsQuery_CodePage().

◆ DnsWToC()

static PCHAR DnsWToC ( const WCHAR WideString)
static

Definition at line 156 of file query.c.

157 {
159  int AnsiLen = WideCharToMultiByte(CP_ACP,
160  0,
161  WideString,
162  -1,
163  NULL,
164  0,
165  NULL,
166  0);
167  if (AnsiLen == 0)
168  return NULL;
169  AnsiString = RtlAllocateHeap(RtlGetProcessHeap(), 0, AnsiLen);
170  if (AnsiString == NULL)
171  {
172  return NULL;
173  }
175  0,
176  WideString,
177  -1,
178  AnsiString,
179  AnsiLen,
180  NULL,
181  0);
182 
183  return AnsiString;
184 }
signed char * PCHAR
Definition: retypes.h:7
#define WideCharToMultiByte
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:99
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588

Referenced by DnsQuery_CodePage().

◆ DnsWToUTF8()

static PCHAR DnsWToUTF8 ( const WCHAR WideString)
static

Definition at line 214 of file query.c.

215 {
217  int AnsiLen = WideCharToMultiByte(CP_UTF8,
218  0,
219  WideString,
220  -1,
221  NULL,
222  0,
223  NULL,
224  0);
225  if (AnsiLen == 0)
226  return NULL;
227  AnsiString = RtlAllocateHeap(RtlGetProcessHeap(), 0, AnsiLen);
228  if (AnsiString == NULL)
229  {
230  return NULL;
231  }
233  0,
234  WideString,
235  -1,
236  AnsiString,
237  AnsiLen,
238  NULL,
239  0);
240 
241  return AnsiString;
242 }
signed char * PCHAR
Definition: retypes.h:7
#define WideCharToMultiByte
Definition: compat.h:101
#define CP_UTF8
Definition: nls.h:20
smooth NULL
Definition: ftsmooth.c:416
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588

Referenced by DnsQuery_CodePage().

◆ GetCurrentTimeInSeconds()

DWORD WINAPI GetCurrentTimeInSeconds ( VOID  )

Definition at line 991 of file query.c.

992 {
993  FILETIME Time;
995  ULARGE_INTEGER lTime, lAdj;
996  SYSTEMTIME st = {1970, 1, 0, 1, 0, 0, 0};
997 
999  memcpy(&lAdj, &Adjustment, sizeof(lAdj));
1001  memcpy(&lTime, &Time, sizeof(lTime));
1002  lTime.QuadPart -= lAdj.QuadPart;
1003  return (DWORD)(lTime.QuadPart/10000000ULL);
1004 }
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
ULONGLONG QuadPart
Definition: ms-dtyp.idl:185
_In_ KPRIORITY _In_ LONG Adjustment
Definition: kefuncs.h:438
#define ULL(a, b)
Definition: format_msg.c:27
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:158
static PLARGE_INTEGER Time
Definition: time.c:105

◆ ParseIpv4Address()

static BOOL ParseIpv4Address ( _In_ PCWSTR  AddressString,
_Out_ PIN_ADDR  pAddress 
)
static

Definition at line 21 of file query.c.

24 {
25  PCWSTR pTerminator = NULL;
27 
28  Status = RtlIpv4StringToAddressW(AddressString,
29  TRUE,
30  &pTerminator,
31  pAddress);
32  if (NT_SUCCESS(Status) && pTerminator != NULL && *pTerminator == L'\0')
33  return TRUE;
34 
35  return FALSE;
36 }
const uint16_t * PCWSTR
Definition: typedefs.h:56
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static const WCHAR L[]
Definition: oid.c:1250
Status
Definition: gdiplustypes.h:24
NTSYSAPI NTSTATUS NTAPI RtlIpv4StringToAddressW(_In_ PCWSTR String, _In_ BOOLEAN Strict, _Out_ PCWSTR *Terminator, _Out_ struct in_addr *Addr)
Definition: network.c:405

Referenced by CreateRecordForIpAddress().

◆ ParseIpv6Address()

static BOOL ParseIpv6Address ( _In_ PCWSTR  AddressString,
_Out_ PIN6_ADDR  pAddress 
)
static

Definition at line 41 of file query.c.

44 {
45  PCWSTR pTerminator = NULL;
47 
48  Status = RtlIpv6StringToAddressW(AddressString,
49  &pTerminator,
50  pAddress);
51  if (NT_SUCCESS(Status) && pTerminator != NULL && *pTerminator == L'\0')
52  return TRUE;
53 
54  return FALSE;
55 }
const uint16_t * PCWSTR
Definition: typedefs.h:56
#define TRUE
Definition: types.h:120
LONG NTSTATUS
Definition: precomp.h:26
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
NTSYSAPI NTSTATUS NTAPI RtlIpv6StringToAddressW(_In_ PCWSTR String, _Out_ PCWSTR *Terminator, _Out_ struct in6_addr *Addr)
Definition: network.c:806
static const WCHAR L[]
Definition: oid.c:1250
Status
Definition: gdiplustypes.h:24

Referenced by CreateRecordForIpAddress().

◆ Query_Main()

DNS_STATUS WINAPI Query_Main ( LPCWSTR  Name,
WORD  Type,
DWORD  Options,
PDNS_RECORD QueryResultSet 
)

Definition at line 654 of file query.c.

658 {
659  adns_state astate;
660  int quflags = (Options & DNS_QUERY_NO_RECURSION) == 0 ? adns_qf_search : 0;
661  int adns_error;
662  adns_answer *answer;
663  LPSTR CurrentName;
664  unsigned CNameLoop;
665  PFIXED_INFO network_info;
666  ULONG network_info_blen = 0;
667  DWORD network_info_result;
668  PIP_ADDR_STRING pip;
670  struct in_addr addr;
671  PCHAR HostWithDomainName;
672  PCHAR AnsiName;
673  size_t NameLen = 0;
674 
675  if (Name == NULL)
677  if (QueryResultSet == NULL)
679 
680  *QueryResultSet = NULL;
681 
682  switch (Type)
683  {
684  case DNS_TYPE_A:
685  /* FIXME: how much instead of MAX_PATH? */
686  NameLen = WideCharToMultiByte(CP_ACP,
687  0,
688  Name,
689  -1,
690  NULL,
691  0,
692  NULL,
693  0);
694  AnsiName = RtlAllocateHeap(RtlGetProcessHeap(), 0, NameLen);
695  if (NULL == AnsiName)
696  {
697  return ERROR_OUTOFMEMORY;
698  }
700  0,
701  Name,
702  -1,
703  AnsiName,
704  NameLen,
705  NULL,
706  0);
707  NameLen--;
708 
709  network_info_result = GetNetworkParams(NULL, &network_info_blen);
710  network_info = (PFIXED_INFO)RtlAllocateHeap(RtlGetProcessHeap(), 0, (size_t)network_info_blen);
711  if (NULL == network_info)
712  {
713  return ERROR_OUTOFMEMORY;
714  }
715 
716  network_info_result = GetNetworkParams(network_info, &network_info_blen);
717  if (network_info_result != ERROR_SUCCESS)
718  {
719  RtlFreeHeap(RtlGetProcessHeap(), 0, network_info);
720  return network_info_result;
721  }
722 
723  if ((Address = CheckForCurrentHostname(NameLen != 0 ? AnsiName : network_info->HostName, network_info)) != 0)
724  {
725  size_t TempLen = 2, StringLength = 0;
726  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
727  StringCchLengthA(network_info->HostName, sizeof(network_info->HostName), &StringLength);
728  TempLen += StringLength;
729  StringCchLengthA(network_info->DomainName, sizeof(network_info->DomainName), &StringLength);
730  TempLen += StringLength;
731  HostWithDomainName = (PCHAR)RtlAllocateHeap(RtlGetProcessHeap(), 0, TempLen);
732  StringCchCopyA(HostWithDomainName, TempLen, network_info->HostName);
733  if (network_info->DomainName[0])
734  {
735  StringCchCatA(HostWithDomainName, TempLen, ".");
736  StringCchCatA(HostWithDomainName, TempLen, network_info->DomainName);
737  }
738  RtlFreeHeap(RtlGetProcessHeap(), 0, network_info);
739  *QueryResultSet = (PDNS_RECORD)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
740 
741  if (NULL == *QueryResultSet)
742  {
743  RtlFreeHeap(RtlGetProcessHeap(), 0, HostWithDomainName);
744  return ERROR_OUTOFMEMORY;
745  }
746 
747  (*QueryResultSet)->pNext = NULL;
748  (*QueryResultSet)->wType = Type;
749  (*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA);
750  (*QueryResultSet)->Flags.S.Section = DnsSectionAnswer;
751  (*QueryResultSet)->Flags.S.CharSet = DnsCharSetUnicode;
752  (*QueryResultSet)->Data.A.IpAddress = Address;
753 
754  (*QueryResultSet)->pName = (LPSTR)DnsCToW(HostWithDomainName);
755 
756  RtlFreeHeap(RtlGetProcessHeap(), 0, HostWithDomainName);
757  return (*QueryResultSet)->pName ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
758  }
759 
760  if ((Options & DNS_QUERY_NO_WIRE_QUERY) != 0)
761  {
762  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
763  RtlFreeHeap(RtlGetProcessHeap(), 0, network_info);
764  return ERROR_FILE_NOT_FOUND;
765  }
766 
767  adns_error = adns_init(&astate, adns_if_noenv | adns_if_noerrprint | adns_if_noserverwarn, 0);
768  if (adns_error != adns_s_ok)
769  {
770  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
771  RtlFreeHeap(RtlGetProcessHeap(), 0, network_info);
772  return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
773  }
774  for (pip = &(network_info->DnsServerList); pip; pip = pip->Next)
775  {
776  addr.s_addr = inet_addr(pip->IpAddress.String);
777  if ((addr.s_addr != INADDR_ANY) && (addr.s_addr != INADDR_NONE))
778  adns_addserver(astate, addr);
779  }
780  if (network_info->DomainName[0])
781  {
782  adns_ccf_search(astate, "LOCALDOMAIN", -1, network_info->DomainName);
783  }
784  RtlFreeHeap(RtlGetProcessHeap(), 0, network_info);
785 
786  if (!adns_numservers(astate))
787  {
788  /* There are no servers to query so bail out */
789  adns_finish(astate);
790  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
791  return ERROR_FILE_NOT_FOUND;
792  }
793 
794  /*
795  * adns doesn't resolve chained CNAME records (a CNAME which points to
796  * another CNAME pointing to another... pointing to an A record), according
797  * to a mailing list thread the authors believe that chained CNAME records
798  * are invalid and the DNS entries should be fixed. That's a nice academic
799  * standpoint, but there certainly are chained CNAME records out there,
800  * even some fairly major ones (at the time of this writing
801  * download.mozilla.org is a chained CNAME). Everyone else seems to resolve
802  * these fine, so we should too. So we loop here to try to resolve CNAME
803  * chains ourselves. Of course, there must be a limit to protect against
804  * CNAME loops.
805  */
806 
807 #define CNAME_LOOP_MAX 16
808 
809  CurrentName = AnsiName;
810 
811  for (CNameLoop = 0; CNameLoop < CNAME_LOOP_MAX; CNameLoop++)
812  {
813  adns_error = adns_synchronous(astate, CurrentName, adns_r_addr, quflags, &answer);
814 
815  if (adns_error != adns_s_ok)
816  {
817  adns_finish(astate);
818 
819  if (CurrentName != AnsiName)
820  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
821 
822  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
823  return DnsIntTranslateAdnsToDNS_STATUS(adns_error);
824  }
825 
826  if (answer && answer->rrs.addr)
827  {
828  if (CurrentName != AnsiName)
829  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
830 
831  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
832  *QueryResultSet = (PDNS_RECORD)RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(DNS_RECORD));
833 
834  if (NULL == *QueryResultSet)
835  {
836  adns_finish(astate);
837  return ERROR_OUTOFMEMORY;
838  }
839 
840  (*QueryResultSet)->pNext = NULL;
841  (*QueryResultSet)->wType = Type;
842  (*QueryResultSet)->wDataLength = sizeof(DNS_A_DATA);
843  (*QueryResultSet)->Flags.S.Section = DnsSectionAnswer;
844  (*QueryResultSet)->Flags.S.CharSet = DnsCharSetUnicode;
845  (*QueryResultSet)->Data.A.IpAddress = answer->rrs.addr->addr.inet.sin_addr.s_addr;
846 
847  adns_finish(astate);
848 
849  (*QueryResultSet)->pName = (LPSTR)xstrsave(Name);
850 
851  return (*QueryResultSet)->pName ? ERROR_SUCCESS : ERROR_OUTOFMEMORY;
852  }
853 
854  if (NULL == answer || adns_s_prohibitedcname != answer->status || NULL == answer->cname)
855  {
856  adns_finish(astate);
857 
858  if (CurrentName != AnsiName)
859  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
860 
861  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
862  return ERROR_FILE_NOT_FOUND;
863  }
864 
865  if (CurrentName != AnsiName)
866  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
867 
868  CurrentName = (LPSTR)xstrsaveA(answer->cname);
869 
870  if (!CurrentName)
871  {
872  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
873  adns_finish(astate);
874  return ERROR_OUTOFMEMORY;
875  }
876  }
877 
878  adns_finish(astate);
879  RtlFreeHeap(RtlGetProcessHeap(), 0, AnsiName);
880  RtlFreeHeap(RtlGetProcessHeap(), 0, CurrentName);
881  return ERROR_FILE_NOT_FOUND;
882 
883  default:
884  return ERROR_OUTOFMEMORY; /* XXX arty: find a better error code. */
885  }
886 }
signed char * PCHAR
Definition: retypes.h:7
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define inet_addr(cp)
Definition: inet.h:98
Type
Definition: Type.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
#define WideCharToMultiByte
Definition: compat.h:101
#define DNS_TYPE_A
Definition: windns.h:41
ADNS_API void adns_finish(adns_state ads)
Definition: setup.c:650
#define CP_ACP
Definition: compat.h:99
IP_ADDRESS_STRING IpAddress
Definition: iptypes.h:47
struct _IP_ADDR_STRING * Next
Definition: iptypes.h:46
#define INADDR_NONE
Definition: tcp.c:42
BOOLEAN NTAPI RtlFreeHeap(IN PVOID HeapHandle, IN ULONG Flags, IN PVOID HeapBase)
Definition: heap.c:606
#define INADDR_ANY
Definition: StrAddr.c:4
char String[4 *4]
Definition: iptypes.h:42
adns_rr_addr * addr
Definition: adns.h:322
char * LPSTR
Definition: xmlstorage.h:182
enum OPTION_FLAGS Options
Definition: stats.c:44
static PWCHAR DnsCToW(const CHAR *NarrowString)
Definition: query.c:187
ADNS_API void adns_ccf_search(adns_state state, const char *fn, int lno, const char *buf)
Definition: setup.c:715
#define DNS_QUERY_NO_RECURSION
Definition: windns.h:11
DWORD IP4_ADDRESS
Definition: windns.h:36
STRSAFEAPI StringCchCatA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:320
union adns_answer::@3870 rrs
DWORD WINAPI GetNetworkParams(PFIXED_INFO pFixedInfo, PULONG pOutBufLen)
smooth NULL
Definition: ftsmooth.c:416
static WCHAR Address[46]
Definition: ping.c:68
char DomainName[MAX_DOMAIN_NAME_LEN+4]
Definition: iptypes.h:82
WCHAR * xstrsave(const WCHAR *str)
Definition: query.c:544
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
IP4_ADDRESS CheckForCurrentHostname(CONST CHAR *Name, PFIXED_INFO network_info)
Definition: query.c:582
#define PCHAR
Definition: match.c:90
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
__kernel_size_t size_t
Definition: linux.h:237
CHAR * xstrsaveA(const CHAR *str)
Definition: query.c:562
ADNS_API int adns_numservers(adns_state state)
Definition: setup.c:718
Definition: tcpip.h:125
DNS_STATUS DnsIntTranslateAdnsToDNS_STATUS(int Status)
Definition: adns.c:17
unsigned long DWORD
Definition: ntddk_ex.h:95
#define CNAME_LOOP_MAX
ADNS_API void adns_addserver(adns_state state, struct in_addr server)
Definition: setup.c:712
adns_status status
Definition: adns.h:311
GLenum const GLvoid * addr
Definition: glext.h:9621
char * cname
Definition: adns.h:312
char HostName[MAX_HOSTNAME_LEN+4]
Definition: iptypes.h:81
struct FIXED_INFO * PFIXED_INFO
#define DNS_RECORD
Definition: windns.h:635
STRSAFEAPI StringCchCopyA(STRSAFE_LPSTR pszDest, size_t cchDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:145
STRSAFEAPI StringCchLengthA(STRSAFE_LPCSTR psz, size_t cchMax, size_t *pcchLength)
Definition: strsafe.h:832
ADNS_API int adns_init(adns_state *newstate_r, adns_initflags flags, FILE *diagfile)
Definition: setup.c:568
struct sockaddr_in inet
Definition: adns.h:271
#define DNS_QUERY_NO_WIRE_QUERY
Definition: windns.h:13
int adns_synchronous(adns_state ads, const char *owner, adns_rrtype type, adns_queryflags flags, adns_answer **answer_r)
Definition: query.c:314
unsigned int ULONG
Definition: retypes.h:1
IP_ADDR_STRING DnsServerList
Definition: iptypes.h:84
#define PDNS_RECORD
Definition: windns.h:636
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
union adns_rr_addr::@3869 addr

Referenced by R_ResolverQuery().

◆ xstrsave()

WCHAR* xstrsave ( const WCHAR str)

Definition at line 544 of file query.c.

545 {
546  WCHAR *p;
547  size_t len = 0;
548 
549  /* FIXME: how much instead of MAX_PATH? */
551  len+=sizeof(WCHAR);
552 
553  p = RtlAllocateHeap(RtlGetProcessHeap(), 0, len);
554 
555  if (p)
556  StringCbCopyW(p, len, str);
557 
558  return p;
559 }
STRSAFEAPI StringCbLengthW(STRSAFE_LPCWSTR psz, size_t cbMax, size_t *pcbLength)
Definition: strsafe.h:876
const WCHAR * str
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define MAX_PATH
Definition: compat.h:26
GLenum GLsizei len
Definition: glext.h:6722
GLfloat GLfloat p
Definition: glext.h:8902
STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:166

Referenced by of_asynch_id(), of_ptr(), prep_query(), query_do(), and Query_Main().

◆ xstrsaveA()

CHAR* xstrsaveA ( const CHAR str)

Definition at line 562 of file query.c.

563 {
564  CHAR *p;
565  size_t len = 0;
566 
567  /* FIXME: how much instead of MAX_PATH? */
569  len++;
570 
571  p = RtlAllocateHeap(RtlGetProcessHeap(), 0, len);
572 
573  if (p)
574  StringCbCopyA(p, len, str);
575 
576  return p;
577 }
char CHAR
Definition: xmlstorage.h:175
const WCHAR * str
STRSAFEAPI StringCbCopyA(STRSAFE_LPSTR pszDest, size_t cbDest, STRSAFE_LPCSTR pszSrc)
Definition: strsafe.h:161
PVOID NTAPI RtlAllocateHeap(IN PVOID HeapHandle, IN ULONG Flags, IN SIZE_T Size)
Definition: heap.c:588
#define MAX_PATH
Definition: compat.h:26
GLenum GLsizei len
Definition: glext.h:6722
STRSAFEAPI StringCbLengthA(STRSAFE_LPCSTR psz, size_t cbMax, size_t *pcbLength)
Definition: strsafe.h:859
GLfloat GLfloat p
Definition: glext.h:8902

Referenced by Query_Main().