Delphi/MiTec
Delphi/MiTec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
MiTec/Common/MiTeC_DNS.pas

1561 lines
48 KiB
ObjectPascal
Raw Permalink Normal View History

Init
2024-01-02 00:01:59 +01:00
{*******************************************************}
{ MiTeC Common Routines }
{ Domain Naming Services API }
{ }
{ }
{ Copyright (c) 1997-2021 Michal Mutl }
{ }
{*******************************************************}
{$INCLUDE Compilers.inc}
unit MiTeC_DNS;
interface
uses {$IFDEF RAD9PLUS}
WinAPI.Windows, System.SysUtils, WinAPI.WinSock,
{$ELSE}
Windows, SysUtils, WinSock,
{$ENDIF}
MiTeC_Ws2_32, MiTeC_Windows;
type
DNS_STATUS = Longint;
{$EXTERNALSYM DNS_STATUS}
PDNS_STATUS = ^DNS_STATUS;
{$EXTERNALSYM PDNS_STATUS}
TDnsStatus = DNS_STATUS;
PDnsStatus = PDNS_STATUS;
IP4_ADDRESS = DWORD;
{$EXTERNALSYM IP4_ADDRESS}
PIP4_ADDRESS = ^IP4_ADDRESS;
{$EXTERNALSYM PIP4_ADDRESS}
TIP4Address = IP4_ADDRESS;
PIP4Address = PIP4_ADDRESS;
const
SIZEOF_IP4_ADDRESS = 4;
{$EXTERNALSYM SIZEOF_IP4_ADDRESS}
IP4_ADDRESS_STRING_LENGTH = 15;
{$EXTERNALSYM IP4_ADDRESS_STRING_LENGTH}
IP4_ADDRESS_STRING_BUFFER_LENGTH = 16;
{$EXTERNALSYM IP4_ADDRESS_STRING_BUFFER_LENGTH}
type
PIP4_ARRAY = ^IP4_ARRAY;
{$EXTERNALSYM PIP4_ARRAY}
_IP4_ARRAY = record
AddrCount: DWORD;
AddrArray: array [0..0] of IP4_ADDRESS;
end;
{$EXTERNALSYM _IP4_ARRAY}
IP4_ARRAY = _IP4_ARRAY;
{$EXTERNALSYM IP4_ARRAY}
TIp4Array = IP4_ARRAY;
PIp4Array = PIP4_ARRAY;
PIP6_ADDRESS = ^IP6_ADDRESS;
{$EXTERNALSYM PIP6_ADDRESS}
IP6_ADDRESS = record
case Integer of
0: (IP6Qword: array [0..1] of QWORD);
1: (IP6Dword: array [0..3] of DWORD);
2: (IP6Word: array [0..7] of WORD);
3: (IP6Byte: array [0..15] of BYTE);
4: (In6: IN6_ADDR);
end;
{$EXTERNALSYM IP6_ADDRESS}
TIp6Address = IP6_ADDRESS;
PIp6Address = PIP6_ADDRESS;
DNS_IP6_ADDRESS = IP6_ADDRESS;
{$EXTERNALSYM DNS_IP6_ADDRESS}
PDNS_IP6_ADDRESS = ^IP6_ADDRESS;
{$EXTERNALSYM PDNS_IP6_ADDRESS}
TDnsIp6Address = DNS_IP6_ADDRESS;
PDnsIp6Address = PDNS_IP6_ADDRESS;
const
IP6_ADDRESS_STRING_LENGTH = 47;
{$EXTERNALSYM IP6_ADDRESS_STRING_LENGTH}
IP6_ADDRESS_STRING_BUFFER_LENGTH = 48;
{$EXTERNALSYM IP6_ADDRESS_STRING_BUFFER_LENGTH}
IPV6_ADDRESS_STRING_LENGTH = IP6_ADDRESS_STRING_LENGTH;
{$EXTERNALSYM IPV6_ADDRESS_STRING_LENGTH}
procedure INLINE_WORD_FLIP(var Out_: WORD; In_: WORD);
{$EXTERNALSYM INLINE_WORD_FLIP}
procedure INLINE_HTONS(var Out_: WORD; In_: WORD);
{$EXTERNALSYM INLINE_HTONS}
procedure INLINE_NTOHS(var Out_: WORD; In_: WORD);
{$EXTERNALSYM INLINE_NTOHS}
procedure INLINE_DWORD_FLIP(var Out_: DWORD; In_: DWORD);
{$EXTERNALSYM INLINE_DWORD_FLIP}
procedure INLINE_NTOHL(var Out_: DWORD; In_: DWORD);
{$EXTERNALSYM INLINE_NTOHL}
procedure INLINE_HTONL(var Out_: DWORD; In_: DWORD);
{$EXTERNALSYM INLINE_HTONL}
procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
{$EXTERNALSYM INLINE_WRITE_FLIPPED_WORD}
procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
{$EXTERNALSYM INLINE_WRITE_FLIPPED_DWORD}
const
DNS_PORT_HOST_ORDER = $0035; // port 53
{$EXTERNALSYM DNS_PORT_HOST_ORDER}
DNS_PORT_NET_ORDER = $3500;
{$EXTERNALSYM DNS_PORT_NET_ORDER}
DNS_RFC_MAX_UDP_PACKET_LENGTH = 512;
{$EXTERNALSYM DNS_RFC_MAX_UDP_PACKET_LENGTH}
DNS_MAX_NAME_LENGTH = 255;
{$EXTERNALSYM DNS_MAX_NAME_LENGTH}
DNS_MAX_LABEL_LENGTH = 63;
{$EXTERNALSYM DNS_MAX_LABEL_LENGTH}
DNS_MAX_NAME_BUFFER_LENGTH = 256;
{$EXTERNALSYM DNS_MAX_NAME_BUFFER_LENGTH}
DNS_MAX_LABEL_BUFFER_LENGTH = 64;
{$EXTERNALSYM DNS_MAX_LABEL_BUFFER_LENGTH}
DNS_IP4_REVERSE_DOMAIN_STRING = 'in-addr.arpa.';
{$EXTERNALSYM DNS_IP4_REVERSE_DOMAIN_STRING}
//DNS_MAX_IP4_REVERSE_NAME_LENGTH = IP_ADDRESS_STRING_LENGTH + 1 + SizeOf(DNS_IP4_REVERSE_DOMAIN_STRING);
//{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_LENGTH}
//DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP4_REVERSE_NAME_LENGTH + 1;
//{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH}
DNS_IP6_REVERSE_DOMAIN_STRING = 'ip6.int.';
{$EXTERNALSYM DNS_IP6_REVERSE_DOMAIN_STRING}
DNS_MAX_IP6_REVERSE_NAME_LENGTH = 64 + SizeOf(DNS_IP6_REVERSE_DOMAIN_STRING);
{$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_LENGTH}
DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP6_REVERSE_NAME_LENGTH + 1;
{$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH}
DNS_MAX_REVERSE_NAME_LENGTH = DNS_MAX_IP6_REVERSE_NAME_LENGTH;
{$EXTERNALSYM DNS_MAX_REVERSE_NAME_LENGTH}
DNS_MAX_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH;
{$EXTERNALSYM DNS_MAX_REVERSE_NAME_BUFFER_LENGTH}
DNS_MAX_TEXT_STRING_LENGTH = 255;
{$EXTERNALSYM DNS_MAX_TEXT_STRING_LENGTH}
type
_DNS_HEADER = packed record
Xid: WORD;
Flags: Byte;
//BYTE RecursionDesired : 1;
//BYTE Truncation : 1;
//BYTE Authoritative : 1;
//BYTE Opcode : 4;
//BYTE IsResponse : 1;
Flags2: Byte;
//BYTE ResponseCode : 4;
//BYTE Reserved : 3;
//BYTE RecursionAvailable : 1;
QuestionCount: WORD;
AnswerCount: WORD;
NameServerCount: WORD;
AdditionalCount: WORD;
end;
{$EXTERNALSYM _DNS_HEADER}
DNS_HEADER = _DNS_HEADER;
{$EXTERNALSYM DNS_HEADER}
PDNS_HEADER = ^DNS_HEADER;
{$EXTERNALSYM PDNS_HEADER}
TDnsHeader = DNS_HEADER;
PDnsHeader = PDNS_HEADER;
function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
{$EXTERNALSYM DNS_HEADER_FLAGS}
procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
{$EXTERNALSYM DNS_BYTE_FLIP_HEADER_COUNTS}
const
DNS_OFFSET_TO_QUESTION_NAME = SizeOf(DNS_HEADER);
{$EXTERNALSYM DNS_OFFSET_TO_QUESTION_NAME}
DNS_COMPRESSED_QUESTION_NAME = $C00C;
{$EXTERNALSYM DNS_COMPRESSED_QUESTION_NAME}
type
PDNS_WIRE_QUESTION = ^DNS_WIRE_QUESTION;
{$EXTERNALSYM PDNS_WIRE_QUESTION}
_DNS_WIRE_QUESTION = packed record
// Preceded by question name
QuestionType: WORD;
QuestionClass: WORD;
end;
{$EXTERNALSYM _DNS_WIRE_QUESTION}
DNS_WIRE_QUESTION = _DNS_WIRE_QUESTION;
{$EXTERNALSYM DNS_WIRE_QUESTION}
TDnsWireQuestion = DNS_WIRE_QUESTION;
PDnsWireQuestion = PDNS_WIRE_QUESTION;
PDNS_WIRE_RECORD = ^DNS_WIRE_RECORD;
{$EXTERNALSYM PDNS_WIRE_RECORD}
_DNS_WIRE_RECORD = packed record
// Preceded by record owner name
RecordType: WORD;
RecordClass: WORD;
TimeToLive: DWORD;
DataLength: WORD;
// Followed by record data
end;
{$EXTERNALSYM _DNS_WIRE_RECORD}
DNS_WIRE_RECORD = _DNS_WIRE_RECORD;
{$EXTERNALSYM DNS_WIRE_RECORD}
TDnsWireRecord = DNS_WIRE_RECORD;
PDnsWireRecord = PDNS_WIRE_RECORD;
const
DNS_OPCODE_QUERY = 0; // Query
{$EXTERNALSYM DNS_OPCODE_QUERY}
DNS_OPCODE_IQUERY = 1; // Obsolete: IP to name
{$EXTERNALSYM DNS_OPCODE_IQUERY}
DNS_OPCODE_SERVER_STATUS = 2; // Obsolete: DNS ping
{$EXTERNALSYM DNS_OPCODE_SERVER_STATUS}
DNS_OPCODE_UNKNOWN = 3; // Unknown
{$EXTERNALSYM DNS_OPCODE_UNKNOWN}
DNS_OPCODE_NOTIFY = 4; // Notify
{$EXTERNALSYM DNS_OPCODE_NOTIFY}
DNS_OPCODE_UPDATE = 5; // Dynamic Update
{$EXTERNALSYM DNS_OPCODE_UPDATE}
DNS_RCODE_NOERROR = 0;
{$EXTERNALSYM DNS_RCODE_NOERROR}
DNS_RCODE_FORMERR = 1; // Format error
{$EXTERNALSYM DNS_RCODE_FORMERR}
DNS_RCODE_SERVFAIL = 2; // Server failure
{$EXTERNALSYM DNS_RCODE_SERVFAIL}
DNS_RCODE_NXDOMAIN = 3; // Name error
{$EXTERNALSYM DNS_RCODE_NXDOMAIN}
DNS_RCODE_NOTIMPL = 4; // Not implemented
{$EXTERNALSYM DNS_RCODE_NOTIMPL}
DNS_RCODE_REFUSED = 5; // Refused
{$EXTERNALSYM DNS_RCODE_REFUSED}
DNS_RCODE_YXDOMAIN = 6; // Domain name should not exist
{$EXTERNALSYM DNS_RCODE_YXDOMAIN}
DNS_RCODE_YXRRSET = 7; // RR set should not exist
{$EXTERNALSYM DNS_RCODE_YXRRSET}
DNS_RCODE_NXRRSET = 8; // RR set does not exist
{$EXTERNALSYM DNS_RCODE_NXRRSET}
DNS_RCODE_NOTAUTH = 9; // Not authoritative for zone
{$EXTERNALSYM DNS_RCODE_NOTAUTH}
DNS_RCODE_NOTZONE = 10; // Name is not zone
{$EXTERNALSYM DNS_RCODE_NOTZONE}
DNS_RCODE_MAX = 15;
{$EXTERNALSYM DNS_RCODE_MAX}
DNS_RCODE_BADVERS = 16; // Bad EDNS version
{$EXTERNALSYM DNS_RCODE_BADVERS}
DNS_RCODE_BADSIG = 16; // Bad signature
{$EXTERNALSYM DNS_RCODE_BADSIG}
DNS_RCODE_BADKEY = 17; // Bad key
{$EXTERNALSYM DNS_RCODE_BADKEY}
DNS_RCODE_BADTIME = 18; // Bad timestamp
{$EXTERNALSYM DNS_RCODE_BADTIME}
DNS_RCODE_NO_ERROR = DNS_RCODE_NOERROR;
{$EXTERNALSYM DNS_RCODE_NO_ERROR}
DNS_RCODE_FORMAT_ERROR = DNS_RCODE_FORMERR;
{$EXTERNALSYM DNS_RCODE_FORMAT_ERROR}
DNS_RCODE_SERVER_FAILURE = DNS_RCODE_SERVFAIL;
{$EXTERNALSYM DNS_RCODE_SERVER_FAILURE}
DNS_RCODE_NAME_ERROR = DNS_RCODE_NXDOMAIN;
{$EXTERNALSYM DNS_RCODE_NAME_ERROR}
DNS_RCODE_NOT_IMPLEMENTED = DNS_RCODE_NOTIMPL;
{$EXTERNALSYM DNS_RCODE_NOT_IMPLEMENTED}
DNS_CLASS_INTERNET = $0001; // 1
{$EXTERNALSYM DNS_CLASS_INTERNET}
DNS_CLASS_CSNET = $0002; // 2
{$EXTERNALSYM DNS_CLASS_CSNET}
DNS_CLASS_CHAOS = $0003; // 3
{$EXTERNALSYM DNS_CLASS_CHAOS}
DNS_CLASS_HESIOD = $0004; // 4
{$EXTERNALSYM DNS_CLASS_HESIOD}
DNS_CLASS_NONE = $00fe; // 254
{$EXTERNALSYM DNS_CLASS_NONE}
DNS_CLASS_ALL = $00ff; // 255
{$EXTERNALSYM DNS_CLASS_ALL}
DNS_CLASS_ANY = $00ff; // 255
{$EXTERNALSYM DNS_CLASS_ANY}
DNS_RCLASS_INTERNET = $0100; // 1
{$EXTERNALSYM DNS_RCLASS_INTERNET}
DNS_RCLASS_CSNET = $0200; // 2
{$EXTERNALSYM DNS_RCLASS_CSNET}
DNS_RCLASS_CHAOS = $0300; // 3
{$EXTERNALSYM DNS_RCLASS_CHAOS}
DNS_RCLASS_HESIOD = $0400; // 4
{$EXTERNALSYM DNS_RCLASS_HESIOD}
DNS_RCLASS_NONE = $fe00; // 254
{$EXTERNALSYM DNS_RCLASS_NONE}
DNS_RCLASS_ALL = $ff00; // 255
{$EXTERNALSYM DNS_RCLASS_ALL}
DNS_RCLASS_ANY = $ff00; // 255
{$EXTERNALSYM DNS_RCLASS_ANY}
DNS_TYPE_ZERO = $0000;
{$EXTERNALSYM DNS_TYPE_ZERO}
// RFC 1034/1035
DNS_TYPE_A = $0001; // 1
{$EXTERNALSYM DNS_TYPE_A}
DNS_TYPE_NS = $0002; // 2
{$EXTERNALSYM DNS_TYPE_NS}
DNS_TYPE_MD = $0003; // 3
{$EXTERNALSYM DNS_TYPE_MD}
DNS_TYPE_MF = $0004; // 4
{$EXTERNALSYM DNS_TYPE_MF}
DNS_TYPE_CNAME = $0005; // 5
{$EXTERNALSYM DNS_TYPE_CNAME}
DNS_TYPE_SOA = $0006; // 6
{$EXTERNALSYM DNS_TYPE_SOA}
DNS_TYPE_MB = $0007; // 7
{$EXTERNALSYM DNS_TYPE_MB}
DNS_TYPE_MG = $0008; // 8
{$EXTERNALSYM DNS_TYPE_MG}
DNS_TYPE_MR = $0009; // 9
{$EXTERNALSYM DNS_TYPE_MR}
DNS_TYPE_NULL = $000a; // 10
{$EXTERNALSYM DNS_TYPE_NULL}
DNS_TYPE_WKS = $000b; // 11
{$EXTERNALSYM DNS_TYPE_WKS}
DNS_TYPE_PTR = $000c; // 12
{$EXTERNALSYM DNS_TYPE_PTR}
DNS_TYPE_HINFO = $000d; // 13
{$EXTERNALSYM DNS_TYPE_HINFO}
DNS_TYPE_MINFO = $000e; // 14
{$EXTERNALSYM DNS_TYPE_MINFO}
DNS_TYPE_MX = $000f; // 15
{$EXTERNALSYM DNS_TYPE_MX}
DNS_TYPE_TEXT = $0010; // 16
{$EXTERNALSYM DNS_TYPE_TEXT}
// RFC 1183
DNS_TYPE_RP = $0011; // 17
{$EXTERNALSYM DNS_TYPE_RP}
DNS_TYPE_AFSDB = $0012; // 18
{$EXTERNALSYM DNS_TYPE_AFSDB}
DNS_TYPE_X25 = $0013; // 19
{$EXTERNALSYM DNS_TYPE_X25}
DNS_TYPE_ISDN = $0014; // 20
{$EXTERNALSYM DNS_TYPE_ISDN}
DNS_TYPE_RT = $0015; // 21
{$EXTERNALSYM DNS_TYPE_RT}
// RFC 1348
DNS_TYPE_NSAP = $0016; // 22
{$EXTERNALSYM DNS_TYPE_NSAP}
DNS_TYPE_NSAPPTR = $0017; // 23
{$EXTERNALSYM DNS_TYPE_NSAPPTR}
// RFC 2065 (DNS security)
DNS_TYPE_SIG = $0018; // 24
{$EXTERNALSYM DNS_TYPE_SIG}
DNS_TYPE_KEY = $0019; // 25
{$EXTERNALSYM DNS_TYPE_KEY}
// RFC 1664 (X.400 mail)
DNS_TYPE_PX = $001a; // 26
{$EXTERNALSYM DNS_TYPE_PX}
// RFC 1712 (Geographic position)
DNS_TYPE_GPOS = $001b; // 27
{$EXTERNALSYM DNS_TYPE_GPOS}
// RFC 1886 (IPv6 Address)
DNS_TYPE_AAAA = $001c; // 28
{$EXTERNALSYM DNS_TYPE_AAAA}
// RFC 1876 (Geographic location)
DNS_TYPE_LOC = $001d; // 29
{$EXTERNALSYM DNS_TYPE_LOC}
// RFC 2065 (Secure negative response)
DNS_TYPE_NXT = $001e; // 30
{$EXTERNALSYM DNS_TYPE_NXT}
// Patton (Endpoint Identifier)
DNS_TYPE_EID = $001f; // 31
{$EXTERNALSYM DNS_TYPE_EID}
// Patton (Nimrod Locator)
DNS_TYPE_NIMLOC = $0020; // 32
{$EXTERNALSYM DNS_TYPE_NIMLOC}
// RFC 2052 (Service location)
DNS_TYPE_SRV = $0021; // 33
{$EXTERNALSYM DNS_TYPE_SRV}
// ATM Standard something-or-another (ATM Address)
DNS_TYPE_ATMA = $0022; // 34
{$EXTERNALSYM DNS_TYPE_ATMA}
// RFC 2168 (Naming Authority Pointer)
DNS_TYPE_NAPTR = $0023; // 35
{$EXTERNALSYM DNS_TYPE_NAPTR}
// RFC 2230 (Key Exchanger)
DNS_TYPE_KX = $0024; // 36
{$EXTERNALSYM DNS_TYPE_KX}
// RFC 2538 (CERT)
DNS_TYPE_CERT = $0025; // 37
{$EXTERNALSYM DNS_TYPE_CERT}
// A6 Draft (A6)
DNS_TYPE_A6 = $0026; // 38
{$EXTERNALSYM DNS_TYPE_A6}
// DNAME Draft (DNAME)
DNS_TYPE_DNAME = $0027; // 39
{$EXTERNALSYM DNS_TYPE_DNAME}
// Eastlake (Kitchen Sink)
DNS_TYPE_SINK = $0028; // 40
{$EXTERNALSYM DNS_TYPE_SINK}
// RFC 2671 (EDNS OPT)
DNS_TYPE_OPT = $0029; // 41
{$EXTERNALSYM DNS_TYPE_OPT}
DNS_TYPE_UINFO = $0064; // 100
{$EXTERNALSYM DNS_TYPE_UINFO}
DNS_TYPE_UID = $0065; // 101
{$EXTERNALSYM DNS_TYPE_UID}
DNS_TYPE_GID = $0066; // 102
{$EXTERNALSYM DNS_TYPE_GID}
DNS_TYPE_UNSPEC = $0067; // 103
{$EXTERNALSYM DNS_TYPE_UNSPEC}
DNS_TYPE_ADDRS = $00f8; // 248
{$EXTERNALSYM DNS_TYPE_ADDRS}
DNS_TYPE_TKEY = $00f9; // 249
{$EXTERNALSYM DNS_TYPE_TKEY}
DNS_TYPE_TSIG = $00fa; // 250
{$EXTERNALSYM DNS_TYPE_TSIG}
DNS_TYPE_IXFR = $00fb; // 251
{$EXTERNALSYM DNS_TYPE_IXFR}
DNS_TYPE_AXFR = $00fc; // 252
{$EXTERNALSYM DNS_TYPE_AXFR}
DNS_TYPE_MAILB = $00fd; // 253
{$EXTERNALSYM DNS_TYPE_MAILB}
DNS_TYPE_MAILA = $00fe; // 254
{$EXTERNALSYM DNS_TYPE_MAILA}
DNS_TYPE_ALL = $00ff; // 255
{$EXTERNALSYM DNS_TYPE_ALL}
DNS_TYPE_ANY = $00ff; // 255
{$EXTERNALSYM DNS_TYPE_ANY}
DNS_TYPE_WINS = $ff01; // 64K - 255
{$EXTERNALSYM DNS_TYPE_WINS}
DNS_TYPE_WINSR = $ff02; // 64K - 254
{$EXTERNALSYM DNS_TYPE_WINSR}
DNS_TYPE_NBSTAT = DNS_TYPE_WINSR;
{$EXTERNALSYM DNS_TYPE_NBSTAT}
DNS_RTYPE_A = $0100; // 1
{$EXTERNALSYM DNS_RTYPE_A}
DNS_RTYPE_NS = $0200; // 2
{$EXTERNALSYM DNS_RTYPE_NS}
DNS_RTYPE_MD = $0300; // 3
{$EXTERNALSYM DNS_RTYPE_MD}
DNS_RTYPE_MF = $0400; // 4
{$EXTERNALSYM DNS_RTYPE_MF}
DNS_RTYPE_CNAME = $0500; // 5
{$EXTERNALSYM DNS_RTYPE_CNAME}
DNS_RTYPE_SOA = $0600; // 6
{$EXTERNALSYM DNS_RTYPE_SOA}
DNS_RTYPE_MB = $0700; // 7
{$EXTERNALSYM DNS_RTYPE_MB}
DNS_RTYPE_MG = $0800; // 8
{$EXTERNALSYM DNS_RTYPE_MG}
DNS_RTYPE_MR = $0900; // 9
{$EXTERNALSYM DNS_RTYPE_MR}
DNS_RTYPE_NULL = $0a00; // 10
{$EXTERNALSYM DNS_RTYPE_NULL}
DNS_RTYPE_WKS = $0b00; // 11
{$EXTERNALSYM DNS_RTYPE_WKS}
DNS_RTYPE_PTR = $0c00; // 12
{$EXTERNALSYM DNS_RTYPE_PTR}
DNS_RTYPE_HINFO = $0d00; // 13
{$EXTERNALSYM DNS_RTYPE_HINFO}
DNS_RTYPE_MINFO = $0e00; // 14
{$EXTERNALSYM DNS_RTYPE_MINFO}
DNS_RTYPE_MX = $0f00; // 15
{$EXTERNALSYM DNS_RTYPE_MX}
DNS_RTYPE_TEXT = $1000; // 16
{$EXTERNALSYM DNS_RTYPE_TEXT}
DNS_RTYPE_RP = $1100; // 17
{$EXTERNALSYM DNS_RTYPE_RP}
DNS_RTYPE_AFSDB = $1200; // 18
{$EXTERNALSYM DNS_RTYPE_AFSDB}
DNS_RTYPE_X25 = $1300; // 19
{$EXTERNALSYM DNS_RTYPE_X25}
DNS_RTYPE_ISDN = $1400; // 20
{$EXTERNALSYM DNS_RTYPE_ISDN}
DNS_RTYPE_RT = $1500; // 21
{$EXTERNALSYM DNS_RTYPE_RT}
DNS_RTYPE_NSAP = $1600; // 22
{$EXTERNALSYM DNS_RTYPE_NSAP}
DNS_RTYPE_NSAPPTR = $1700; // 23
{$EXTERNALSYM DNS_RTYPE_NSAPPTR}
DNS_RTYPE_SIG = $1800; // 24
{$EXTERNALSYM DNS_RTYPE_SIG}
DNS_RTYPE_KEY = $1900; // 25
{$EXTERNALSYM DNS_RTYPE_KEY}
DNS_RTYPE_PX = $1a00; // 26
{$EXTERNALSYM DNS_RTYPE_PX}
DNS_RTYPE_GPOS = $1b00; // 27
{$EXTERNALSYM DNS_RTYPE_GPOS}
DNS_RTYPE_AAAA = $1c00; // 28
{$EXTERNALSYM DNS_RTYPE_AAAA}
DNS_RTYPE_LOC = $1d00; // 29
{$EXTERNALSYM DNS_RTYPE_LOC}
DNS_RTYPE_NXT = $1e00; // 30
{$EXTERNALSYM DNS_RTYPE_NXT}
DNS_RTYPE_EID = $1f00; // 31
{$EXTERNALSYM DNS_RTYPE_EID}
DNS_RTYPE_NIMLOC = $2000; // 32
{$EXTERNALSYM DNS_RTYPE_NIMLOC}
DNS_RTYPE_SRV = $2100; // 33
{$EXTERNALSYM DNS_RTYPE_SRV}
DNS_RTYPE_ATMA = $2200; // 34
{$EXTERNALSYM DNS_RTYPE_ATMA}
DNS_RTYPE_NAPTR = $2300; // 35
{$EXTERNALSYM DNS_RTYPE_NAPTR}
DNS_RTYPE_KX = $2400; // 36
{$EXTERNALSYM DNS_RTYPE_KX}
DNS_RTYPE_CERT = $2500; // 37
{$EXTERNALSYM DNS_RTYPE_CERT}
DNS_RTYPE_A6 = $2600; // 38
{$EXTERNALSYM DNS_RTYPE_A6}
DNS_RTYPE_DNAME = $2700; // 39
{$EXTERNALSYM DNS_RTYPE_DNAME}
DNS_RTYPE_SINK = $2800; // 40
{$EXTERNALSYM DNS_RTYPE_SINK}
DNS_RTYPE_OPT = $2900; // 41
{$EXTERNALSYM DNS_RTYPE_OPT}
DNS_RTYPE_UINFO = $6400; // 100
{$EXTERNALSYM DNS_RTYPE_UINFO}
DNS_RTYPE_UID = $6500; // 101
{$EXTERNALSYM DNS_RTYPE_UID}
DNS_RTYPE_GID = $6600; // 102
{$EXTERNALSYM DNS_RTYPE_GID}
DNS_RTYPE_UNSPEC = $6700; // 103
{$EXTERNALSYM DNS_RTYPE_UNSPEC}
DNS_RTYPE_TKEY = $f900; // 249
{$EXTERNALSYM DNS_RTYPE_TKEY}
DNS_RTYPE_TSIG = $fa00; // 250
{$EXTERNALSYM DNS_RTYPE_TSIG}
DNS_RTYPE_IXFR = $fb00; // 251
{$EXTERNALSYM DNS_RTYPE_IXFR}
DNS_RTYPE_AXFR = $fc00; // 252
{$EXTERNALSYM DNS_RTYPE_AXFR}
DNS_RTYPE_MAILB = $fd00; // 253
{$EXTERNALSYM DNS_RTYPE_MAILB}
DNS_RTYPE_MAILA = $fe00; // 254
{$EXTERNALSYM DNS_RTYPE_MAILA}
DNS_RTYPE_ALL = $ff00; // 255
{$EXTERNALSYM DNS_RTYPE_ALL}
DNS_RTYPE_ANY = $ff00; // 255
{$EXTERNALSYM DNS_RTYPE_ANY}
DNS_RTYPE_WINS = $01ff; // 64K - 255
{$EXTERNALSYM DNS_RTYPE_WINS}
DNS_RTYPE_WINSR = $02ff; // 64K - 254
{$EXTERNALSYM DNS_RTYPE_WINSR}
DNS_ATMA_FORMAT_E164 = ATM_E164;
{$EXTERNALSYM DNS_ATMA_FORMAT_E164}
DNS_ATMA_FORMAT_AESA = ATM_AESA;
{$EXTERNALSYM DNS_ATMA_FORMAT_AESA}
DNS_ATMA_MAX_ADDR_LENGTH = ATM_ADDR_SIZE;
{$EXTERNALSYM DNS_ATMA_MAX_ADDR_LENGTH}
DNS_ATMA_AESA_ADDR_LENGTH = 20;
{$EXTERNALSYM DNS_ATMA_AESA_ADDR_LENGTH}
DNS_ATMA_MAX_RECORD_LENGTH = DNS_ATMA_MAX_ADDR_LENGTH + 1;
{$EXTERNALSYM DNS_ATMA_MAX_RECORD_LENGTH}
DNSSEC_ALGORITHM_RSAMD5 = 1;
{$EXTERNALSYM DNSSEC_ALGORITHM_RSAMD5}
DNSSEC_ALGORITHM_NULL = 253;
{$EXTERNALSYM DNSSEC_ALGORITHM_NULL}
DNSSEC_ALGORITHM_PRIVATE = 254;
{$EXTERNALSYM DNSSEC_ALGORITHM_PRIVATE}
DNSSEC_PROTOCOL_NONE = 0;
{$EXTERNALSYM DNSSEC_PROTOCOL_NONE}
DNSSEC_PROTOCOL_TLS = 1;
{$EXTERNALSYM DNSSEC_PROTOCOL_TLS}
DNSSEC_PROTOCOL_EMAIL = 2;
{$EXTERNALSYM DNSSEC_PROTOCOL_EMAIL}
DNSSEC_PROTOCOL_DNSSEC = 3;
{$EXTERNALSYM DNSSEC_PROTOCOL_DNSSEC}
DNSSEC_PROTOCOL_IPSEC = 4;
{$EXTERNALSYM DNSSEC_PROTOCOL_IPSEC}
DNSSEC_KEY_FLAG_NOAUTH = $0001;
{$EXTERNALSYM DNSSEC_KEY_FLAG_NOAUTH}
DNSSEC_KEY_FLAG_NOCONF = $0002;
{$EXTERNALSYM DNSSEC_KEY_FLAG_NOCONF}
DNSSEC_KEY_FLAG_FLAG2 = $0004;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG2}
DNSSEC_KEY_FLAG_EXTEND = $0008;
{$EXTERNALSYM DNSSEC_KEY_FLAG_EXTEND}
{$DEFINE DNSSEC_KEY_FLAG_}
DNSSEC_KEY_FLAG_FLAG4 = $0010;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG4}
DNSSEC_KEY_FLAG_FLAG5 = $0020;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG5}
DNSSEC_KEY_FLAG_USER = $0000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_USER}
DNSSEC_KEY_FLAG_ZONE = $0040;
{$EXTERNALSYM DNSSEC_KEY_FLAG_ZONE}
DNSSEC_KEY_FLAG_HOST = $0080;
{$EXTERNALSYM DNSSEC_KEY_FLAG_HOST}
DNSSEC_KEY_FLAG_NTPE3 = $00c0;
{$EXTERNALSYM DNSSEC_KEY_FLAG_NTPE3}
DNSSEC_KEY_FLAG_FLAG8 = $0100;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG8}
DNSSEC_KEY_FLAG_FLAG9 = $0200;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG9}
DNSSEC_KEY_FLAG_FLAG10 = $0400;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG10}
DNSSEC_KEY_FLAG_FLAG11 = $0800;
{$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG11}
DNSSEC_KEY_FLAG_SIG0 = $0000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG0}
DNSSEC_KEY_FLAG_SIG1 = $1000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG1}
DNSSEC_KEY_FLAG_SIG2 = $2000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG2}
DNSSEC_KEY_FLAG_SIG3 = $3000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG3}
DNSSEC_KEY_FLAG_SIG4 = $4000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG4}
DNSSEC_KEY_FLAG_SIG5 = $5000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG5}
DNSSEC_KEY_FLAG_SIG6 = $6000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG6}
DNSSEC_KEY_FLAG_SIG7 = $7000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG7}
DNSSEC_KEY_FLAG_SIG8 = $8000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG8}
DNSSEC_KEY_FLAG_SIG9 = $9000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG9}
DNSSEC_KEY_FLAG_SIG10 = $a000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG10}
DNSSEC_KEY_FLAG_SIG11 = $b000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG11}
DNSSEC_KEY_FLAG_SIG12 = $c000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG12}
DNSSEC_KEY_FLAG_SIG13 = $d000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG13}
DNSSEC_KEY_FLAG_SIG14 = $e000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG14}
DNSSEC_KEY_FLAG_SIG15 = $f000;
{$EXTERNALSYM DNSSEC_KEY_FLAG_SIG15}
DNS_TKEY_MODE_SERVER_ASSIGN = 1;
{$EXTERNALSYM DNS_TKEY_MODE_SERVER_ASSIGN}
DNS_TKEY_MODE_DIFFIE_HELLMAN = 2;
{$EXTERNALSYM DNS_TKEY_MODE_DIFFIE_HELLMAN}
DNS_TKEY_MODE_GSS = 3;
{$EXTERNALSYM DNS_TKEY_MODE_GSS}
DNS_TKEY_MODE_RESOLVER_ASSIGN = 4;
{$EXTERNALSYM DNS_TKEY_MODE_RESOLVER_ASSIGN}
DNS_WINS_FLAG_SCOPE = DWORD($80000000);
{$EXTERNALSYM DNS_WINS_FLAG_SCOPE}
DNS_WINS_FLAG_LOCAL = $00010000;
{$EXTERNALSYM DNS_WINS_FLAG_LOCAL}
function IS_WORD_ALIGNED(P: Pointer): BOOL;
{$EXTERNALSYM IS_DWORD_ALIGNED}
function IS_DWORD_ALIGNED(P: Pointer): BOOL;
{$EXTERNALSYM IS_DWORD_ALIGNED}
function IS_QWORD_ALIGNED(P: Pointer): BOOL;
{$EXTERNALSYM IS_QWORD_ALIGNED}
type
DNS_CONFIG_TYPE = (
// In Win2K
DnsConfigPrimaryDomainName_W,
DnsConfigPrimaryDomainName_A,
DnsConfigPrimaryDomainName_UTF8,
// Not available yet
DnsConfigAdapterDomainName_W,
DnsConfigAdapterDomainName_A,
DnsConfigAdapterDomainName_UTF8,
// In Win2K
DnsConfigDnsServerList,
// Not available yet
DnsConfigSearchList,
DnsConfigAdapterInfo,
// In Win2K
DnsConfigPrimaryHostNameRegistrationEnabled,
DnsConfigAdapterHostNameRegistrationEnabled,
DnsConfigAddressRegistrationMaxCount,
// In WindowsXP
DnsConfigHostName_W,
DnsConfigHostName_A,
DnsConfigHostName_UTF8,
DnsConfigFullHostName_W,
DnsConfigFullHostName_A,
DnsConfigFullHostName_UTF8);
{$EXTERNALSYM DNS_CONFIG_TYPE}
TDnsConfigType = DNS_CONFIG_TYPE;
const
DNS_CONFIG_FLAG_ALLOC = $00000001;
{$EXTERNALSYM DNS_CONFIG_FLAG_ALLOC}
function DnsQueryConfig(Config: DNS_CONFIG_TYPE; Flag: DWORD; pwsAdapterName: PWSTR; pReserved, pBuffer: PVOID; pBufferLength: PDWORD): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQueryConfig}
type
PDNS_A_DATA = ^DNS_A_DATA;
{$EXTERNALSYM PDNS_A_DATA}
DNS_A_DATA = record
IpAddress: IP4_ADDRESS;
end;
{$EXTERNALSYM DNS_A_DATA}
TDnsAData = DNS_A_DATA;
PDnsAData = PDNS_A_DATA;
PDNS_PTR_DATA = ^DNS_PTR_DATA;
{$EXTERNALSYM PDNS_PTR_DATA}
DNS_PTR_DATA = record
pNameHost: LPTSTR;
end;
{$EXTERNALSYM DNS_PTR_DATA}
TDnsPtrData = DNS_PTR_DATA;
PDnsPtrData = PDNS_PTR_DATA;
PDNS_SOA_DATA = ^DNS_SOA_DATA;
{$EXTERNALSYM PDNS_SOA_DATA}
DNS_SOA_DATA = record
pNamePrimaryServer: LPTSTR;
pNameAdministrator: LPTSTR;
dwSerialNo: DWORD;
dwRefresh: DWORD;
dwRetry: DWORD;
dwExpire: DWORD;
dwDefaultTtl: DWORD;
end;
{$EXTERNALSYM DNS_SOA_DATA}
TDnsSoaData = DNS_SOA_DATA;
PDnsSoaData = PDNS_SOA_DATA;
PDNS_MINFO_DATA = ^DNS_MINFO_DATA;
{$EXTERNALSYM PDNS_MINFO_DATA}
DNS_MINFO_DATA = record
pNameMailbox: LPTSTR;
pNameErrorsMailbox: LPTSTR;
end;
{$EXTERNALSYM DNS_MINFO_DATA}
TDnsMinfoData = DNS_MINFO_DATA;
PDnsMinfoData = PDNS_MINFO_DATA;
PDNS_MX_DATA = ^DNS_MX_DATA;
{$EXTERNALSYM PDNS_MX_DATA}
DNS_MX_DATA = record
pNameExchange: LPTSTR;
wPreference: WORD;
Pad: WORD; // keep ptrs DWORD aligned
end;
{$EXTERNALSYM DNS_MX_DATA}
TDnsMxData = DNS_MX_DATA;
PDnsMxData = PDNS_MX_DATA;
PDNS_TXT_DATA = ^DNS_TXT_DATA;
{$EXTERNALSYM PDNS_TXT_DATA}
DNS_TXT_DATA = record
dwStringCount: DWORD;
pStringArray: array [0..0] of LPTSTR;
end;
{$EXTERNALSYM DNS_TXT_DATA}
TDnsTxtData = DNS_TXT_DATA;
PDnsTxtData = PDNS_TXT_DATA;
PDNS_NULL_DATA = ^DNS_NULL_DATA;
{$EXTERNALSYM PDNS_NULL_DATA}
DNS_NULL_DATA = record
dwByteCount: DWORD;
Data: array [0..0] of BYTE;
end;
{$EXTERNALSYM DNS_NULL_DATA}
TDnsNullData = DNS_NULL_DATA;
PDnsNullData = PDNS_NULL_DATA;
PDNS_WKS_DATA = ^DNS_WKS_DATA;
{$EXTERNALSYM PDNS_WKS_DATA}
DNS_WKS_DATA = record
IpAddress: IP4_ADDRESS;
chProtocol: UCHAR;
BitMask: array [0..0] of BYTE;
end;
{$EXTERNALSYM DNS_WKS_DATA}
TDnsWksData = DNS_WKS_DATA;
PDnsWksData = PDNS_WKS_DATA;
PDNS_AAAA_DATA = ^DNS_AAAA_DATA;
{$EXTERNALSYM PDNS_AAAA_DATA}
DNS_AAAA_DATA = record
Ip6Address: DNS_IP6_ADDRESS;
end;
{$EXTERNALSYM DNS_AAAA_DATA}
TDnsAaaaData = DNS_AAAA_DATA;
PDnsAaaaData = PDNS_AAAA_DATA;
PDNS_SIG_DATA = ^DNS_SIG_DATA;
{$EXTERNALSYM PDNS_SIG_DATA}
DNS_SIG_DATA = record
pNameSigner: LPTSTR;
wTypeCovered: WORD;
chAlgorithm: BYTE;
chLabelCount: BYTE;
dwOriginalTtl: DWORD;
dwExpiration: DWORD;
dwTimeSigned: DWORD;
wKeyTag: WORD;
Pad: WORD; // keep byte field aligned
Signature: array [0..0] of BYTE;
end;
{$EXTERNALSYM DNS_SIG_DATA}
TDnsSigData = DNS_SIG_DATA;
PDnsSigData = PDNS_SIG_DATA;
PDNS_KEY_DATA = ^DNS_KEY_DATA;
{$EXTERNALSYM PDNS_KEY_DATA}
DNS_KEY_DATA = record
wFlags: WORD;
chProtocol: BYTE;
chAlgorithm: BYTE;
Key: array [0..1 - 1] of BYTE;
end;
{$EXTERNALSYM DNS_KEY_DATA}
TDnsKeyData = DNS_KEY_DATA;
PDnsKeyData = PDNS_KEY_DATA;
PDNS_LOC_DATA = ^DNS_LOC_DATA;
{$EXTERNALSYM PDNS_LOC_DATA}
DNS_LOC_DATA = record
wVersion: WORD;
wSize: WORD;
wHorPrec: WORD;
wVerPrec: WORD;
dwLatitude: DWORD;
dwLongitude: DWORD;
dwAltitude: DWORD;
end;
{$EXTERNALSYM DNS_LOC_DATA}
TDnsLocData = DNS_LOC_DATA;
PDnsLocData = PDNS_LOC_DATA;
PDNS_NXT_DATA = ^DNS_NXT_DATA;
{$EXTERNALSYM PDNS_NXT_DATA}
DNS_NXT_DATA = record
pNameNext: LPTSTR;
wNumTypes: WORD;
wTypes: array [0..0] of WORD;
end;
{$EXTERNALSYM DNS_NXT_DATA}
TDnsNxtData = DNS_NXT_DATA;
PDnsNxtData = PDNS_NXT_DATA;
PDNS_SRV_DATA = ^DNS_SRV_DATA;
{$EXTERNALSYM PDNS_SRV_DATA}
DNS_SRV_DATA = record
pNameTarget: LPTSTR;
wPriority: WORD;
wWeight: WORD;
wPort: WORD;
Pad: WORD; // keep ptrs DWORD aligned
end;
{$EXTERNALSYM DNS_SRV_DATA}
TDnsSrvData = DNS_SRV_DATA;
PDnsSrvData = PDNS_SRV_DATA;
PDNS_ATMA_DATA = ^DNS_ATMA_DATA;
{$EXTERNALSYM PDNS_ATMA_DATA}
DNS_ATMA_DATA = record
AddressType: BYTE;
Address: array [0..DNS_ATMA_MAX_ADDR_LENGTH - 1] of BYTE;
// E164 -- Null terminated string of less than
// DNS_ATMA_MAX_ADDR_LENGTH
//
// For NSAP (AESA) BCD encoding of exactly
// DNS_ATMA_AESA_ADDR_LENGTH
end;
{$EXTERNALSYM DNS_ATMA_DATA}
TDnsAtmaData = DNS_ATMA_DATA;
PDnsAtmaData = PDNS_ATMA_DATA;
PDNS_TKEY_DATA = ^DNS_TKEY_DATA;
{$EXTERNALSYM PDNS_TKEY_DATA}
DNS_TKEY_DATA = record
pNameAlgorithm: LPTSTR;
pAlgorithmPacket: PBYTE;
pKey: PBYTE;
pOtherData: PBYTE;
dwCreateTime: DWORD;
dwExpireTime: DWORD;
wMode: WORD;
wError: WORD;
wKeyLength: WORD;
wOtherLength: WORD;
cAlgNameLength: UCHAR;
bPacketPointers: BOOL;
end;
{$EXTERNALSYM DNS_TKEY_DATA}
TDnsTkeyData = DNS_TKEY_DATA;
PDnsTkeyData = PDNS_TKEY_DATA;
PDNS_TSIG_DATA = ^DNS_TSIG_DATA;
{$EXTERNALSYM PDNS_TSIG_DATA}
DNS_TSIG_DATA = record
pNameAlgorithm: LPTSTR;
pAlgorithmPacket: PBYTE;
pSignature: PBYTE;
pOtherData: PBYTE;
i64CreateTime: LONGLONG;
wFudgeTime: WORD;
wOriginalXid: WORD;
wError: WORD;
wSigLength: WORD;
wOtherLength: WORD;
cAlgNameLength: UCHAR;
bPacketPointers: BOOL;
end;
{$EXTERNALSYM DNS_TSIG_DATA}
TDnsTsigData = DNS_TSIG_DATA;
PDnsTsigData = PDNS_TSIG_DATA;
PDNS_WINS_DATA = ^DNS_WINS_DATA;
{$EXTERNALSYM PDNS_WINS_DATA}
DNS_WINS_DATA = record
dwMappingFlag: DWORD;
dwLookupTimeout: DWORD;
dwCacheTimeout: DWORD;
cWinsServerCount: DWORD;
WinsServers: array [0..0] of IP4_ADDRESS;
end;
{$EXTERNALSYM DNS_WINS_DATA}
TDnsWinsData = DNS_WINS_DATA;
PDnsWinsData = PDNS_WINS_DATA;
PDNS_WINSR_DATA = ^DNS_WINSR_DATA;
{$EXTERNALSYM PDNS_WINSR_DATA}
DNS_WINSR_DATA = record
dwMappingFlag: DWORD;
dwLookupTimeout: DWORD;
dwCacheTimeout: DWORD;
pNameResultDomain: LPTSTR;
end;
{$EXTERNALSYM DNS_WINSR_DATA}
TDnsWinsrData = DNS_WINSR_DATA;
PDnsWinsrData = PDNS_WINSR_DATA;
function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
{$EXTERNALSYM DNS_TEXT_RECORD_LENGTH}
function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
{$EXTERNALSYM DNS_NULL_RECORD_LENGTH}
function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
{$EXTERNALSYM DNS_WKS_RECORD_LENGTH}
type
_DnsRecordFlags = record
//DWORD Section : 2;
//DWORD Delete : 1;
//DWORD CharSet : 2;
//DWORD Unused : 3;
//DWORD Reserved : 24;
Flags: DWORD;
end;
{$EXTERNALSYM _DnsRecordFlags}
DNS_RECORD_FLAGS = _DnsRecordFlags;
{$EXTERNALSYM DNS_RECORD_FLAGS}
TDnsRecordFlags = DNS_RECORD_FLAGS;
PDnsRecordFlags = ^DNS_RECORD_FLAGS;
_DnsSection = (
DnsSectionQuestion,
DnsSectionAnswer,
DnsSectionAuthority,
DnsSectionAddtional);
{$EXTERNALSYM _DnsSection}
DNS_SECTION = _DnsSection;
TDnsSection = _DnsSection;
const
DnsSectionZone = DnsSectionQuestion;
{$EXTERNALSYM DnsSectionZone}
DnsSectionPrereq = DnsSectionAnswer;
{$EXTERNALSYM DnsSectionPrereq}
DnsSectionUpdate = DnsSectionAuthority;
{$EXTERNALSYM DnsSectionUpdate}
DNSREC_SECTION = $00000003;
{$EXTERNALSYM DNSREC_SECTION}
DNSREC_QUESTION = $00000000;
{$EXTERNALSYM DNSREC_QUESTION}
DNSREC_ANSWER = $00000001;
{$EXTERNALSYM DNSREC_ANSWER}
DNSREC_AUTHORITY = $00000002;
{$EXTERNALSYM DNSREC_AUTHORITY}
DNSREC_ADDITIONAL = $00000003;
{$EXTERNALSYM DNSREC_ADDITIONAL}
DNSREC_ZONE = $00000000;
{$EXTERNALSYM DNSREC_ZONE}
DNSREC_PREREQ = $00000001;
{$EXTERNALSYM DNSREC_PREREQ}
DNSREC_UPDATE = $00000002;
{$EXTERNALSYM DNSREC_UPDATE}
DNSREC_DELETE = $00000004;
{$EXTERNALSYM DNSREC_DELETE}
DNSREC_NOEXIST = $00000004;
{$EXTERNALSYM DNSREC_NOEXIST}
type
PDNS_RECORD = ^DNS_RECORD;
{$EXTERNALSYM PDNS_RECORD}
_DnsRecord = record
pNext: PDNS_RECORD;
pName: LPTSTR;
wType: WORD;
wDataLength: WORD; // Not referenced for DNS record types defined above.
Flags: record
case Integer of
0: (DW: DWORD); // flags as DWORD
1: (S: DNS_RECORD_FLAGS); // flags as structure
end;
dwTtl: DWORD;
dwReserved: DWORD;
Data: record
case Integer of
0: (A: DNS_A_DATA);
1: (SOA, Soa_: DNS_SOA_DATA);
2: (PTR, Ptr_,
NS, Ns_,
CNAME, Cname_,
MB, Mb_,
MD, Md_,
MF, Mf_,
MG, Mg_,
MR, Mr_: DNS_PTR_DATA);
3: (MINFO, Minfo_,
RP, Rp_: DNS_MINFO_DATA);
4: (MX, Mx_,
AFSDB, Afsdb_,
RT, Rt_: DNS_MX_DATA);
5: (HINFO, Hinfo_,
ISDN, Isdn_,
TXT, Txt_,
X25: DNS_TXT_DATA);
6: (Null: DNS_NULL_DATA);
7: (WKS, Wks_: DNS_WKS_DATA);
8: (AAAA: DNS_AAAA_DATA);
9: (KEY, Key_: DNS_KEY_DATA);
10: (SIG, Sig_: DNS_SIG_DATA);
11: (ATMA, Atma_: DNS_ATMA_DATA);
12: (NXT, Nxt_: DNS_NXT_DATA);
13: (SRV, Srv_: DNS_SRV_DATA);
14: (TKEY, Tkey_: DNS_TKEY_DATA);
15: (TSIG, Tsig_: DNS_TSIG_DATA);
16: (WINS, Wins_: DNS_WINS_DATA);
17: (WINSR, WinsR_, NBSTAT, Nbstat_: DNS_WINSR_DATA);
end;
end;
{$EXTERNALSYM _DnsRecord}
DNS_RECORD = _DnsRecord;
{$EXTERNALSYM DNS_RECORD}
PPDNS_RECORD = ^PDNS_RECORD;
{$NODEFINE PPDNS_RECORD}
TDnsRecord = DNS_RECORD;
PDnsRecord = PDNS_RECORD;
const
DNS_RECORD_FIXED_SIZE = 24; // FIELD_OFFSET( DNS_RECORD, Data )
{$EXTERNALSYM DNS_RECORD_FIXED_SIZE}
SIZEOF_DNS_RECORD_HEADER = DNS_RECORD_FIXED_SIZE;
{$EXTERNALSYM SIZEOF_DNS_RECORD_HEADER}
type
PDnsRRSet = ^DnsRRSet;
{$EXTERNALSYM PDnsRRSet}
_DnsRRSet = record
pFirstRR: PDNS_RECORD;
pLastRR: PDNS_RECORD;
end;
{$EXTERNALSYM _DnsRRSet}
DnsRRSet = _DnsRRSet;
{$EXTERNALSYM DnsRRSet}
TDnsrrset = DnsRRSet;
procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
{$EXTERNALSYM DNS_RRSET_INIT}
procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
{$EXTERNALSYM DNS_RRSET_TERMINATE}
type
_DNS_CHARSET = (
DnsCharSetUnknown,
DnsCharSetUnicode,
DnsCharSetUtf8,
DnsCharSetAnsi);
{$EXTERNALSYM _DNS_CHARSET}
DNS_CHARSET = _DNS_CHARSET;
{$EXTERNALSYM DNS_CHARSET}
TDnsCharSet = DNS_CHARSET;
PDnsCharSet = ^DNS_CHARSET;
function DnsRecordCopyEx(pRecord: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
{$EXTERNALSYM DnsRecordCopyEx}
function DnsRecordSetCopyEx(pRecordSet: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
{$EXTERNALSYM DnsRecordSetCopyEx}
function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
{$EXTERNALSYM DnsRecordCopy}
function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
{$EXTERNALSYM DnsRecordSetCopy}
function DnsRecordCompare(pRecord1: PDNS_RECORD; pRecord2: PDNS_RECORD): BOOL; stdcall;
{$EXTERNALSYM DnsRecordCompare}
function DnsRecordSetCompare(pRR1: PDNS_RECORD; pRR2: PDNS_RECORD; var ppDiff1, ppDiff2: PDNS_RECORD): BOOL; stdcall;
{$EXTERNALSYM DnsRecordSetCompare}
function DnsRecordSetDetach(pRecordList: PDNS_RECORD): PDNS_RECORD; stdcall;
{$EXTERNALSYM DnsRecordSetDetach}
type
DNS_FREE_TYPE = (DnsFreeFlat, DnsFreeRecordList);
{$EXTERNALSYM DNS_FREE_TYPE}
TDnsFreeType = DNS_FREE_TYPE;
procedure DnsFreeRecordListDeep(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
{$EXTERNALSYM DnsFreeRecordListDeep}
procedure DnsRecordListFree(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
{$EXTERNALSYM DnsRecordListFree}
procedure DnsFree(pData: PVOID; FreeType: DNS_FREE_TYPE); stdcall;
{$EXTERNALSYM DnsFree}
const
DNS_QUERY_STANDARD = $00000000;
{$EXTERNALSYM DNS_QUERY_STANDARD}
DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE = $00000001;
{$EXTERNALSYM DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE}
DNS_QUERY_USE_TCP_ONLY = $00000002;
{$EXTERNALSYM DNS_QUERY_USE_TCP_ONLY}
DNS_QUERY_NO_RECURSION = $00000004;
{$EXTERNALSYM DNS_QUERY_NO_RECURSION}
DNS_QUERY_BYPASS_CACHE = $00000008;
{$EXTERNALSYM DNS_QUERY_BYPASS_CACHE}
DNS_QUERY_NO_WIRE_QUERY = $00000010;
{$EXTERNALSYM DNS_QUERY_NO_WIRE_QUERY}
DNS_QUERY_NO_LOCAL_NAME = $00000020;
{$EXTERNALSYM DNS_QUERY_NO_LOCAL_NAME}
DNS_QUERY_NO_HOSTS_FILE = $00000040;
{$EXTERNALSYM DNS_QUERY_NO_HOSTS_FILE}
DNS_QUERY_NO_NETBT = $00000080;
{$EXTERNALSYM DNS_QUERY_NO_NETBT}
DNS_QUERY_WIRE_ONLY = $00000100;
{$EXTERNALSYM DNS_QUERY_WIRE_ONLY}
DNS_QUERY_RETURN_MESSAGE = $00000200;
{$EXTERNALSYM DNS_QUERY_RETURN_MESSAGE}
DNS_QUERY_TREAT_AS_FQDN = $00001000;
{$EXTERNALSYM DNS_QUERY_TREAT_AS_FQDN}
DNS_QUERY_DONT_RESET_TTL_VALUES = $00100000;
{$EXTERNALSYM DNS_QUERY_DONT_RESET_TTL_VALUES}
DNS_QUERY_RESERVED = DWORD($ff000000);
{$EXTERNALSYM DNS_QUERY_RESERVED}
DNS_QUERY_CACHE_ONLY = DNS_QUERY_NO_WIRE_QUERY;
{$EXTERNALSYM DNS_QUERY_CACHE_ONLY}
function DnsQuery_A(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_A}
function DnsQuery_UTF8(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_UTF8}
function DnsQuery_W(pszName: LPCWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery_W}
function DnsQuery(pszName: LPCTSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsQuery}
const
DNS_UPDATE_SECURITY_USE_DEFAULT = $00000000;
{$EXTERNALSYM DNS_UPDATE_SECURITY_USE_DEFAULT}
DNS_UPDATE_SECURITY_OFF = $00000010;
{$EXTERNALSYM DNS_UPDATE_SECURITY_OFF}
DNS_UPDATE_SECURITY_ON = $00000020;
{$EXTERNALSYM DNS_UPDATE_SECURITY_ON}
DNS_UPDATE_SECURITY_ONLY = $00000100;
{$EXTERNALSYM DNS_UPDATE_SECURITY_ONLY}
DNS_UPDATE_CACHE_SECURITY_CONTEXT = $00000200;
{$EXTERNALSYM DNS_UPDATE_CACHE_SECURITY_CONTEXT}
DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT = $00000400;
{$EXTERNALSYM DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT}
DNS_UPDATE_FORCE_SECURITY_NEGO = $00000800;
{$EXTERNALSYM DNS_UPDATE_FORCE_SECURITY_NEGO}
DNS_UPDATE_TRY_ALL_MASTER_SERVERS = $00001000;
{$EXTERNALSYM DNS_UPDATE_TRY_ALL_MASTER_SERVERS}
DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS = $00002000;
{$EXTERNALSYM DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS}
DNS_UPDATE_RESERVED = DWORD($ffff0000);
{$EXTERNALSYM DNS_UPDATE_RESERVED}
function DnsAcquireContextHandle_W(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle_W}
function DnsAcquireContextHandle_A(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle_A}
function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsAcquireContextHandle}
procedure DnsReleaseContextHandle(hContext: HANDLE); stdcall;
{$EXTERNALSYM DnsReleaseContextHandle}
function DnsModifyRecordsInSet_W(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_W}
function DnsModifyRecordsInSet_A(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_A}
function DnsModifyRecordsInSet_UTF8(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet_UTF8}
function DnsModifyRecordsInSet(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsModifyRecordsInSet}
function DnsReplaceRecordSetW(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetW}
function DnsReplaceRecordSetA(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetA}
function DnsReplaceRecordSetUTF8(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSetUTF8}
function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsReplaceRecordSet}
type
_DNS_NAME_FORMAT = (
DnsNameDomain,
DnsNameDomainLabel,
DnsNameHostnameFull,
DnsNameHostnameLabel,
DnsNameWildcard,
DnsNameSrvRecord);
{$EXTERNALSYM _DNS_NAME_FORMAT}
DNS_NAME_FORMAT = _DNS_NAME_FORMAT;
{$EXTERNALSYM DNS_NAME_FORMAT}
TDnsNameFormat = DNS_NAME_FORMAT;
PDnsNameFormat = ^DNS_NAME_FORMAT;
function DnsValidateName_UTF8(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_UTF8}
function DnsValidateName_W(pwszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_W}
function DnsValidateName_A(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsValidateName_A}
function DnsValidateName(pszName: LPCTSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
{$EXTERNALSYM DnsValidateName}
function DnsNameCompare_A(pName1: LPSTR; pName2: LPSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare_A}
function DnsNameCompare_W(pName1: LPWSTR; pName2: LPWSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare_W}
function DnsNameCompare(pName1: LPTSTR; pName2: LPTSTR): BOOL; stdcall;
{$EXTERNALSYM DnsNameCompare}
type
PDNS_MESSAGE_BUFFER = ^DNS_MESSAGE_BUFFER;
{$EXTERNALSYM PDNS_MESSAGE_BUFFER}
_DNS_MESSAGE_BUFFER = record
MessageHead: DNS_HEADER;
MessageBody: array [0..0] of AnsiChar;
end;
{$EXTERNALSYM _DNS_MESSAGE_BUFFER}
DNS_MESSAGE_BUFFER = _DNS_MESSAGE_BUFFER;
{$EXTERNALSYM DNS_MESSAGE_BUFFER}
TDnsMessageBuffer = DNS_MESSAGE_BUFFER;
PDnsMessageBuffer = PDNS_MESSAGE_BUFFER;
function DnsWriteQuestionToBuffer_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPWSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
{$EXTERNALSYM DnsWriteQuestionToBuffer_W}
function DnsWriteQuestionToBuffer_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
{$EXTERNALSYM DnsWriteQuestionToBuffer_UTF8}
function DnsExtractRecordsFromMessage_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsExtractRecordsFromMessage_W}
function DnsExtractRecordsFromMessage_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
{$EXTERNALSYM DnsExtractRecordsFromMessage_UTF8}
implementation
const
dnsapi = 'dnsapi.dll';
{$IFDEF UNICODE}
AWSuffix = 'W';
{$ELSE}
AWSuffix = 'A';
{$ENDIF UNICODE}
procedure INLINE_WORD_FLIP(var Out_: WORD; In_: WORD);
begin
Out_ := (In_ shl 8) or (In_ shr 8);
end;
procedure INLINE_HTONS(var Out_: WORD; In_: WORD);
begin
INLINE_WORD_FLIP(Out_, In_);
end;
procedure INLINE_NTOHS(var Out_: WORD; In_: WORD);
begin
INLINE_WORD_FLIP(Out_, In_);
end;
procedure INLINE_DWORD_FLIP(var Out_: DWORD; In_: DWORD);
begin
Out_ := ((In_ shl 8) and $00ff0000) or (In_ shl 24) or
((In_ shr 8) and $0000ff00) or (In_ shr 24);
end;
procedure INLINE_NTOHL(var Out_: DWORD; In_: DWORD);
begin
INLINE_DWORD_FLIP(Out_, In_);
end;
procedure INLINE_HTONL(var Out_: DWORD; In_: DWORD);
begin
INLINE_DWORD_FLIP(Out_, In_);
end;
procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
begin
INLINE_WORD_FLIP(pout^, In_);
end;
procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
begin
INLINE_DWORD_FLIP(pout^, In_);
end;
function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
begin
//Warning: Converting a pointer to Integer may conflict with 3GB adress space (and later 64bit)
Result := PWORD(DWORD_PTR(pHead) + SizeOf(WORD))^;
end;
procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
var
_head: PDNS_HEADER;
begin
_head := pHeader;
INLINE_HTONS(_head^.Xid, _head^.Xid);
INLINE_HTONS(_head^.QuestionCount, _head^.QuestionCount);
INLINE_HTONS(_head^.AnswerCount, _head^.AnswerCount);
INLINE_HTONS(_head^.NameServerCount, _head^.NameServerCount);
INLINE_HTONS(_head^.AdditionalCount, _head^.AdditionalCount);
end;
{
#define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) \
( (PAnsiChar)( (PDNS_HEADER)(_pHeader_) + 1 ) )
#define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) \
( (PAnsiChar)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
}
function IS_WORD_ALIGNED(P: Pointer): BOOL;
begin
//Warning: Converting a pointer to Integer may conflict with 3GB adress space (and later 64bit)
Result := (DWORD_PTR(P) and 1) = 0;
end;
function IS_DWORD_ALIGNED(P: Pointer): BOOL;
begin
//Warning: Converting a pointer to Integer may conflict with 3GB adress space (and later 64bit)
Result := (DWORD_PTR(P) and 3) = 0;
end;
function IS_QWORD_ALIGNED(P: Pointer): BOOL;
begin
//Warning: Converting a pointer to Integer may conflict with 3GB adress space (and later 64bit)
Result := (DWORD_PTR(P) and 7) = 0;
end;
function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
begin
Result := SizeOf(DWORD) + ((StringCount) * SizeOf(PAnsiChar));
end;
function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
begin
Result := SizeOf(DWORD) + (ByteCount);
end;
function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
begin
Result := SizeOf(DNS_WKS_DATA) + (ByteCount - 1);
end;
//#define DNS_WINS_RECORD_LENGTH(IpCount) \
// (FIELD_OFFSET(DNS_WINS_DATA, WinsServers) + ((IpCount) * sizeof(IP4_ADDRESS)))
procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
begin
rrset^.pFirstRR := nil;
rrset^.pLastRR := (@rrset^.pFirstRR);
end;
//#define DNS_RRSET_ADD( rrset, pnewRR ) \
// { \
// PDNS_RRSET _prrset = &(rrset); \
// PDNS_RECORD _prrnew = (pnewRR); \
// _prrset->pLastRR->pNext = _prrnew; \
// _prrset->pLastRR = _prrnew; \
// }
procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
begin
rrset^.pLastRR^.pNext := nil;
end;
{$IFDEF UNICODE}
function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
Result := DnsRecordCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
end;
function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
Result := DnsRecordSetCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
end;
function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
begin
Result := DnsValidateName_W(pszName, Format);
end;
{$ELSE}
function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
Result := DnsRecordCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
end;
function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
begin
Result := DnsRecordSetCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
end;
function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
begin
Result := DnsValidateName_A(pszName, Format);
end;
{$ENDIF UNICODE}
function DnsQueryConfig; external dnsapi name 'DnsQueryConfig';
function DnsRecordCopyEx; external dnsapi name 'DnsRecordCopyEx';
function DnsRecordSetCopyEx; external dnsapi name 'DnsRecordSetCopyEx';
function DnsRecordCompare; external dnsapi name 'DnsRecordCompare';
function DnsRecordSetCompare; external dnsapi name 'DnsRecordSetCompare';
function DnsRecordSetDetach; external dnsapi name 'DnsRecordSetDetach';
procedure DnsFreeRecordListDeep; external dnsapi name 'DnsRecordListFree';
procedure DnsRecordListFree; external dnsapi name 'DnsRecordListFree';
procedure DnsFree; external dnsapi name 'DnsFree';
function DnsQuery_A; external dnsapi name 'DnsQuery_A';
function DnsQuery_UTF8; external dnsapi name 'DnsQuery_UTF8';
function DnsQuery_W; external dnsapi name 'DnsQuery_W';
function DnsQuery; external dnsapi name 'DnsQuery_' + AWSuffix;
function DnsAcquireContextHandle_W; external dnsapi name 'DnsAcquireContextHandle_W';
function DnsAcquireContextHandle_A; external dnsapi name 'DnsAcquireContextHandle_A';
function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_' + AWSuffix;
procedure DnsReleaseContextHandle; external dnsapi name 'DnsReleaseContextHandle';
function DnsModifyRecordsInSet_W; external dnsapi name 'DnsModifyRecordsInSet_W';
function DnsModifyRecordsInSet_A; external dnsapi name 'DnsModifyRecordsInSet_A';
function DnsModifyRecordsInSet_UTF8; external dnsapi name 'DnsModifyRecordsInSet_UTF8';
function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_' + AWSuffix;
function DnsReplaceRecordSetW; external dnsapi name 'DnsReplaceRecordSetW';
function DnsReplaceRecordSetA; external dnsapi name 'DnsReplaceRecordSetA';
function DnsReplaceRecordSetUTF8; external dnsapi name 'DnsReplaceRecordSetUTF8';
function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSet' + AWSuffix;
function DnsValidateName_UTF8; external dnsapi name 'DnsValidateName_UTF8';
function DnsValidateName_W; external dnsapi name 'DnsValidateName_W';
function DnsValidateName_A; external dnsapi name 'DnsValidateName_A';
function DnsNameCompare_A; external dnsapi name 'DnsNameCompare_A';
function DnsNameCompare_W; external dnsapi name 'DnsNameCompare_W';
function DnsNameCompare; external dnsapi name 'DnsNameCompare_' + AWSuffix;
function DnsWriteQuestionToBuffer_W; external dnsapi name 'DnsWriteQuestionToBuffer_W';
function DnsWriteQuestionToBuffer_UTF8; external dnsapi name 'DnsWriteQuestionToBuffer_UTF8';
function DnsExtractRecordsFromMessage_W; external dnsapi name 'DnsExtractRecordsFromMessage_W';
function DnsExtractRecordsFromMessage_UTF8; external dnsapi name 'DnsExtractRecordsFromMessage_UTF8';
end.
Reference in New Issue Copy Permalink