1 {******************************************************************************}
2 { }
3 { Domain Naming Services API interface Unit for Object Pascal }
4 { }
5 { Portions created by Microsoft are Copyright (C) 1995-2001 Microsoft }
6 { Corporation. All Rights Reserved. }
7 { }
8 { The original file is: windns.h, released June 2000. The original Pascal }
9 { code is: WinDNS.pas, released December 2000. The initial developer of the }
10 { Pascal code is Marcel van Brakel (brakelm att chello dott nl). }
11 { }
12 { Portions created by Marcel van Brakel are Copyright (C) 1999-2001 }
13 { Marcel van Brakel. All Rights Reserved. }
14 { }
15 { Obtained through: Joint Endeavour of Delphi Innovators (Project JEDI) }
16 { }
17 { You may retrieve the latest version of this file at the Project JEDI }
18 { APILIB home page, located at http://jedi-apilib.sourceforge.net }
19 { }
20 { The contents of this file are used with permission, subject to the Mozilla }
21 { Public License Version 1.1 (the "License"); you may not use this file except }
22 { in compliance with the License. You may obtain a copy of the License at }
23 { http://www.mozilla.org/MPL/MPL-1.1.html }
24 { }
25 { Software distributed under the License is distributed on an "AS IS" basis, }
26 { WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for }
27 { the specific language governing rights and limitations under the License. }
28 { }
29 { Alternatively, the contents of this file may be used under the terms of the }
30 { GNU Lesser General Public License (the "LGPL License"), in which case the }
31 { provisions of the LGPL License are applicable instead of those above. }
32 { If you wish to allow use of your version of this file only under the terms }
33 { of the LGPL License and not to allow others to use your version of this file }
34 { under the MPL, indicate your decision by deleting the provisions above and }
35 { replace them with the notice and other provisions required by the LGPL }
36 { License. If you do not delete the provisions above, a recipient may use }
37 { your version of this file under either the MPL or the LGPL License. }
38 { }
39 { For more information about the LGPL: http://www.gnu.org/copyleft/lesser.html }
40 { }
41 {******************************************************************************}
42
43 // $Id: JwaWinDNS.pas,v 1.12 2007/09/05 11:58:53 dezipaitor Exp $
44
45 {******************************************************************}
46 { Notes (TODO): }
47 { DnsRecordSetDetach() and DnsValidateName_X() didn't have a cc }
48 { IP_ADDRESS_STRING_LENGTH is defined nowhere }
49 { DNS_WINS_RECORD macro untranslatable due to IP_ADDRESS }
50 { DNS_RRSET_ADD macro untranslatable }
51 {******************************************************************}
52
53 {$IFNDEF JWA_OMIT_SECTIONS}
54 unit JwaWinDNS;
55
56 {$WEAKPACKAGEUNIT}
57 {$ENDIF JWA_OMIT_SECTIONS}
58
59 {$HPPEMIT ''}
60 {$HPPEMIT '#include "WinDNS.h"'}
61 {$HPPEMIT ''}
62 {$HPPEMIT 'typeded PDNS_RECORD *PPDNS_RECORD'}
63 {$HPPEMIT ''}
64
65 {$IFNDEF JWA_OMIT_SECTIONS}
66 {$I jediapilib.inc}
67
68 interface
69
70 uses
71 JwaWinsock2, JwaWinType, JwaWS2atm;
72 {$ENDIF JWA_OMIT_SECTIONS}
73
74 {$IFNDEF JWA_IMPLEMENTATIONSECTION}
75
76
77 {$IFNDEF JWA_INCLUDEMODE}
78 type
79 IN6_ADDR = Pointer; // todo
80 {$ENDIF JWA_INCLUDEMODE}
81
82 //
83 // DNS public types
84 //
85
86 type
87 DNS_STATUS = Longint;
88 {$EXTERNALSYM DNS_STATUS}
89 PDNS_STATUS = ^DNS_STATUS;
90 {$EXTERNALSYM PDNS_STATUS}
91 TDnsStatus = DNS_STATUS;
92 PDnsStatus = PDNS_STATUS;
93
94 //
95 // IP Address
96 //
97
98 type
99 IP4_ADDRESS = DWORD;
100 {$EXTERNALSYM IP4_ADDRESS}
101 PIP4_ADDRESS = ^IP4_ADDRESS;
102 {$EXTERNALSYM PIP4_ADDRESS}
103 TIP4Address = IP4_ADDRESS;
104 PIP4Address = PIP4_ADDRESS;
105
106 const
107 SIZEOF_IP4_ADDRESS = 4;
108 {$EXTERNALSYM SIZEOF_IP4_ADDRESS}
109 IP4_ADDRESS_STRING_LENGTH = 15;
110 {$EXTERNALSYM IP4_ADDRESS_STRING_LENGTH}
111 IP4_ADDRESS_STRING_BUFFER_LENGTH = 16;
112 {$EXTERNALSYM IP4_ADDRESS_STRING_BUFFER_LENGTH}
113
114 //
115 // IP Address Array type
116 //
117
118 type
119 PIP4_ARRAY = ^IP4_ARRAY;
120 {$EXTERNALSYM PIP4_ARRAY}
121 _IP4_ARRAY = record
122 AddrCount: DWORD;
123 AddrArray: array [0..0] of IP4_ADDRESS;
124 end;
125 {$EXTERNALSYM _IP4_ARRAY}
126 IP4_ARRAY = _IP4_ARRAY;
127 {$EXTERNALSYM IP4_ARRAY}
128 TIp4Array = IP4_ARRAY;
129 PIp4Array = PIP4_ARRAY;
130
131 //
132 // IPv6 Address
133 //
134
135 PIP6_ADDRESS = ^IP6_ADDRESS;
136 {$EXTERNALSYM PIP6_ADDRESS}
137 IP6_ADDRESS = record
138 case Integer of
139 0: (IP6Qword: array [0..1] of QWORD);
140 1: (IP6Dword: array [0..3] of DWORD);
141 2: (IP6Word: array [0..7] of WORD);
142 3: (IP6Byte: array [0..15] of BYTE);
143 4: (In6: IN6_ADDR);
144 end;
145 {$EXTERNALSYM IP6_ADDRESS}
146 TIp6Address = IP6_ADDRESS;
147 PIp6Address = PIP6_ADDRESS;
148
149 // Backward compatibility
150
151 DNS_IP6_ADDRESS = IP6_ADDRESS;
152 {$EXTERNALSYM DNS_IP6_ADDRESS}
153 PDNS_IP6_ADDRESS = ^IP6_ADDRESS;
154 {$EXTERNALSYM PDNS_IP6_ADDRESS}
155 TDnsIp6Address = DNS_IP6_ADDRESS;
156 PDnsIp6Address = PDNS_IP6_ADDRESS;
157
158 //
159 // IP6 string max is 45 bytes
160 // - 6 WORDs in colon+hex (5 chars)
161 // - last DWORD as IP4 (15 chars)
162 //
163
164 const
165 IP6_ADDRESS_STRING_LENGTH = 47;
166 {$EXTERNALSYM IP6_ADDRESS_STRING_LENGTH}
167 IP6_ADDRESS_STRING_BUFFER_LENGTH = 48;
168 {$EXTERNALSYM IP6_ADDRESS_STRING_BUFFER_LENGTH}
169
170 // backcompat
171
172 IPV6_ADDRESS_STRING_LENGTH = IP6_ADDRESS_STRING_LENGTH;
173 {$EXTERNALSYM IPV6_ADDRESS_STRING_LENGTH}
174
175 //
176 // Inline byte flipping -- can be done in registers
177 //
178
179 procedure INLINE_WORD_FLIP(var Out_: WORD; In_: WORD);
180 {$EXTERNALSYM INLINE_WORD_FLIP}
181
182 procedure INLINE_HTONS(var Out_: WORD; In_: WORD);
183 {$EXTERNALSYM INLINE_HTONS}
184
185 procedure INLINE_NTOHS(var Out_: WORD; In_: WORD);
186 {$EXTERNALSYM INLINE_NTOHS}
187
188 procedure INLINE_DWORD_FLIP(var Out_: DWORD; In_: DWORD);
189 {$EXTERNALSYM INLINE_DWORD_FLIP}
190
191 procedure INLINE_NTOHL(var Out_: DWORD; In_: DWORD);
192 {$EXTERNALSYM INLINE_NTOHL}
193
194 procedure INLINE_HTONL(var Out_: DWORD; In_: DWORD);
195 {$EXTERNALSYM INLINE_HTONL}
196
197 //
198 // Inline byte flip and write to packet (unaligned)
199 //
200
201 procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
202 {$EXTERNALSYM INLINE_WRITE_FLIPPED_WORD}
203
204 procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
205 {$EXTERNALSYM INLINE_WRITE_FLIPPED_DWORD}
206
207 //
208 // Basic DNS definitions
209 //
210
211 //
212 // DNS port for both UDP and TCP is 53.
213 //
214
215 const
216 DNS_PORT_HOST_ORDER = $0035; // port 53
217 {$EXTERNALSYM DNS_PORT_HOST_ORDER}
218 DNS_PORT_NET_ORDER = $3500;
219 {$EXTERNALSYM DNS_PORT_NET_ORDER}
220
221 //
222 // DNS UDP packets no more than 512 bytes
223 //
224
225 DNS_RFC_MAX_UDP_PACKET_LENGTH = 512;
226 {$EXTERNALSYM DNS_RFC_MAX_UDP_PACKET_LENGTH}
227
228 //
229 // DNS Names limited to 255, 63 in any one label
230 //
231
232 DNS_MAX_NAME_LENGTH = 255;
233 {$EXTERNALSYM DNS_MAX_NAME_LENGTH}
234 DNS_MAX_LABEL_LENGTH = 63;
235 {$EXTERNALSYM DNS_MAX_LABEL_LENGTH}
236
237 DNS_MAX_NAME_BUFFER_LENGTH = 256;
238 {$EXTERNALSYM DNS_MAX_NAME_BUFFER_LENGTH}
239 DNS_MAX_LABEL_BUFFER_LENGTH = 64;
240 {$EXTERNALSYM DNS_MAX_LABEL_BUFFER_LENGTH}
241
242 //
243 // Reverse lookup domain names
244 //
245
246 DNS_IP4_REVERSE_DOMAIN_STRING = 'in-addr.arpa.';
247 {$EXTERNALSYM DNS_IP4_REVERSE_DOMAIN_STRING}
248
249 //DNS_MAX_IP4_REVERSE_NAME_LENGTH = IP_ADDRESS_STRING_LENGTH + 1 + SizeOf(DNS_IP4_REVERSE_DOMAIN_STRING);
250 //{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_LENGTH}
251
252 //DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP4_REVERSE_NAME_LENGTH + 1;
253 //{$EXTERNALSYM DNS_MAX_IP4_REVERSE_NAME_BUFFER_LENGTH}
254
255 DNS_IP6_REVERSE_DOMAIN_STRING = 'ip6.int.';
256 {$EXTERNALSYM DNS_IP6_REVERSE_DOMAIN_STRING}
257
258 DNS_MAX_IP6_REVERSE_NAME_LENGTH = 64 + SizeOf(DNS_IP6_REVERSE_DOMAIN_STRING);
259 {$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_LENGTH}
260
261 DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP6_REVERSE_NAME_LENGTH + 1;
262 {$EXTERNALSYM DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH}
263
264 // Combined
265
266 DNS_MAX_REVERSE_NAME_LENGTH = DNS_MAX_IP6_REVERSE_NAME_LENGTH;
267 {$EXTERNALSYM DNS_MAX_REVERSE_NAME_LENGTH}
268
269 DNS_MAX_REVERSE_NAME_BUFFER_LENGTH = DNS_MAX_IP6_REVERSE_NAME_BUFFER_LENGTH;
270 {$EXTERNALSYM DNS_MAX_REVERSE_NAME_BUFFER_LENGTH}
271
272 //
273 // DNS Text string limited by size representable
274 // in a single byte length field
275
276 DNS_MAX_TEXT_STRING_LENGTH = 255;
277 {$EXTERNALSYM DNS_MAX_TEXT_STRING_LENGTH}
278
279 //
280 // DNS On-The-Wire Structures
281 //
282
283 //
284 // DNS Message Header
285 //
286
287 type
288 _DNS_HEADER = packed record
289 Xid: WORD;
290 Flags: Byte;
291 //BYTE RecursionDesired : 1;
292 //BYTE Truncation : 1;
293 //BYTE Authoritative : 1;
294 //BYTE Opcode : 4;
295 //BYTE IsResponse : 1;
296 Flags2: Byte;
297 //BYTE ResponseCode : 4;
298 //BYTE Reserved : 3;
299 //BYTE RecursionAvailable : 1;
300 QuestionCount: WORD;
301 AnswerCount: WORD;
302 NameServerCount: WORD;
303 AdditionalCount: WORD;
304 end;
305 {$EXTERNALSYM _DNS_HEADER}
306 DNS_HEADER = _DNS_HEADER;
307 {$EXTERNALSYM DNS_HEADER}
308 PDNS_HEADER = ^DNS_HEADER;
309 {$EXTERNALSYM PDNS_HEADER}
310 TDnsHeader = DNS_HEADER;
311 PDnsHeader = PDNS_HEADER;
312
313 //
314 // Flags as WORD
315 //
316
DNS_HEADER_FLAGSnull317 function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
318 {$EXTERNALSYM DNS_HEADER_FLAGS}
319
320 //
321 // Byte flip DNS header to\from host order.
322 //
323 // Note that this does NOT flip flags, as definition above defines
324 // flags as individual bytes for direct access to net byte order.
325 //
326
327 procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
328 {$EXTERNALSYM DNS_BYTE_FLIP_HEADER_COUNTS}
329
330 //
331 // Question name follows header
332 //
333
334 const
335 DNS_OFFSET_TO_QUESTION_NAME = SizeOf(DNS_HEADER);
336 {$EXTERNALSYM DNS_OFFSET_TO_QUESTION_NAME}
337
338 //
339 // Question immediately follows header so compressed question name
340 // 0xC000 | sizeof(DNS_HEADER)
341
342 DNS_COMPRESSED_QUESTION_NAME = $C00C;
343 {$EXTERNALSYM DNS_COMPRESSED_QUESTION_NAME}
344
345 //
346 // Packet extraction macros
347 //
348
349 {
350 #define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) \
351 ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )
352
353 #define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) \
354 ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
355 }
356
357 //
358 // DNS Question
359 //
360
361 type
362 PDNS_WIRE_QUESTION = ^DNS_WIRE_QUESTION;
363 {$EXTERNALSYM PDNS_WIRE_QUESTION}
364 _DNS_WIRE_QUESTION = packed record
365 // Preceded by question name
366 QuestionType: WORD;
367 QuestionClass: WORD;
368 end;
369 {$EXTERNALSYM _DNS_WIRE_QUESTION}
370 DNS_WIRE_QUESTION = _DNS_WIRE_QUESTION;
371 {$EXTERNALSYM DNS_WIRE_QUESTION}
372 TDnsWireQuestion = DNS_WIRE_QUESTION;
373 PDnsWireQuestion = PDNS_WIRE_QUESTION;
374
375 //
376 // DNS Resource Record
377 //
378
379 PDNS_WIRE_RECORD = ^DNS_WIRE_RECORD;
380 {$EXTERNALSYM PDNS_WIRE_RECORD}
381 _DNS_WIRE_RECORD = packed record
382 // Preceded by record owner name
383 RecordType: WORD;
384 RecordClass: WORD;
385 TimeToLive: DWORD;
386 DataLength: WORD;
387 // Followed by record data
388 end;
389 {$EXTERNALSYM _DNS_WIRE_RECORD}
390 DNS_WIRE_RECORD = _DNS_WIRE_RECORD;
391 {$EXTERNALSYM DNS_WIRE_RECORD}
392 TDnsWireRecord = DNS_WIRE_RECORD;
393 PDnsWireRecord = PDNS_WIRE_RECORD;
394
395 //
396 // DNS Query Types
397 //
398
399 const
400 DNS_OPCODE_QUERY = 0; // Query
401 {$EXTERNALSYM DNS_OPCODE_QUERY}
402 DNS_OPCODE_IQUERY = 1; // Obsolete: IP to name
403 {$EXTERNALSYM DNS_OPCODE_IQUERY}
404 DNS_OPCODE_SERVER_STATUS = 2; // Obsolete: DNS ping
405 {$EXTERNALSYM DNS_OPCODE_SERVER_STATUS}
406 DNS_OPCODE_UNKNOWN = 3; // Unknown
407 {$EXTERNALSYM DNS_OPCODE_UNKNOWN}
408 DNS_OPCODE_NOTIFY = 4; // Notify
409 {$EXTERNALSYM DNS_OPCODE_NOTIFY}
410 DNS_OPCODE_UPDATE = 5; // Dynamic Update
411 {$EXTERNALSYM DNS_OPCODE_UPDATE}
412
413 //
414 // DNS response codes.
415 //
416 // Sent in the "ResponseCode" field of a DNS_HEADER.
417 //
418
419 DNS_RCODE_NOERROR = 0;
420 {$EXTERNALSYM DNS_RCODE_NOERROR}
421 DNS_RCODE_FORMERR = 1; // Format error
422 {$EXTERNALSYM DNS_RCODE_FORMERR}
423 DNS_RCODE_SERVFAIL = 2; // Server failure
424 {$EXTERNALSYM DNS_RCODE_SERVFAIL}
425 DNS_RCODE_NXDOMAIN = 3; // Name error
426 {$EXTERNALSYM DNS_RCODE_NXDOMAIN}
427 DNS_RCODE_NOTIMPL = 4; // Not implemented
428 {$EXTERNALSYM DNS_RCODE_NOTIMPL}
429 DNS_RCODE_REFUSED = 5; // Refused
430 {$EXTERNALSYM DNS_RCODE_REFUSED}
431 DNS_RCODE_YXDOMAIN = 6; // Domain name should not exist
432 {$EXTERNALSYM DNS_RCODE_YXDOMAIN}
433 DNS_RCODE_YXRRSET = 7; // RR set should not exist
434 {$EXTERNALSYM DNS_RCODE_YXRRSET}
435 DNS_RCODE_NXRRSET = 8; // RR set does not exist
436 {$EXTERNALSYM DNS_RCODE_NXRRSET}
437 DNS_RCODE_NOTAUTH = 9; // Not authoritative for zone
438 {$EXTERNALSYM DNS_RCODE_NOTAUTH}
439 DNS_RCODE_NOTZONE = 10; // Name is not zone
440 {$EXTERNALSYM DNS_RCODE_NOTZONE}
441 DNS_RCODE_MAX = 15;
442 {$EXTERNALSYM DNS_RCODE_MAX}
443
444 //
445 // Extended RCODEs
446 //
447
448 DNS_RCODE_BADVERS = 16; // Bad EDNS version
449 {$EXTERNALSYM DNS_RCODE_BADVERS}
450 DNS_RCODE_BADSIG = 16; // Bad signature
451 {$EXTERNALSYM DNS_RCODE_BADSIG}
452 DNS_RCODE_BADKEY = 17; // Bad key
453 {$EXTERNALSYM DNS_RCODE_BADKEY}
454 DNS_RCODE_BADTIME = 18; // Bad timestamp
455 {$EXTERNALSYM DNS_RCODE_BADTIME}
456
457 //
458 // Mappings to friendly names
459 //
460
461 DNS_RCODE_NO_ERROR = DNS_RCODE_NOERROR;
462 {$EXTERNALSYM DNS_RCODE_NO_ERROR}
463 DNS_RCODE_FORMAT_ERROR = DNS_RCODE_FORMERR;
464 {$EXTERNALSYM DNS_RCODE_FORMAT_ERROR}
465 DNS_RCODE_SERVER_FAILURE = DNS_RCODE_SERVFAIL;
466 {$EXTERNALSYM DNS_RCODE_SERVER_FAILURE}
467 DNS_RCODE_NAME_ERROR = DNS_RCODE_NXDOMAIN;
468 {$EXTERNALSYM DNS_RCODE_NAME_ERROR}
469 DNS_RCODE_NOT_IMPLEMENTED = DNS_RCODE_NOTIMPL;
470 {$EXTERNALSYM DNS_RCODE_NOT_IMPLEMENTED}
471
472 //
473 // DNS Classes
474 //
475 // Classes are on the wire as WORDs.
476 //
477 // _CLASS_ defines in host order.
478 // _RCLASS_ defines in net byte order.
479 //
480 // Generally we'll avoid byte flip and test class in net byte order.
481 //
482
483 DNS_CLASS_INTERNET = $0001; // 1
484 {$EXTERNALSYM DNS_CLASS_INTERNET}
485 DNS_CLASS_CSNET = $0002; // 2
486 {$EXTERNALSYM DNS_CLASS_CSNET}
487 DNS_CLASS_CHAOS = $0003; // 3
488 {$EXTERNALSYM DNS_CLASS_CHAOS}
489 DNS_CLASS_HESIOD = $0004; // 4
490 {$EXTERNALSYM DNS_CLASS_HESIOD}
491 DNS_CLASS_NONE = $00fe; // 254
492 {$EXTERNALSYM DNS_CLASS_NONE}
493 DNS_CLASS_ALL = $00ff; // 255
494 {$EXTERNALSYM DNS_CLASS_ALL}
495 DNS_CLASS_ANY = $00ff; // 255
496 {$EXTERNALSYM DNS_CLASS_ANY}
497
498 DNS_RCLASS_INTERNET = $0100; // 1
499 {$EXTERNALSYM DNS_RCLASS_INTERNET}
500 DNS_RCLASS_CSNET = $0200; // 2
501 {$EXTERNALSYM DNS_RCLASS_CSNET}
502 DNS_RCLASS_CHAOS = $0300; // 3
503 {$EXTERNALSYM DNS_RCLASS_CHAOS}
504 DNS_RCLASS_HESIOD = $0400; // 4
505 {$EXTERNALSYM DNS_RCLASS_HESIOD}
506 DNS_RCLASS_NONE = $fe00; // 254
507 {$EXTERNALSYM DNS_RCLASS_NONE}
508 DNS_RCLASS_ALL = $ff00; // 255
509 {$EXTERNALSYM DNS_RCLASS_ALL}
510 DNS_RCLASS_ANY = $ff00; // 255
511 {$EXTERNALSYM DNS_RCLASS_ANY}
512
513 //
514 // DNS Record Types
515 //
516 // _TYPE_ defines are in host byte order.
517 // _RTYPE_ defines are in net byte order.
518 //
519 // Generally always deal with types in host byte order as we index
520 // resource record functions by type.
521 //
522
523 DNS_TYPE_ZERO = $0000;
524 {$EXTERNALSYM DNS_TYPE_ZERO}
525
526 // RFC 1034/1035
527 DNS_TYPE_A = $0001; // 1
528 {$EXTERNALSYM DNS_TYPE_A}
529 DNS_TYPE_NS = $0002; // 2
530 {$EXTERNALSYM DNS_TYPE_NS}
531 DNS_TYPE_MD = $0003; // 3
532 {$EXTERNALSYM DNS_TYPE_MD}
533 DNS_TYPE_MF = $0004; // 4
534 {$EXTERNALSYM DNS_TYPE_MF}
535 DNS_TYPE_CNAME = $0005; // 5
536 {$EXTERNALSYM DNS_TYPE_CNAME}
537 DNS_TYPE_SOA = $0006; // 6
538 {$EXTERNALSYM DNS_TYPE_SOA}
539 DNS_TYPE_MB = $0007; // 7
540 {$EXTERNALSYM DNS_TYPE_MB}
541 DNS_TYPE_MG = $0008; // 8
542 {$EXTERNALSYM DNS_TYPE_MG}
543 DNS_TYPE_MR = $0009; // 9
544 {$EXTERNALSYM DNS_TYPE_MR}
545 DNS_TYPE_NULL = $000a; // 10
546 {$EXTERNALSYM DNS_TYPE_NULL}
547 DNS_TYPE_WKS = $000b; // 11
548 {$EXTERNALSYM DNS_TYPE_WKS}
549 DNS_TYPE_PTR = $000c; // 12
550 {$EXTERNALSYM DNS_TYPE_PTR}
551 DNS_TYPE_HINFO = $000d; // 13
552 {$EXTERNALSYM DNS_TYPE_HINFO}
553 DNS_TYPE_MINFO = $000e; // 14
554 {$EXTERNALSYM DNS_TYPE_MINFO}
555 DNS_TYPE_MX = $000f; // 15
556 {$EXTERNALSYM DNS_TYPE_MX}
557 DNS_TYPE_TEXT = $0010; // 16
558 {$EXTERNALSYM DNS_TYPE_TEXT}
559
560 // RFC 1183
561 DNS_TYPE_RP = $0011; // 17
562 {$EXTERNALSYM DNS_TYPE_RP}
563 DNS_TYPE_AFSDB = $0012; // 18
564 {$EXTERNALSYM DNS_TYPE_AFSDB}
565 DNS_TYPE_X25 = $0013; // 19
566 {$EXTERNALSYM DNS_TYPE_X25}
567 DNS_TYPE_ISDN = $0014; // 20
568 {$EXTERNALSYM DNS_TYPE_ISDN}
569 DNS_TYPE_RT = $0015; // 21
570 {$EXTERNALSYM DNS_TYPE_RT}
571
572 // RFC 1348
573 DNS_TYPE_NSAP = $0016; // 22
574 {$EXTERNALSYM DNS_TYPE_NSAP}
575 DNS_TYPE_NSAPPTR = $0017; // 23
576 {$EXTERNALSYM DNS_TYPE_NSAPPTR}
577
578 // RFC 2065 (DNS security)
579 DNS_TYPE_SIG = $0018; // 24
580 {$EXTERNALSYM DNS_TYPE_SIG}
581 DNS_TYPE_KEY = $0019; // 25
582 {$EXTERNALSYM DNS_TYPE_KEY}
583
584 // RFC 1664 (X.400 mail)
585 DNS_TYPE_PX = $001a; // 26
586 {$EXTERNALSYM DNS_TYPE_PX}
587
588 // RFC 1712 (Geographic position)
589 DNS_TYPE_GPOS = $001b; // 27
590 {$EXTERNALSYM DNS_TYPE_GPOS}
591
592 // RFC 1886 (IPv6 Address)
593 DNS_TYPE_AAAA = $001c; // 28
594 {$EXTERNALSYM DNS_TYPE_AAAA}
595
596 // RFC 1876 (Geographic location)
597 DNS_TYPE_LOC = $001d; // 29
598 {$EXTERNALSYM DNS_TYPE_LOC}
599
600 // RFC 2065 (Secure negative response)
601 DNS_TYPE_NXT = $001e; // 30
602 {$EXTERNALSYM DNS_TYPE_NXT}
603
604 // Patton (Endpoint Identifier)
605 DNS_TYPE_EID = $001f; // 31
606 {$EXTERNALSYM DNS_TYPE_EID}
607
608 // Patton (Nimrod Locator)
609 DNS_TYPE_NIMLOC = $0020; // 32
610 {$EXTERNALSYM DNS_TYPE_NIMLOC}
611
612 // RFC 2052 (Service location)
613 DNS_TYPE_SRV = $0021; // 33
614 {$EXTERNALSYM DNS_TYPE_SRV}
615
616 // ATM Standard something-or-another (ATM Address)
617 DNS_TYPE_ATMA = $0022; // 34
618 {$EXTERNALSYM DNS_TYPE_ATMA}
619
620 // RFC 2168 (Naming Authority Pointer)
621 DNS_TYPE_NAPTR = $0023; // 35
622 {$EXTERNALSYM DNS_TYPE_NAPTR}
623
624 // RFC 2230 (Key Exchanger)
625 DNS_TYPE_KX = $0024; // 36
626 {$EXTERNALSYM DNS_TYPE_KX}
627
628 // RFC 2538 (CERT)
629 DNS_TYPE_CERT = $0025; // 37
630 {$EXTERNALSYM DNS_TYPE_CERT}
631
632 // A6 Draft (A6)
633 DNS_TYPE_A6 = $0026; // 38
634 {$EXTERNALSYM DNS_TYPE_A6}
635
636 // DNAME Draft (DNAME)
637 DNS_TYPE_DNAME = $0027; // 39
638 {$EXTERNALSYM DNS_TYPE_DNAME}
639
640 // Eastlake (Kitchen Sink)
641 DNS_TYPE_SINK = $0028; // 40
642 {$EXTERNALSYM DNS_TYPE_SINK}
643
644 // RFC 2671 (EDNS OPT)
645 DNS_TYPE_OPT = $0029; // 41
646 {$EXTERNALSYM DNS_TYPE_OPT}
647
648 //
649 // IANA Reserved
650 //
651
652 DNS_TYPE_UINFO = $0064; // 100
653 {$EXTERNALSYM DNS_TYPE_UINFO}
654 DNS_TYPE_UID = $0065; // 101
655 {$EXTERNALSYM DNS_TYPE_UID}
656 DNS_TYPE_GID = $0066; // 102
657 {$EXTERNALSYM DNS_TYPE_GID}
658 DNS_TYPE_UNSPEC = $0067; // 103
659 {$EXTERNALSYM DNS_TYPE_UNSPEC}
660
661 //
662 // Query only types (1035, 1995)
663 // - Crawford (ADDRS)
664 // - TKEY draft (TKEY)
665 // - TSIG draft (TSIG)
666 // - RFC 1995 (IXFR)
667 // - RFC 1035 (AXFR up)
668 //
669
670 DNS_TYPE_ADDRS = $00f8; // 248
671 {$EXTERNALSYM DNS_TYPE_ADDRS}
672 DNS_TYPE_TKEY = $00f9; // 249
673 {$EXTERNALSYM DNS_TYPE_TKEY}
674 DNS_TYPE_TSIG = $00fa; // 250
675 {$EXTERNALSYM DNS_TYPE_TSIG}
676 DNS_TYPE_IXFR = $00fb; // 251
677 {$EXTERNALSYM DNS_TYPE_IXFR}
678 DNS_TYPE_AXFR = $00fc; // 252
679 {$EXTERNALSYM DNS_TYPE_AXFR}
680 DNS_TYPE_MAILB = $00fd; // 253
681 {$EXTERNALSYM DNS_TYPE_MAILB}
682 DNS_TYPE_MAILA = $00fe; // 254
683 {$EXTERNALSYM DNS_TYPE_MAILA}
684 DNS_TYPE_ALL = $00ff; // 255
685 {$EXTERNALSYM DNS_TYPE_ALL}
686 DNS_TYPE_ANY = $00ff; // 255
687 {$EXTERNALSYM DNS_TYPE_ANY}
688
689 //
690 // Temp Microsoft types -- use until get IANA approval for real type
691 //
692
693 DNS_TYPE_WINS = $ff01; // 64K - 255
694 {$EXTERNALSYM DNS_TYPE_WINS}
695 DNS_TYPE_WINSR = $ff02; // 64K - 254
696 {$EXTERNALSYM DNS_TYPE_WINSR}
697 DNS_TYPE_NBSTAT = DNS_TYPE_WINSR;
698 {$EXTERNALSYM DNS_TYPE_NBSTAT}
699
700 //
701 // DNS Record Types -- Net Byte Order
702 //
703
704 DNS_RTYPE_A = $0100; // 1
705 {$EXTERNALSYM DNS_RTYPE_A}
706 DNS_RTYPE_NS = $0200; // 2
707 {$EXTERNALSYM DNS_RTYPE_NS}
708 DNS_RTYPE_MD = $0300; // 3
709 {$EXTERNALSYM DNS_RTYPE_MD}
710 DNS_RTYPE_MF = $0400; // 4
711 {$EXTERNALSYM DNS_RTYPE_MF}
712 DNS_RTYPE_CNAME = $0500; // 5
713 {$EXTERNALSYM DNS_RTYPE_CNAME}
714 DNS_RTYPE_SOA = $0600; // 6
715 {$EXTERNALSYM DNS_RTYPE_SOA}
716 DNS_RTYPE_MB = $0700; // 7
717 {$EXTERNALSYM DNS_RTYPE_MB}
718 DNS_RTYPE_MG = $0800; // 8
719 {$EXTERNALSYM DNS_RTYPE_MG}
720 DNS_RTYPE_MR = $0900; // 9
721 {$EXTERNALSYM DNS_RTYPE_MR}
722 DNS_RTYPE_NULL = $0a00; // 10
723 {$EXTERNALSYM DNS_RTYPE_NULL}
724 DNS_RTYPE_WKS = $0b00; // 11
725 {$EXTERNALSYM DNS_RTYPE_WKS}
726 DNS_RTYPE_PTR = $0c00; // 12
727 {$EXTERNALSYM DNS_RTYPE_PTR}
728 DNS_RTYPE_HINFO = $0d00; // 13
729 {$EXTERNALSYM DNS_RTYPE_HINFO}
730 DNS_RTYPE_MINFO = $0e00; // 14
731 {$EXTERNALSYM DNS_RTYPE_MINFO}
732 DNS_RTYPE_MX = $0f00; // 15
733 {$EXTERNALSYM DNS_RTYPE_MX}
734 DNS_RTYPE_TEXT = $1000; // 16
735 {$EXTERNALSYM DNS_RTYPE_TEXT}
736 DNS_RTYPE_RP = $1100; // 17
737 {$EXTERNALSYM DNS_RTYPE_RP}
738 DNS_RTYPE_AFSDB = $1200; // 18
739 {$EXTERNALSYM DNS_RTYPE_AFSDB}
740 DNS_RTYPE_X25 = $1300; // 19
741 {$EXTERNALSYM DNS_RTYPE_X25}
742 DNS_RTYPE_ISDN = $1400; // 20
743 {$EXTERNALSYM DNS_RTYPE_ISDN}
744 DNS_RTYPE_RT = $1500; // 21
745 {$EXTERNALSYM DNS_RTYPE_RT}
746 DNS_RTYPE_NSAP = $1600; // 22
747 {$EXTERNALSYM DNS_RTYPE_NSAP}
748 DNS_RTYPE_NSAPPTR = $1700; // 23
749 {$EXTERNALSYM DNS_RTYPE_NSAPPTR}
750 DNS_RTYPE_SIG = $1800; // 24
751 {$EXTERNALSYM DNS_RTYPE_SIG}
752 DNS_RTYPE_KEY = $1900; // 25
753 {$EXTERNALSYM DNS_RTYPE_KEY}
754 DNS_RTYPE_PX = $1a00; // 26
755 {$EXTERNALSYM DNS_RTYPE_PX}
756 DNS_RTYPE_GPOS = $1b00; // 27
757 {$EXTERNALSYM DNS_RTYPE_GPOS}
758 DNS_RTYPE_AAAA = $1c00; // 28
759 {$EXTERNALSYM DNS_RTYPE_AAAA}
760 DNS_RTYPE_LOC = $1d00; // 29
761 {$EXTERNALSYM DNS_RTYPE_LOC}
762 DNS_RTYPE_NXT = $1e00; // 30
763 {$EXTERNALSYM DNS_RTYPE_NXT}
764 DNS_RTYPE_EID = $1f00; // 31
765 {$EXTERNALSYM DNS_RTYPE_EID}
766 DNS_RTYPE_NIMLOC = $2000; // 32
767 {$EXTERNALSYM DNS_RTYPE_NIMLOC}
768 DNS_RTYPE_SRV = $2100; // 33
769 {$EXTERNALSYM DNS_RTYPE_SRV}
770 DNS_RTYPE_ATMA = $2200; // 34
771 {$EXTERNALSYM DNS_RTYPE_ATMA}
772 DNS_RTYPE_NAPTR = $2300; // 35
773 {$EXTERNALSYM DNS_RTYPE_NAPTR}
774 DNS_RTYPE_KX = $2400; // 36
775 {$EXTERNALSYM DNS_RTYPE_KX}
776 DNS_RTYPE_CERT = $2500; // 37
777 {$EXTERNALSYM DNS_RTYPE_CERT}
778 DNS_RTYPE_A6 = $2600; // 38
779 {$EXTERNALSYM DNS_RTYPE_A6}
780 DNS_RTYPE_DNAME = $2700; // 39
781 {$EXTERNALSYM DNS_RTYPE_DNAME}
782 DNS_RTYPE_SINK = $2800; // 40
783 {$EXTERNALSYM DNS_RTYPE_SINK}
784 DNS_RTYPE_OPT = $2900; // 41
785 {$EXTERNALSYM DNS_RTYPE_OPT}
786
787 //
788 // IANA Reserved
789 //
790
791 DNS_RTYPE_UINFO = $6400; // 100
792 {$EXTERNALSYM DNS_RTYPE_UINFO}
793 DNS_RTYPE_UID = $6500; // 101
794 {$EXTERNALSYM DNS_RTYPE_UID}
795 DNS_RTYPE_GID = $6600; // 102
796 {$EXTERNALSYM DNS_RTYPE_GID}
797 DNS_RTYPE_UNSPEC = $6700; // 103
798 {$EXTERNALSYM DNS_RTYPE_UNSPEC}
799
800 //
801 // Query only types
802 //
803
804 DNS_RTYPE_TKEY = $f900; // 249
805 {$EXTERNALSYM DNS_RTYPE_TKEY}
806 DNS_RTYPE_TSIG = $fa00; // 250
807 {$EXTERNALSYM DNS_RTYPE_TSIG}
808 DNS_RTYPE_IXFR = $fb00; // 251
809 {$EXTERNALSYM DNS_RTYPE_IXFR}
810 DNS_RTYPE_AXFR = $fc00; // 252
811 {$EXTERNALSYM DNS_RTYPE_AXFR}
812 DNS_RTYPE_MAILB = $fd00; // 253
813 {$EXTERNALSYM DNS_RTYPE_MAILB}
814 DNS_RTYPE_MAILA = $fe00; // 254
815 {$EXTERNALSYM DNS_RTYPE_MAILA}
816 DNS_RTYPE_ALL = $ff00; // 255
817 {$EXTERNALSYM DNS_RTYPE_ALL}
818 DNS_RTYPE_ANY = $ff00; // 255
819 {$EXTERNALSYM DNS_RTYPE_ANY}
820
821 //
822 // Temp Microsoft types -- use until get IANA approval for real type
823 //
824
825 DNS_RTYPE_WINS = $01ff; // 64K - 255
826 {$EXTERNALSYM DNS_RTYPE_WINS}
827 DNS_RTYPE_WINSR = $02ff; // 64K - 254
828 {$EXTERNALSYM DNS_RTYPE_WINSR}
829
830 //
831 // Record type specific definitions
832 //
833
834 //
835 // ATMA (ATM address type) formats
836 //
837 // Define these directly for any environment (ex NT4)
838 // without winsock2 ATM support (ws2atm.h)
839 //
840
841 DNS_ATMA_FORMAT_E164 = ATM_E164;
842 {$EXTERNALSYM DNS_ATMA_FORMAT_E164}
843 DNS_ATMA_FORMAT_AESA = ATM_AESA;
844 {$EXTERNALSYM DNS_ATMA_FORMAT_AESA}
845 DNS_ATMA_MAX_ADDR_LENGTH = ATM_ADDR_SIZE;
846 {$EXTERNALSYM DNS_ATMA_MAX_ADDR_LENGTH}
847
848 DNS_ATMA_AESA_ADDR_LENGTH = 20;
849 {$EXTERNALSYM DNS_ATMA_AESA_ADDR_LENGTH}
850 DNS_ATMA_MAX_RECORD_LENGTH = DNS_ATMA_MAX_ADDR_LENGTH + 1;
851 {$EXTERNALSYM DNS_ATMA_MAX_RECORD_LENGTH}
852
853 //
854 // DNSSEC defs
855 //
856
857 // DNSSEC algorithms
858
859 DNSSEC_ALGORITHM_RSAMD5 = 1;
860 {$EXTERNALSYM DNSSEC_ALGORITHM_RSAMD5}
861 DNSSEC_ALGORITHM_NULL = 253;
862 {$EXTERNALSYM DNSSEC_ALGORITHM_NULL}
863 DNSSEC_ALGORITHM_PRIVATE = 254;
864 {$EXTERNALSYM DNSSEC_ALGORITHM_PRIVATE}
865
866 // DNSSEC KEY protocol table
867
868 DNSSEC_PROTOCOL_NONE = 0;
869 {$EXTERNALSYM DNSSEC_PROTOCOL_NONE}
870 DNSSEC_PROTOCOL_TLS = 1;
871 {$EXTERNALSYM DNSSEC_PROTOCOL_TLS}
872 DNSSEC_PROTOCOL_EMAIL = 2;
873 {$EXTERNALSYM DNSSEC_PROTOCOL_EMAIL}
874 DNSSEC_PROTOCOL_DNSSEC = 3;
875 {$EXTERNALSYM DNSSEC_PROTOCOL_DNSSEC}
876 DNSSEC_PROTOCOL_IPSEC = 4;
877 {$EXTERNALSYM DNSSEC_PROTOCOL_IPSEC}
878
879 // DNSSEC KEY flag field
880
881 DNSSEC_KEY_FLAG_NOAUTH = $0001;
882 {$EXTERNALSYM DNSSEC_KEY_FLAG_NOAUTH}
883 DNSSEC_KEY_FLAG_NOCONF = $0002;
884 {$EXTERNALSYM DNSSEC_KEY_FLAG_NOCONF}
885 DNSSEC_KEY_FLAG_FLAG2 = $0004;
886 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG2}
887 DNSSEC_KEY_FLAG_EXTEND = $0008;
888 {$EXTERNALSYM DNSSEC_KEY_FLAG_EXTEND}
889 {$DEFINE DNSSEC_KEY_FLAG_}
890 DNSSEC_KEY_FLAG_FLAG4 = $0010;
891 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG4}
892 DNSSEC_KEY_FLAG_FLAG5 = $0020;
893 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG5}
894
895 // bits 6,7 are name type
896
897 DNSSEC_KEY_FLAG_USER = $0000;
898 {$EXTERNALSYM DNSSEC_KEY_FLAG_USER}
899 DNSSEC_KEY_FLAG_ZONE = $0040;
900 {$EXTERNALSYM DNSSEC_KEY_FLAG_ZONE}
901 DNSSEC_KEY_FLAG_HOST = $0080;
902 {$EXTERNALSYM DNSSEC_KEY_FLAG_HOST}
903 DNSSEC_KEY_FLAG_NTPE3 = $00c0;
904 {$EXTERNALSYM DNSSEC_KEY_FLAG_NTPE3}
905
906 // bits 8-11 are reserved for future use
907
908 DNSSEC_KEY_FLAG_FLAG8 = $0100;
909 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG8}
910 DNSSEC_KEY_FLAG_FLAG9 = $0200;
911 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG9}
912 DNSSEC_KEY_FLAG_FLAG10 = $0400;
913 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG10}
914 DNSSEC_KEY_FLAG_FLAG11 = $0800;
915 {$EXTERNALSYM DNSSEC_KEY_FLAG_FLAG11}
916
917 // bits 12-15 are sig field
918
919 DNSSEC_KEY_FLAG_SIG0 = $0000;
920 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG0}
921 DNSSEC_KEY_FLAG_SIG1 = $1000;
922 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG1}
923 DNSSEC_KEY_FLAG_SIG2 = $2000;
924 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG2}
925 DNSSEC_KEY_FLAG_SIG3 = $3000;
926 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG3}
927 DNSSEC_KEY_FLAG_SIG4 = $4000;
928 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG4}
929 DNSSEC_KEY_FLAG_SIG5 = $5000;
930 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG5}
931 DNSSEC_KEY_FLAG_SIG6 = $6000;
932 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG6}
933 DNSSEC_KEY_FLAG_SIG7 = $7000;
934 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG7}
935 DNSSEC_KEY_FLAG_SIG8 = $8000;
936 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG8}
937 DNSSEC_KEY_FLAG_SIG9 = $9000;
938 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG9}
939 DNSSEC_KEY_FLAG_SIG10 = $a000;
940 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG10}
941 DNSSEC_KEY_FLAG_SIG11 = $b000;
942 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG11}
943 DNSSEC_KEY_FLAG_SIG12 = $c000;
944 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG12}
945 DNSSEC_KEY_FLAG_SIG13 = $d000;
946 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG13}
947 DNSSEC_KEY_FLAG_SIG14 = $e000;
948 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG14}
949 DNSSEC_KEY_FLAG_SIG15 = $f000;
950 {$EXTERNALSYM DNSSEC_KEY_FLAG_SIG15}
951
952 //
953 // TKEY modes
954 //
955
956 DNS_TKEY_MODE_SERVER_ASSIGN = 1;
957 {$EXTERNALSYM DNS_TKEY_MODE_SERVER_ASSIGN}
958 DNS_TKEY_MODE_DIFFIE_HELLMAN = 2;
959 {$EXTERNALSYM DNS_TKEY_MODE_DIFFIE_HELLMAN}
960 DNS_TKEY_MODE_GSS = 3;
961 {$EXTERNALSYM DNS_TKEY_MODE_GSS}
962 DNS_TKEY_MODE_RESOLVER_ASSIGN = 4;
963 {$EXTERNALSYM DNS_TKEY_MODE_RESOLVER_ASSIGN}
964
965 //
966 // WINS + NBSTAT flag field
967 //
968
969 DNS_WINS_FLAG_SCOPE = DWORD($80000000);
970 {$EXTERNALSYM DNS_WINS_FLAG_SCOPE}
971 DNS_WINS_FLAG_LOCAL = $00010000;
972 {$EXTERNALSYM DNS_WINS_FLAG_LOCAL}
973
974 //
975 // Helpful checks
976 //
977
978 function IS_WORD_ALIGNED(P: Pointer): BOOL;
979 {$EXTERNALSYM IS_DWORD_ALIGNED}
980
981 function IS_DWORD_ALIGNED(P: Pointer): BOOL;
982 {$EXTERNALSYM IS_DWORD_ALIGNED}
983
984 function IS_QWORD_ALIGNED(P: Pointer): BOOL;
985 {$EXTERNALSYM IS_QWORD_ALIGNED}
986
987 //
988 // DNS config API
989 //
990
991 //
992 // Types of DNS configuration info
993 //
994
995 type
996 DNS_CONFIG_TYPE = (
997 // In Win2K
998 DnsConfigPrimaryDomainName_W,
999 DnsConfigPrimaryDomainName_A,
1000 DnsConfigPrimaryDomainName_UTF8,
1001
1002 // Not available yet
1003 DnsConfigAdapterDomainName_W,
1004 DnsConfigAdapterDomainName_A,
1005 DnsConfigAdapterDomainName_UTF8,
1006
1007 // In Win2K
1008 DnsConfigDnsServerList,
1009
1010 // Not available yet
1011 DnsConfigSearchList,
1012 DnsConfigAdapterInfo,
1013
1014 // In Win2K
1015 DnsConfigPrimaryHostNameRegistrationEnabled,
1016 DnsConfigAdapterHostNameRegistrationEnabled,
1017 DnsConfigAddressRegistrationMaxCount,
1018
1019 // In WindowsXP
1020 DnsConfigHostName_W,
1021 DnsConfigHostName_A,
1022 DnsConfigHostName_UTF8,
1023 DnsConfigFullHostName_W,
1024 DnsConfigFullHostName_A,
1025 DnsConfigFullHostName_UTF8);
1026 {$EXTERNALSYM DNS_CONFIG_TYPE}
1027 TDnsConfigType = DNS_CONFIG_TYPE;
1028
1029 //
1030 // Config API flags
1031 //
1032
1033 //
1034 // Causes config info to be allocated with LocalAlloc()
1035 //
1036
1037 const
1038 DNS_CONFIG_FLAG_ALLOC = $00000001;
1039 {$EXTERNALSYM DNS_CONFIG_FLAG_ALLOC}
1040
1041 function DnsQueryConfig(Config: DNS_CONFIG_TYPE; Flag: DWORD; pwsAdapterName: PWSTR; pReserved, pBuffer: PVOID; pBufferLength: PDWORD): DNS_STATUS; stdcall;
1042 {$EXTERNALSYM DnsQueryConfig}
1043
1044 //
1045 // DNS resource record structure
1046 //
1047
1048 //
1049 // Record data for specific types
1050 //
1051
1052 type
1053 PDNS_A_DATA = ^DNS_A_DATA;
1054 {$EXTERNALSYM PDNS_A_DATA}
1055 DNS_A_DATA = record
1056 IpAddress: IP4_ADDRESS;
1057 end;
1058 {$EXTERNALSYM DNS_A_DATA}
1059 TDnsAData = DNS_A_DATA;
1060 PDnsAData = PDNS_A_DATA;
1061
1062 PDNS_PTR_DATA = ^DNS_PTR_DATA;
1063 {$EXTERNALSYM PDNS_PTR_DATA}
1064 DNS_PTR_DATA = record
1065 pNameHost: LPTSTR;
1066 end;
1067 {$EXTERNALSYM DNS_PTR_DATA}
1068 TDnsPtrData = DNS_PTR_DATA;
1069 PDnsPtrData = PDNS_PTR_DATA;
1070
1071 PDNS_SOA_DATA = ^DNS_SOA_DATA;
1072 {$EXTERNALSYM PDNS_SOA_DATA}
1073 DNS_SOA_DATA = record
1074 pNamePrimaryServer: LPTSTR;
1075 pNameAdministrator: LPTSTR;
1076 dwSerialNo: DWORD;
1077 dwRefresh: DWORD;
1078 dwRetry: DWORD;
1079 dwExpire: DWORD;
1080 dwDefaultTtl: DWORD;
1081 end;
1082 {$EXTERNALSYM DNS_SOA_DATA}
1083 TDnsSoaData = DNS_SOA_DATA;
1084 PDnsSoaData = PDNS_SOA_DATA;
1085
1086 PDNS_MINFO_DATA = ^DNS_MINFO_DATA;
1087 {$EXTERNALSYM PDNS_MINFO_DATA}
1088 DNS_MINFO_DATA = record
1089 pNameMailbox: LPTSTR;
1090 pNameErrorsMailbox: LPTSTR;
1091 end;
1092 {$EXTERNALSYM DNS_MINFO_DATA}
1093 TDnsMinfoData = DNS_MINFO_DATA;
1094 PDnsMinfoData = PDNS_MINFO_DATA;
1095
1096 PDNS_MX_DATA = ^DNS_MX_DATA;
1097 {$EXTERNALSYM PDNS_MX_DATA}
1098 DNS_MX_DATA = record
1099 pNameExchange: LPTSTR;
1100 wPreference: WORD;
1101 Pad: WORD; // keep ptrs DWORD aligned
1102 end;
1103 {$EXTERNALSYM DNS_MX_DATA}
1104 TDnsMxData = DNS_MX_DATA;
1105 PDnsMxData = PDNS_MX_DATA;
1106
1107 PDNS_TXT_DATA = ^DNS_TXT_DATA;
1108 {$EXTERNALSYM PDNS_TXT_DATA}
1109 DNS_TXT_DATA = record
1110 dwStringCount: DWORD;
1111 pStringArray: array [0..0] of LPTSTR;
1112 end;
1113 {$EXTERNALSYM DNS_TXT_DATA}
1114 TDnsTxtData = DNS_TXT_DATA;
1115 PDnsTxtData = PDNS_TXT_DATA;
1116
1117 PDNS_NULL_DATA = ^DNS_NULL_DATA;
1118 {$EXTERNALSYM PDNS_NULL_DATA}
1119 DNS_NULL_DATA = record
1120 dwByteCount: DWORD;
1121 Data: array [0..0] of BYTE;
1122 end;
1123 {$EXTERNALSYM DNS_NULL_DATA}
1124 TDnsNullData = DNS_NULL_DATA;
1125 PDnsNullData = PDNS_NULL_DATA;
1126
1127 PDNS_WKS_DATA = ^DNS_WKS_DATA;
1128 {$EXTERNALSYM PDNS_WKS_DATA}
1129 DNS_WKS_DATA = record
1130 IpAddress: IP4_ADDRESS;
1131 chProtocol: UCHAR;
1132 BitMask: array [0..0] of BYTE;
1133 end;
1134 {$EXTERNALSYM DNS_WKS_DATA}
1135 TDnsWksData = DNS_WKS_DATA;
1136 PDnsWksData = PDNS_WKS_DATA;
1137
1138 PDNS_AAAA_DATA = ^DNS_AAAA_DATA;
1139 {$EXTERNALSYM PDNS_AAAA_DATA}
1140 DNS_AAAA_DATA = record
1141 Ip6Address: DNS_IP6_ADDRESS;
1142 end;
1143 {$EXTERNALSYM DNS_AAAA_DATA}
1144 TDnsAaaaData = DNS_AAAA_DATA;
1145 PDnsAaaaData = PDNS_AAAA_DATA;
1146
1147 PDNS_SIG_DATA = ^DNS_SIG_DATA;
1148 {$EXTERNALSYM PDNS_SIG_DATA}
1149 DNS_SIG_DATA = record
1150 pNameSigner: LPTSTR;
1151 wTypeCovered: WORD;
1152 chAlgorithm: BYTE;
1153 chLabelCount: BYTE;
1154 dwOriginalTtl: DWORD;
1155 dwExpiration: DWORD;
1156 dwTimeSigned: DWORD;
1157 wKeyTag: WORD;
1158 Pad: WORD; // keep byte field aligned
1159 Signature: array [0..0] of BYTE;
1160 end;
1161 {$EXTERNALSYM DNS_SIG_DATA}
1162 TDnsSigData = DNS_SIG_DATA;
1163 PDnsSigData = PDNS_SIG_DATA;
1164
1165 PDNS_KEY_DATA = ^DNS_KEY_DATA;
1166 {$EXTERNALSYM PDNS_KEY_DATA}
1167 DNS_KEY_DATA = record
1168 wFlags: WORD;
1169 chProtocol: BYTE;
1170 chAlgorithm: BYTE;
1171 Key: array [0..1 - 1] of BYTE;
1172 end;
1173 {$EXTERNALSYM DNS_KEY_DATA}
1174 TDnsKeyData = DNS_KEY_DATA;
1175 PDnsKeyData = PDNS_KEY_DATA;
1176
1177 PDNS_LOC_DATA = ^DNS_LOC_DATA;
1178 {$EXTERNALSYM PDNS_LOC_DATA}
1179 DNS_LOC_DATA = record
1180 wVersion: WORD;
1181 wSize: WORD;
1182 wHorPrec: WORD;
1183 wVerPrec: WORD;
1184 dwLatitude: DWORD;
1185 dwLongitude: DWORD;
1186 dwAltitude: DWORD;
1187 end;
1188 {$EXTERNALSYM DNS_LOC_DATA}
1189 TDnsLocData = DNS_LOC_DATA;
1190 PDnsLocData = PDNS_LOC_DATA;
1191
1192 PDNS_NXT_DATA = ^DNS_NXT_DATA;
1193 {$EXTERNALSYM PDNS_NXT_DATA}
1194 DNS_NXT_DATA = record
1195 pNameNext: LPTSTR;
1196 wNumTypes: WORD;
1197 wTypes: array [0..0] of WORD;
1198 end;
1199 {$EXTERNALSYM DNS_NXT_DATA}
1200 TDnsNxtData = DNS_NXT_DATA;
1201 PDnsNxtData = PDNS_NXT_DATA;
1202
1203 PDNS_SRV_DATA = ^DNS_SRV_DATA;
1204 {$EXTERNALSYM PDNS_SRV_DATA}
1205 DNS_SRV_DATA = record
1206 pNameTarget: LPTSTR;
1207 wPriority: WORD;
1208 wWeight: WORD;
1209 wPort: WORD;
1210 Pad: WORD; // keep ptrs DWORD aligned
1211 end;
1212 {$EXTERNALSYM DNS_SRV_DATA}
1213 TDnsSrvData = DNS_SRV_DATA;
1214 PDnsSrvData = PDNS_SRV_DATA;
1215
1216 PDNS_ATMA_DATA = ^DNS_ATMA_DATA;
1217 {$EXTERNALSYM PDNS_ATMA_DATA}
1218 DNS_ATMA_DATA = record
1219 AddressType: BYTE;
1220 Address: array [0..DNS_ATMA_MAX_ADDR_LENGTH - 1] of BYTE;
1221 // E164 -- Null terminated string of less than
1222 // DNS_ATMA_MAX_ADDR_LENGTH
1223 //
1224 // For NSAP (AESA) BCD encoding of exactly
1225 // DNS_ATMA_AESA_ADDR_LENGTH
1226 end;
1227 {$EXTERNALSYM DNS_ATMA_DATA}
1228 TDnsAtmaData = DNS_ATMA_DATA;
1229 PDnsAtmaData = PDNS_ATMA_DATA;
1230
1231 PDNS_TKEY_DATA = ^DNS_TKEY_DATA;
1232 {$EXTERNALSYM PDNS_TKEY_DATA}
1233 DNS_TKEY_DATA = record
1234 pNameAlgorithm: LPTSTR;
1235 pAlgorithmPacket: PBYTE;
1236 pKey: PBYTE;
1237 pOtherData: PBYTE;
1238 dwCreateTime: DWORD;
1239 dwExpireTime: DWORD;
1240 wMode: WORD;
1241 wError: WORD;
1242 wKeyLength: WORD;
1243 wOtherLength: WORD;
1244 cAlgNameLength: UCHAR;
1245 bPacketPointers: BOOL;
1246 end;
1247 {$EXTERNALSYM DNS_TKEY_DATA}
1248 TDnsTkeyData = DNS_TKEY_DATA;
1249 PDnsTkeyData = PDNS_TKEY_DATA;
1250
1251 PDNS_TSIG_DATA = ^DNS_TSIG_DATA;
1252 {$EXTERNALSYM PDNS_TSIG_DATA}
1253 DNS_TSIG_DATA = record
1254 pNameAlgorithm: LPTSTR;
1255 pAlgorithmPacket: PBYTE;
1256 pSignature: PBYTE;
1257 pOtherData: PBYTE;
1258 i64CreateTime: LONGLONG;
1259 wFudgeTime: WORD;
1260 wOriginalXid: WORD;
1261 wError: WORD;
1262 wSigLength: WORD;
1263 wOtherLength: WORD;
1264 cAlgNameLength: UCHAR;
1265 bPacketPointers: BOOL;
1266 end;
1267 {$EXTERNALSYM DNS_TSIG_DATA}
1268 TDnsTsigData = DNS_TSIG_DATA;
1269 PDnsTsigData = PDNS_TSIG_DATA;
1270
1271 //
1272 // MS only types -- only hit the wire in MS-MS zone transfer
1273 //
1274
1275 PDNS_WINS_DATA = ^DNS_WINS_DATA;
1276 {$EXTERNALSYM PDNS_WINS_DATA}
1277 DNS_WINS_DATA = record
1278 dwMappingFlag: DWORD;
1279 dwLookupTimeout: DWORD;
1280 dwCacheTimeout: DWORD;
1281 cWinsServerCount: DWORD;
1282 WinsServers: array [0..0] of IP4_ADDRESS;
1283 end;
1284 {$EXTERNALSYM DNS_WINS_DATA}
1285 TDnsWinsData = DNS_WINS_DATA;
1286 PDnsWinsData = PDNS_WINS_DATA;
1287
1288 PDNS_WINSR_DATA = ^DNS_WINSR_DATA;
1289 {$EXTERNALSYM PDNS_WINSR_DATA}
1290 DNS_WINSR_DATA = record
1291 dwMappingFlag: DWORD;
1292 dwLookupTimeout: DWORD;
1293 dwCacheTimeout: DWORD;
1294 pNameResultDomain: LPTSTR;
1295 end;
1296 {$EXTERNALSYM DNS_WINSR_DATA}
1297 TDnsWinsrData = DNS_WINSR_DATA;
1298 PDnsWinsrData = PDNS_WINSR_DATA;
1299
1300 //
1301 // Length of non-fixed-length data types
1302 //
1303
1304 function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
1305 {$EXTERNALSYM DNS_TEXT_RECORD_LENGTH}
1306
1307 function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
1308 {$EXTERNALSYM DNS_NULL_RECORD_LENGTH}
1309
1310 function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
1311 {$EXTERNALSYM DNS_WKS_RECORD_LENGTH}
1312
1313 //function DNS_WINS_RECORD_LENGTH(IpCount: Integer): Integer;
1314 //{$EXTERNALSYM DNS_WINS_RECORD_LENGTH}
1315
1316 //
1317 // Record flags
1318 //
1319
1320 type
1321 _DnsRecordFlags = record
1322 //DWORD Section : 2;
1323 //DWORD Delete : 1;
1324 //DWORD CharSet : 2;
1325 //DWORD Unused : 3;
1326 //DWORD Reserved : 24;
1327 Flags: DWORD;
1328 end;
1329 {$EXTERNALSYM _DnsRecordFlags}
1330 DNS_RECORD_FLAGS = _DnsRecordFlags;
1331 {$EXTERNALSYM DNS_RECORD_FLAGS}
1332 TDnsRecordFlags = DNS_RECORD_FLAGS;
1333 PDnsRecordFlags = ^DNS_RECORD_FLAGS;
1334
1335 //
1336 // Wire Record Sections
1337 //
1338 // Useable both in record flags "Section" and as index into
1339 // wire message header section counts.
1340 //
1341
1342 _DnsSection = (
1343 DnsSectionQuestion,
1344 DnsSectionAnswer,
1345 DnsSectionAuthority,
1346 DnsSectionAddtional);
1347 {$EXTERNALSYM _DnsSection}
1348 DNS_SECTION = _DnsSection;
1349 TDnsSection = _DnsSection;
1350
1351 // Update message section names
1352
1353 const
1354 DnsSectionZone = DnsSectionQuestion;
1355 {$EXTERNALSYM DnsSectionZone}
1356 DnsSectionPrereq = DnsSectionAnswer;
1357 {$EXTERNALSYM DnsSectionPrereq}
1358 DnsSectionUpdate = DnsSectionAuthority;
1359 {$EXTERNALSYM DnsSectionUpdate}
1360
1361 //
1362 // Record flags as bit flags
1363 // These may be or'd together to set the fields
1364 //
1365
1366 // RR Section in packet
1367
1368 DNSREC_SECTION = $00000003;
1369 {$EXTERNALSYM DNSREC_SECTION}
1370
1371 DNSREC_QUESTION = $00000000;
1372 {$EXTERNALSYM DNSREC_QUESTION}
1373 DNSREC_ANSWER = $00000001;
1374 {$EXTERNALSYM DNSREC_ANSWER}
1375 DNSREC_AUTHORITY = $00000002;
1376 {$EXTERNALSYM DNSREC_AUTHORITY}
1377 DNSREC_ADDITIONAL = $00000003;
1378 {$EXTERNALSYM DNSREC_ADDITIONAL}
1379
1380 // RR Section in packet (update)
1381
1382 DNSREC_ZONE = $00000000;
1383 {$EXTERNALSYM DNSREC_ZONE}
1384 DNSREC_PREREQ = $00000001;
1385 {$EXTERNALSYM DNSREC_PREREQ}
1386 DNSREC_UPDATE = $00000002;
1387 {$EXTERNALSYM DNSREC_UPDATE}
1388
1389 // Delete RR (update) or No-exist (prerequisite)
1390
1391 DNSREC_DELETE = $00000004;
1392 {$EXTERNALSYM DNSREC_DELETE}
1393 DNSREC_NOEXIST = $00000004;
1394 {$EXTERNALSYM DNSREC_NOEXIST}
1395
1396 //
1397 // Record \ RR set structure
1398 //
1399 // Note: The dwReserved flag serves to insure that the substructures
1400 // start on 64-bit boundaries. Do NOT pack this structure, as the
1401 // substructures may contain pointers or int64 values which are
1402 // properly aligned unpacked.
1403 //
1404
1405 type
1406 PDNS_RECORD = ^DNS_RECORD;
1407 {$EXTERNALSYM PDNS_RECORD}
1408 _DnsRecord = record
1409 pNext: PDNS_RECORD;
1410 pName: LPTSTR;
1411 wType: WORD;
1412 wDataLength: WORD; // Not referenced for DNS record types defined above.
1413 Flags: record
1414 case Integer of
1415 0: (DW: DWORD); // flags as DWORD
1416 1: (S: DNS_RECORD_FLAGS); // flags as structure
1417 end;
1418 dwTtl: DWORD;
1419 dwReserved: DWORD;
1420
1421 // Record Data
1422
1423 Data: record
1424 case Integer of
1425 0: (A: DNS_A_DATA);
1426 1: (SOA, Soa_: DNS_SOA_DATA);
1427 2: (PTR, Ptr_,
1428 NS, Ns_,
1429 CNAME, Cname_,
1430 MB, Mb_,
1431 MD, Md_,
1432 MF, Mf_,
1433 MG, Mg_,
1434 MR, Mr_: DNS_PTR_DATA);
1435 3: (MINFO, Minfo_,
1436 RP, Rp_: DNS_MINFO_DATA);
1437 4: (MX, Mx_,
1438 AFSDB, Afsdb_,
1439 RT, Rt_: DNS_MX_DATA);
1440 5: (HINFO, Hinfo_,
1441 ISDN, Isdn_,
1442 TXT, Txt_,
1443 X25: DNS_TXT_DATA);
1444 6: (Null: DNS_NULL_DATA);
1445 7: (WKS, Wks_: DNS_WKS_DATA);
1446 8: (AAAA: DNS_AAAA_DATA);
1447 9: (KEY, Key_: DNS_KEY_DATA);
1448 10: (SIG, Sig_: DNS_SIG_DATA);
1449 11: (ATMA, Atma_: DNS_ATMA_DATA);
1450 12: (NXT, Nxt_: DNS_NXT_DATA);
1451 13: (SRV, Srv_: DNS_SRV_DATA);
1452 14: (TKEY, Tkey_: DNS_TKEY_DATA);
1453 15: (TSIG, Tsig_: DNS_TSIG_DATA);
1454 16: (WINS, Wins_: DNS_WINS_DATA);
1455 17: (WINSR, WinsR_, NBSTAT, Nbstat_: DNS_WINSR_DATA);
1456 end;
1457 end;
1458 {$EXTERNALSYM _DnsRecord}
1459 DNS_RECORD = _DnsRecord;
1460 {$EXTERNALSYM DNS_RECORD}
1461 PPDNS_RECORD = ^PDNS_RECORD;
1462 {$NODEFINE PPDNS_RECORD}
1463 TDnsRecord = DNS_RECORD;
1464 PDnsRecord = PDNS_RECORD;
1465
1466 //
1467 // Header or fixed size of DNS_RECORD
1468 //
1469
1470 const
1471 DNS_RECORD_FIXED_SIZE = 24; // FIELD_OFFSET( DNS_RECORD, Data )
1472 {$EXTERNALSYM DNS_RECORD_FIXED_SIZE}
1473 SIZEOF_DNS_RECORD_HEADER = DNS_RECORD_FIXED_SIZE;
1474 {$EXTERNALSYM SIZEOF_DNS_RECORD_HEADER}
1475
1476 //
1477 // Resource record set building
1478 //
1479 // pFirst points to first record in list.
1480 // pLast points to last record in list.
1481 //
1482
1483 type
1484 PDnsRRSet = ^DnsRRSet;
1485 {$EXTERNALSYM PDnsRRSet}
1486 _DnsRRSet = record
1487 pFirstRR: PDNS_RECORD;
1488 pLastRR: PDNS_RECORD;
1489 end;
1490 {$EXTERNALSYM _DnsRRSet}
1491 DnsRRSet = _DnsRRSet;
1492 {$EXTERNALSYM DnsRRSet}
1493 TDnsrrset = DnsRRSet;
1494
1495 //
1496 // To init pFirst is NULL.
1497 // But pLast points at the location of the pFirst pointer -- essentially
1498 // treating the pFirst ptr as a DNS_RECORD. (It is a DNS_RECORD with
1499 // only a pNext field, but that's the only part we use.)
1500 //
1501 // Then when the first record is added to the list, the pNext field of
1502 // this dummy record (which corresponds to pFirst's value) is set to
1503 // point at the first record. So pFirst then properly points at the
1504 // first record.
1505 //
1506 // (This works only because pNext is the first field in a
1507 // DNS_RECORD structure and hence casting a PDNS_RECORD ptr to
1508 // PDNS_RECORD* and dereferencing yields its pNext field)
1509 //
1510 // Use TERMINATE when have built RR set by grabbing records out of
1511 // existing set. This makes sure that at the end, the last RR is
1512 // properly NULL terminated.
1513 //
1514
1515 procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
1516 {$EXTERNALSYM DNS_RRSET_INIT}
1517
1518 //procedure DNS_RRSET_ADD(rrset, pnewRR: PDNS_RRSET);
1519 //{$EXTERNALSYM DNS_RRSET_ADD}
1520
1521 procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
1522 {$EXTERNALSYM DNS_RRSET_TERMINATE}
1523
1524 //
1525 // Record set manipulation
1526 //
1527
1528 //
1529 // Record Copy
1530 // Record copy functions also do conversion between character sets.
1531 //
1532 // Note, it might be advisable to directly expose non-Ex copy
1533 // functions _W, _A for record and set, to avoid exposing the
1534 // conversion enum.
1535 //
1536
1537 type
1538 _DNS_CHARSET = (
1539 DnsCharSetUnknown,
1540 DnsCharSetUnicode,
1541 DnsCharSetUtf8,
1542 DnsCharSetAnsi);
1543 {$EXTERNALSYM _DNS_CHARSET}
1544 DNS_CHARSET = _DNS_CHARSET;
1545 {$EXTERNALSYM DNS_CHARSET}
1546 TDnsCharSet = DNS_CHARSET;
1547 PDnsCharSet = ^DNS_CHARSET;
1548
DnsRecordCopyExnull1549 function DnsRecordCopyEx(pRecord: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
1550 {$EXTERNALSYM DnsRecordCopyEx}
1551
DnsRecordSetCopyExnull1552 function DnsRecordSetCopyEx(pRecordSet: PDNS_RECORD; CharSetIn: DNS_CHARSET; CharSetOut: DNS_CHARSET): PDNS_RECORD; stdcall;
1553 {$EXTERNALSYM DnsRecordSetCopyEx}
1554
DnsRecordCopynull1555 function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1556 {$EXTERNALSYM DnsRecordCopy}
1557
DnsRecordSetCopynull1558 function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1559 {$EXTERNALSYM DnsRecordSetCopy}
1560
1561 //
1562 // Record Compare
1563 //
1564 // Note: these routines only compare records of the SAME character set.
1565 // (ANSI, unicode or UTF8). Furthermore the routines assume the character
1566 // set is indicated within the record. If compare of user created, rather
1567 // than DNS API created record lists is desired, then caller should use
1568 // DnsRecordCopy API and compare copies.
1569 //
1570
DnsRecordComparenull1571 function DnsRecordCompare(pRecord1: PDNS_RECORD; pRecord2: PDNS_RECORD): BOOL; stdcall;
1572 {$EXTERNALSYM DnsRecordCompare}
1573
DnsRecordSetComparenull1574 function DnsRecordSetCompare(pRR1: PDNS_RECORD; pRR2: PDNS_RECORD; var ppDiff1, ppDiff2: PDNS_RECORD): BOOL; stdcall;
1575 {$EXTERNALSYM DnsRecordSetCompare}
1576
1577 //
1578 // Detach next record set from record list
1579 //
1580
DnsRecordSetDetachnull1581 function DnsRecordSetDetach(pRecordList: PDNS_RECORD): PDNS_RECORD; stdcall;
1582 {$EXTERNALSYM DnsRecordSetDetach}
1583
1584 //
1585 // Free record list
1586 //
1587 // Only supported free is deep free of entire record list with LocalFree().
1588 // This correctly frees record list returned by DnsQuery() or DnsRecordSetCopy()
1589 //
1590
1591 type
1592 DNS_FREE_TYPE = (DnsFreeFlat, DnsFreeRecordList);
1593 {$EXTERNALSYM DNS_FREE_TYPE}
1594 TDnsFreeType = DNS_FREE_TYPE;
1595
1596 procedure DnsFreeRecordListDeep(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
1597 {$EXTERNALSYM DnsFreeRecordListDeep}
1598
1599 procedure DnsRecordListFree(pRecordList: PDNS_RECORD; FreeType: DNS_FREE_TYPE); stdcall;
1600 {$EXTERNALSYM DnsRecordListFree}
1601
1602 procedure DnsFree(pData: PVOID; FreeType: DNS_FREE_TYPE); stdcall;
1603 {$EXTERNALSYM DnsFree}
1604
1605 //
1606 // DNS Query API
1607 //
1608
1609 //
1610 // Options for DnsQuery
1611 //
1612
1613 const
1614 DNS_QUERY_STANDARD = $00000000;
1615 {$EXTERNALSYM DNS_QUERY_STANDARD}
1616 DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE = $00000001;
1617 {$EXTERNALSYM DNS_QUERY_ACCEPT_TRUNCATED_RESPONSE}
1618 DNS_QUERY_USE_TCP_ONLY = $00000002;
1619 {$EXTERNALSYM DNS_QUERY_USE_TCP_ONLY}
1620 DNS_QUERY_NO_RECURSION = $00000004;
1621 {$EXTERNALSYM DNS_QUERY_NO_RECURSION}
1622 DNS_QUERY_BYPASS_CACHE = $00000008;
1623 {$EXTERNALSYM DNS_QUERY_BYPASS_CACHE}
1624
1625 DNS_QUERY_NO_WIRE_QUERY = $00000010;
1626 {$EXTERNALSYM DNS_QUERY_NO_WIRE_QUERY}
1627 DNS_QUERY_NO_LOCAL_NAME = $00000020;
1628 {$EXTERNALSYM DNS_QUERY_NO_LOCAL_NAME}
1629 DNS_QUERY_NO_HOSTS_FILE = $00000040;
1630 {$EXTERNALSYM DNS_QUERY_NO_HOSTS_FILE}
1631 DNS_QUERY_NO_NETBT = $00000080;
1632 {$EXTERNALSYM DNS_QUERY_NO_NETBT}
1633
1634 DNS_QUERY_WIRE_ONLY = $00000100;
1635 {$EXTERNALSYM DNS_QUERY_WIRE_ONLY}
1636 DNS_QUERY_RETURN_MESSAGE = $00000200;
1637 {$EXTERNALSYM DNS_QUERY_RETURN_MESSAGE}
1638
1639 DNS_QUERY_TREAT_AS_FQDN = $00001000;
1640 {$EXTERNALSYM DNS_QUERY_TREAT_AS_FQDN}
1641 DNS_QUERY_DONT_RESET_TTL_VALUES = $00100000;
1642 {$EXTERNALSYM DNS_QUERY_DONT_RESET_TTL_VALUES}
1643 DNS_QUERY_RESERVED = DWORD($ff000000);
1644 {$EXTERNALSYM DNS_QUERY_RESERVED}
1645
1646 // Backward compatibility with Win2K
1647 // Do not use
1648
1649 DNS_QUERY_CACHE_ONLY = DNS_QUERY_NO_WIRE_QUERY;
1650 {$EXTERNALSYM DNS_QUERY_CACHE_ONLY}
1651
DnsQuery_Anull1652 function DnsQuery_A(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
1653 {$EXTERNALSYM DnsQuery_A}
1654
DnsQuery_UTF8null1655 function DnsQuery_UTF8(pszName: PCSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
1656 {$EXTERNALSYM DnsQuery_UTF8}
1657
DnsQuery_Wnull1658 function DnsQuery_W(pszName: LPCWSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
1659 {$EXTERNALSYM DnsQuery_W}
1660
DnsQuerynull1661 function DnsQuery(pszName: LPCTSTR; wType: WORD; Options: DWORD; aipServers: PIP4_ARRAY; ppQueryResults: PPDNS_RECORD; pReserved: PPVOID): DNS_STATUS; stdcall;
1662 {$EXTERNALSYM DnsQuery}
1663
1664 //
1665 // DNS Update API
1666 //
1667 // DnsAcquireContextHandle
1668 // DnsReleaseContextHandle
1669 // DnsModifyRecordsInSet
1670 // DnsReplaceRecordSet
1671 //
1672
1673 //
1674 // Update flags
1675 //
1676
1677 const
1678 DNS_UPDATE_SECURITY_USE_DEFAULT = $00000000;
1679 {$EXTERNALSYM DNS_UPDATE_SECURITY_USE_DEFAULT}
1680 DNS_UPDATE_SECURITY_OFF = $00000010;
1681 {$EXTERNALSYM DNS_UPDATE_SECURITY_OFF}
1682 DNS_UPDATE_SECURITY_ON = $00000020;
1683 {$EXTERNALSYM DNS_UPDATE_SECURITY_ON}
1684 DNS_UPDATE_SECURITY_ONLY = $00000100;
1685 {$EXTERNALSYM DNS_UPDATE_SECURITY_ONLY}
1686 DNS_UPDATE_CACHE_SECURITY_CONTEXT = $00000200;
1687 {$EXTERNALSYM DNS_UPDATE_CACHE_SECURITY_CONTEXT}
1688 DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT = $00000400;
1689 {$EXTERNALSYM DNS_UPDATE_TEST_USE_LOCAL_SYS_ACCT}
1690 DNS_UPDATE_FORCE_SECURITY_NEGO = $00000800;
1691 {$EXTERNALSYM DNS_UPDATE_FORCE_SECURITY_NEGO}
1692 DNS_UPDATE_TRY_ALL_MASTER_SERVERS = $00001000;
1693 {$EXTERNALSYM DNS_UPDATE_TRY_ALL_MASTER_SERVERS}
1694 DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS = $00002000;
1695 {$EXTERNALSYM DNS_UPDATE_SKIP_NO_UPDATE_ADAPTERS}
1696 DNS_UPDATE_RESERVED = DWORD($ffff0000);
1697 {$EXTERNALSYM DNS_UPDATE_RESERVED}
1698
1699 //
1700 // Note: pCredentials paramater is currently respectively
1701 // PSEC_WINNT_AUTH_IDENTITY_W or PSEC_WINNT_AUTH_IDENTITY_A.
1702 // Using PVOID to obviate the need for including rpcdce.h
1703 // in order to include this file and to leave open the
1704 // possibility of alternative credential specifications in
1705 // the future.
1706 //
1707
DnsAcquireContextHandle_Wnull1708 function DnsAcquireContextHandle_W(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
1709 {$EXTERNALSYM DnsAcquireContextHandle_W}
1710
DnsAcquireContextHandle_Anull1711 function DnsAcquireContextHandle_A(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
1712 {$EXTERNALSYM DnsAcquireContextHandle_A}
1713
DnsAcquireContextHandlenull1714 function DnsAcquireContextHandle(CredentialFlags: DWORD; pCredentials: PVOID; pContextHandle: PHANDLE): DNS_STATUS; stdcall;
1715 {$EXTERNALSYM DnsAcquireContextHandle}
1716
1717 procedure DnsReleaseContextHandle(hContext: HANDLE); stdcall;
1718 {$EXTERNALSYM DnsReleaseContextHandle}
1719
1720 //
1721 // Dynamic Update API
1722 //
1723
DnsModifyRecordsInSet_Wnull1724 function DnsModifyRecordsInSet_W(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1725 {$EXTERNALSYM DnsModifyRecordsInSet_W}
1726
DnsModifyRecordsInSet_Anull1727 function DnsModifyRecordsInSet_A(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1728 {$EXTERNALSYM DnsModifyRecordsInSet_A}
1729
DnsModifyRecordsInSet_UTF8null1730 function DnsModifyRecordsInSet_UTF8(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1731 {$EXTERNALSYM DnsModifyRecordsInSet_UTF8}
1732
DnsModifyRecordsInSetnull1733 function DnsModifyRecordsInSet(pAddRecords: PDNS_RECORD; pDeleteRecords: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1734 {$EXTERNALSYM DnsModifyRecordsInSet}
1735
DnsReplaceRecordSetWnull1736 function DnsReplaceRecordSetW(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1737 {$EXTERNALSYM DnsReplaceRecordSetW}
1738
DnsReplaceRecordSetAnull1739 function DnsReplaceRecordSetA(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1740 {$EXTERNALSYM DnsReplaceRecordSetA}
1741
DnsReplaceRecordSetUTF8null1742 function DnsReplaceRecordSetUTF8(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1743 {$EXTERNALSYM DnsReplaceRecordSetUTF8}
1744
DnsReplaceRecordSetnull1745 function DnsReplaceRecordSet(pNewSet: PDNS_RECORD; Options: DWORD; hContext: HANDLE; pServerList: PIP4_ARRAY; pReserved: PVOID): DNS_STATUS; stdcall;
1746 {$EXTERNALSYM DnsReplaceRecordSet}
1747
1748 //
1749 // DNS name validation
1750 //
1751
1752 type
1753 _DNS_NAME_FORMAT = (
1754 DnsNameDomain,
1755 DnsNameDomainLabel,
1756 DnsNameHostnameFull,
1757 DnsNameHostnameLabel,
1758 DnsNameWildcard,
1759 DnsNameSrvRecord);
1760 {$EXTERNALSYM _DNS_NAME_FORMAT}
1761 DNS_NAME_FORMAT = _DNS_NAME_FORMAT;
1762 {$EXTERNALSYM DNS_NAME_FORMAT}
1763 TDnsNameFormat = DNS_NAME_FORMAT;
1764 PDnsNameFormat = ^DNS_NAME_FORMAT;
1765
DnsValidateName_UTF8null1766 function DnsValidateName_UTF8(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
1767 {$EXTERNALSYM DnsValidateName_UTF8}
1768
DnsValidateName_Wnull1769 function DnsValidateName_W(pwszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
1770 {$EXTERNALSYM DnsValidateName_W}
1771
DnsValidateName_Anull1772 function DnsValidateName_A(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS; stdcall;
1773 {$EXTERNALSYM DnsValidateName_A}
1774
DnsValidateNamenull1775 function DnsValidateName(pszName: LPCTSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
1776 {$EXTERNALSYM DnsValidateName}
1777
1778 //
1779 // DNS name comparison
1780 //
1781
DnsNameCompare_Anull1782 function DnsNameCompare_A(pName1: LPSTR; pName2: LPSTR): BOOL; stdcall;
1783 {$EXTERNALSYM DnsNameCompare_A}
1784
DnsNameCompare_Wnull1785 function DnsNameCompare_W(pName1: LPWSTR; pName2: LPWSTR): BOOL; stdcall;
1786 {$EXTERNALSYM DnsNameCompare_W}
1787
DnsNameComparenull1788 function DnsNameCompare(pName1: LPTSTR; pName2: LPTSTR): BOOL; stdcall;
1789 {$EXTERNALSYM DnsNameCompare}
1790
1791 //
1792 // DNS message "roll-your-own" routines
1793 //
1794
1795 type
1796 PDNS_MESSAGE_BUFFER = ^DNS_MESSAGE_BUFFER;
1797 {$EXTERNALSYM PDNS_MESSAGE_BUFFER}
1798 _DNS_MESSAGE_BUFFER = record
1799 MessageHead: DNS_HEADER;
1800 MessageBody: array [0..0] of CHAR;
1801 end;
1802 {$EXTERNALSYM _DNS_MESSAGE_BUFFER}
1803 DNS_MESSAGE_BUFFER = _DNS_MESSAGE_BUFFER;
1804 {$EXTERNALSYM DNS_MESSAGE_BUFFER}
1805 TDnsMessageBuffer = DNS_MESSAGE_BUFFER;
1806 PDnsMessageBuffer = PDNS_MESSAGE_BUFFER;
1807
DnsWriteQuestionToBuffer_Wnull1808 function DnsWriteQuestionToBuffer_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPWSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
1809 {$EXTERNALSYM DnsWriteQuestionToBuffer_W}
1810
DnsWriteQuestionToBuffer_UTF8null1811 function DnsWriteQuestionToBuffer_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; pdwBufferSize: LPDWORD; pszName: LPSTR; wType: WORD; Xid: WORD; fRecursionDesired: BOOL): BOOL; stdcall;
1812 {$EXTERNALSYM DnsWriteQuestionToBuffer_UTF8}
1813
DnsExtractRecordsFromMessage_Wnull1814 function DnsExtractRecordsFromMessage_W(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
1815 {$EXTERNALSYM DnsExtractRecordsFromMessage_W}
1816
DnsExtractRecordsFromMessage_UTF8null1817 function DnsExtractRecordsFromMessage_UTF8(pDnsBuffer: PDNS_MESSAGE_BUFFER; wMessageLength: WORD; ppRecord: PPDNS_RECORD): DNS_STATUS; stdcall;
1818 {$EXTERNALSYM DnsExtractRecordsFromMessage_UTF8}
1819
1820 {$ENDIF JWA_IMPLEMENTATIONSECTION}
1821
1822
1823
1824
1825 {$IFNDEF JWA_OMIT_SECTIONS}
1826 implementation
1827 //uses ...
1828 {$ENDIF JWA_OMIT_SECTIONS}
1829
1830 {$IFNDEF JWA_INTERFACESECTION}
1831
1832 {$IFNDEF JWA_INCLUDEMODE}
1833 const
1834 dnsapi = 'dnsapi.dll';
1835 {$IFDEF UNICODE}
1836 AWSuffix = 'W';
1837 {$ELSE}
1838 AWSuffix = 'A';
1839 {$ENDIF UNICODE}
1840 {$ENDIF JWA_INCLUDEMODE}
1841
1842 procedure INLINE_WORD_FLIP(var Out_: WORD; In_: WORD);
1843 begin
1844 Out_ := (In_ shl 8) or (In_ shr 8);
1845 end;
1846
1847 procedure INLINE_HTONS(var Out_: WORD; In_: WORD);
1848 begin
1849 INLINE_WORD_FLIP(Out_, In_);
1850 end;
1851
1852 procedure INLINE_NTOHS(var Out_: WORD; In_: WORD);
1853 begin
1854 INLINE_WORD_FLIP(Out_, In_);
1855 end;
1856
1857 procedure INLINE_DWORD_FLIP(var Out_: DWORD; In_: DWORD);
1858 begin
1859 Out_ := ((In_ shl 8) and $00ff0000) or (In_ shl 24) or
1860 ((In_ shr 8) and $0000ff00) or (In_ shr 24);
1861 end;
1862
1863 procedure INLINE_NTOHL(var Out_: DWORD; In_: DWORD);
1864 begin
1865 INLINE_DWORD_FLIP(Out_, In_);
1866 end;
1867
1868 procedure INLINE_HTONL(var Out_: DWORD; In_: DWORD);
1869 begin
1870 INLINE_DWORD_FLIP(Out_, In_);
1871 end;
1872
1873 procedure INLINE_WRITE_FLIPPED_WORD(pout: PWORD; In_: WORD);
1874 begin
1875 INLINE_WORD_FLIP(pout^, In_);
1876 end;
1877
1878 procedure INLINE_WRITE_FLIPPED_DWORD(pout: PDWORD; In_: DWORD);
1879 begin
1880 INLINE_DWORD_FLIP(pout^, In_);
1881 end;
1882
DNS_HEADER_FLAGSnull1883 function DNS_HEADER_FLAGS(pHead: PDNS_HEADER): WORD;
1884 begin
1885 Result := PWORD(@pHead^.Flags)^;
1886 end;
1887
1888 procedure DNS_BYTE_FLIP_HEADER_COUNTS(var pHeader: PDNS_HEADER);
1889 var
1890 _head: PDNS_HEADER;
1891 begin
1892 _head := pHeader;
1893 INLINE_HTONS(_head^.Xid, _head^.Xid);
1894 INLINE_HTONS(_head^.QuestionCount, _head^.QuestionCount);
1895 INLINE_HTONS(_head^.AnswerCount, _head^.AnswerCount);
1896 INLINE_HTONS(_head^.NameServerCount, _head^.NameServerCount);
1897 INLINE_HTONS(_head^.AdditionalCount, _head^.AdditionalCount);
1898 end;
1899
1900 {
1901 #define DNS_QUESTION_NAME_FROM_HEADER( _pHeader_ ) \
1902 ( (PCHAR)( (PDNS_HEADER)(_pHeader_) + 1 ) )
1903
1904 #define DNS_ANSWER_FROM_QUESTION( _pQuestion_ ) \
1905 ( (PCHAR)( (PDNS_QUESTION)(_pQuestion_) + 1 ) )
1906 }
1907
IS_WORD_ALIGNEDnull1908 function IS_WORD_ALIGNED(P: Pointer): BOOL;
1909 begin
1910 Result := (PtrUInt(P) and 1) = 0;
1911 end;
1912
IS_DWORD_ALIGNEDnull1913 function IS_DWORD_ALIGNED(P: Pointer): BOOL;
1914 begin
1915 Result := (PtrUInt(P) and 3) = 0;
1916 end;
1917
IS_QWORD_ALIGNEDnull1918 function IS_QWORD_ALIGNED(P: Pointer): BOOL;
1919 begin
1920 Result := (PtrUInt(P) and 7) = 0;
1921 end;
1922
DNS_TEXT_RECORD_LENGTHnull1923 function DNS_TEXT_RECORD_LENGTH(StringCount: Integer): Integer;
1924 begin
1925 Result := SizeOf(DWORD) + ((StringCount) * SizeOf(PChar));
1926 end;
1927
DNS_NULL_RECORD_LENGTHnull1928 function DNS_NULL_RECORD_LENGTH(ByteCount: Integer): Integer;
1929 begin
1930 Result := SizeOf(DWORD) + (ByteCount);
1931 end;
1932
DNS_WKS_RECORD_LENGTHnull1933 function DNS_WKS_RECORD_LENGTH(ByteCount: Integer): Integer;
1934 begin
1935 Result := SizeOf(DNS_WKS_DATA) + (ByteCount - 1);
1936 end;
1937
1938 //#define DNS_WINS_RECORD_LENGTH(IpCount) \
1939 // (FIELD_OFFSET(DNS_WINS_DATA, WinsServers) + ((IpCount) * sizeof(IP4_ADDRESS)))
1940
1941 procedure DNS_RRSET_INIT(rrset: PDnsRRSet);
1942 begin
1943 rrset^.pFirstRR := nil;
1944 rrset^.pLastRR := (@rrset^.pFirstRR);
1945 end;
1946
1947 //#define DNS_RRSET_ADD( rrset, pnewRR ) \
1948 // { \
1949 // PDNS_RRSET _prrset = &(rrset); \
1950 // PDNS_RECORD _prrnew = (pnewRR); \
1951 // _prrset->pLastRR->pNext = _prrnew; \
1952 // _prrset->pLastRR = _prrnew; \
1953 // }
1954
1955 procedure DNS_RRSET_TERMINATE(rrset: PDnsRRSet);
1956 begin
1957 rrset^.pLastRR^.pNext := nil;
1958 end;
1959
1960 {$IFDEF UNICODE}
1961
DnsRecordCopynull1962 function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1963 begin
1964 Result := DnsRecordCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
1965 end;
1966
DnsRecordSetCopynull1967 function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1968 begin
1969 Result := DnsRecordSetCopyEx(pRR, DnsCharSetUnicode, DnsCharSetUnicode);
1970 end;
1971
DnsValidateNamenull1972 function DnsValidateName(pszName: LPCWSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
1973 begin
1974 Result := DnsValidateName_W(pszName, Format);
1975 end;
1976
1977 {$ELSE}
1978
DnsRecordCopynull1979 function DnsRecordCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1980 begin
1981 Result := DnsRecordCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
1982 end;
1983
DnsRecordSetCopynull1984 function DnsRecordSetCopy(pRR: PDNS_RECORD): PDNS_RECORD;
1985 begin
1986 Result := DnsRecordSetCopyEx(pRR, DnsCharSetAnsi, DnsCharSetAnsi);
1987 end;
1988
DnsValidateNamenull1989 function DnsValidateName(pszName: LPCSTR; Format: DNS_NAME_FORMAT): DNS_STATUS;
1990 begin
1991 Result := DnsValidateName_A(pszName, Format);
1992 end;
1993
1994 {$ENDIF UNICODE}
1995
1996 {$IFDEF DYNAMIC_LINK}
1997
1998 var
1999 _DnsQueryConfig: Pointer;
2000
DnsQueryConfignull2001 function DnsQueryConfig;
2002 begin
2003 GetProcedureAddress(_DnsQueryConfig, dnsapi, 'DnsQueryConfig');
2004 asm
2005 MOV ESP, EBP
2006 POP EBP
2007 JMP [_DnsQueryConfig]
2008 end;
2009 end;
2010
2011 var
2012 _DnsRecordCopyEx: Pointer;
2013
DnsRecordCopyExnull2014 function DnsRecordCopyEx;
2015 begin
2016 GetProcedureAddress(_DnsRecordCopyEx, dnsapi, 'DnsRecordCopyEx');
2017 asm
2018 MOV ESP, EBP
2019 POP EBP
2020 JMP [_DnsRecordCopyEx]
2021 end;
2022 end;
2023
2024 var
2025 _DnsRecordSetCopyEx: Pointer;
2026
DnsRecordSetCopyExnull2027 function DnsRecordSetCopyEx;
2028 begin
2029 GetProcedureAddress(_DnsRecordSetCopyEx, dnsapi, 'DnsRecordSetCopyEx');
2030 asm
2031 MOV ESP, EBP
2032 POP EBP
2033 JMP [_DnsRecordSetCopyEx]
2034 end;
2035 end;
2036
2037 var
2038 _DnsRecordCompare: Pointer;
2039
DnsRecordComparenull2040 function DnsRecordCompare;
2041 begin
2042 GetProcedureAddress(_DnsRecordCompare, dnsapi, 'DnsRecordCompare');
2043 asm
2044 MOV ESP, EBP
2045 POP EBP
2046 JMP [_DnsRecordCompare]
2047 end;
2048 end;
2049
2050 var
2051 _DnsRecordSetCompare: Pointer;
2052
DnsRecordSetComparenull2053 function DnsRecordSetCompare;
2054 begin
2055 GetProcedureAddress(_DnsRecordSetCompare, dnsapi, 'DnsRecordSetCompare');
2056 asm
2057 MOV ESP, EBP
2058 POP EBP
2059 JMP [_DnsRecordSetCompare]
2060 end;
2061 end;
2062
2063 var
2064 _DnsRecordSetDetach: Pointer;
2065
DnsRecordSetDetachnull2066 function DnsRecordSetDetach;
2067 begin
2068 GetProcedureAddress(_DnsRecordSetDetach, dnsapi, 'DnsRecordSetDetach');
2069 asm
2070 MOV ESP, EBP
2071 POP EBP
2072 JMP [_DnsRecordSetDetach]
2073 end;
2074 end;
2075
2076 var
2077 _DnsFreeRecordListDeep: Pointer;
2078
2079 procedure DnsFreeRecordListDeep;
2080 begin
2081 GetProcedureAddress(_DnsFreeRecordListDeep, dnsapi, 'DnsRecordListFree');
2082 asm
2083 MOV ESP, EBP
2084 POP EBP
2085 JMP [_DnsFreeRecordListDeep]
2086 end;
2087 end;
2088
2089 var
2090 _DnsRecordListFree: Pointer;
2091
2092 procedure DnsRecordListFree;
2093 begin
2094 GetProcedureAddress(_DnsRecordListFree, dnsapi, 'DnsRecordListFree');
2095 asm
2096 MOV ESP, EBP
2097 POP EBP
2098 JMP [_DnsRecordListFree]
2099 end;
2100 end;
2101
2102 var
2103 _DnsFree: Pointer;
2104
2105 procedure DnsFree;
2106 begin
2107 GetProcedureAddress(_DnsFree, dnsapi, 'DnsFree');
2108 asm
2109 MOV ESP, EBP
2110 POP EBP
2111 JMP [_DnsFree]
2112 end;
2113 end;
2114
2115 var
2116 _DnsQuery_A: Pointer;
2117
DnsQuery_Anull2118 function DnsQuery_A;
2119 begin
2120 GetProcedureAddress(_DnsQuery_A, dnsapi, 'DnsQuery_A');
2121 asm
2122 MOV ESP, EBP
2123 POP EBP
2124 JMP [_DnsQuery_A]
2125 end;
2126 end;
2127
2128 var
2129 _DnsQuery_UTF8: Pointer;
2130
DnsQuery_UTF8null2131 function DnsQuery_UTF8;
2132 begin
2133 GetProcedureAddress(_DnsQuery_UTF8, dnsapi, 'DnsQuery_UTF8');
2134 asm
2135 MOV ESP, EBP
2136 POP EBP
2137 JMP [_DnsQuery_UTF8]
2138 end;
2139 end;
2140
2141 var
2142 _DnsQuery_W: Pointer;
2143
DnsQuery_Wnull2144 function DnsQuery_W;
2145 begin
2146 GetProcedureAddress(_DnsQuery_W, dnsapi, 'DnsQuery_W');
2147 asm
2148 MOV ESP, EBP
2149 POP EBP
2150 JMP [_DnsQuery_W]
2151 end;
2152 end;
2153
2154 var
2155 _DnsQuery: Pointer;
2156
DnsQuerynull2157 function DnsQuery;
2158 begin
2159 GetProcedureAddress(_DnsQuery, dnsapi, 'DnsQuery_' + AWSuffix);
2160 asm
2161 MOV ESP, EBP
2162 POP EBP
2163 JMP [_DnsQuery]
2164 end;
2165 end;
2166
2167 var
2168 _DnsAcquireContextHandle_W: Pointer;
2169
DnsAcquireContextHandle_Wnull2170 function DnsAcquireContextHandle_W;
2171 begin
2172 GetProcedureAddress(_DnsAcquireContextHandle_W, dnsapi, 'DnsAcquireContextHandle_W');
2173 asm
2174 MOV ESP, EBP
2175 POP EBP
2176 JMP [_DnsAcquireContextHandle_W]
2177 end;
2178 end;
2179
2180 var
2181 _DnsAcquireContextHandle_A: Pointer;
2182
DnsAcquireContextHandle_Anull2183 function DnsAcquireContextHandle_A;
2184 begin
2185 GetProcedureAddress(_DnsAcquireContextHandle_A, dnsapi, 'DnsAcquireContextHandle_A');
2186 asm
2187 MOV ESP, EBP
2188 POP EBP
2189 JMP [_DnsAcquireContextHandle_A]
2190 end;
2191 end;
2192
2193 var
2194 _DnsAcquireContextHandle: Pointer;
2195
DnsAcquireContextHandlenull2196 function DnsAcquireContextHandle;
2197 begin
2198 GetProcedureAddress(_DnsAcquireContextHandle, dnsapi, 'DnsAcquireContextHandle_' + AWSuffix);
2199 asm
2200 MOV ESP, EBP
2201 POP EBP
2202 JMP [_DnsAcquireContextHandle]
2203 end;
2204 end;
2205
2206 var
2207 _DnsReleaseContextHandle: Pointer;
2208
2209 procedure DnsReleaseContextHandle;
2210 begin
2211 GetProcedureAddress(_DnsReleaseContextHandle, dnsapi, 'DnsReleaseContextHandle');
2212 asm
2213 MOV ESP, EBP
2214 POP EBP
2215 JMP [_DnsReleaseContextHandle]
2216 end;
2217 end;
2218
2219 var
2220 _DnsModifyRecordsInSet_W: Pointer;
2221
DnsModifyRecordsInSet_Wnull2222 function DnsModifyRecordsInSet_W;
2223 begin
2224 GetProcedureAddress(_DnsModifyRecordsInSet_W, dnsapi, 'DnsModifyRecordsInSet_W');
2225 asm
2226 MOV ESP, EBP
2227 POP EBP
2228 JMP [_DnsModifyRecordsInSet_W]
2229 end;
2230 end;
2231
2232 var
2233 _DnsModifyRecordsInSet_A: Pointer;
2234
DnsModifyRecordsInSet_Anull2235 function DnsModifyRecordsInSet_A;
2236 begin
2237 GetProcedureAddress(_DnsModifyRecordsInSet_A, dnsapi, 'DnsModifyRecordsInSet_A');
2238 asm
2239 MOV ESP, EBP
2240 POP EBP
2241 JMP [_DnsModifyRecordsInSet_A]
2242 end;
2243 end;
2244
2245 var
2246 _DnsModifyRecordsInSet_UTF8: Pointer;
2247
DnsModifyRecordsInSet_UTF8null2248 function DnsModifyRecordsInSet_UTF8;
2249 begin
2250 GetProcedureAddress(_DnsModifyRecordsInSet_UTF8, dnsapi, 'DnsModifyRecordsInSet_UTF8');
2251 asm
2252 MOV ESP, EBP
2253 POP EBP
2254 JMP [_DnsModifyRecordsInSet_UTF8]
2255 end;
2256 end;
2257
2258 var
2259 _DnsModifyRecordsInSet: Pointer;
2260
DnsModifyRecordsInSetnull2261 function DnsModifyRecordsInSet;
2262 begin
2263 GetProcedureAddress(_DnsModifyRecordsInSet, dnsapi, 'DnsModifyRecordsInSet_' + AWSuffix);
2264 asm
2265 MOV ESP, EBP
2266 POP EBP
2267 JMP [_DnsModifyRecordsInSet]
2268 end;
2269 end;
2270
2271 var
2272 _DnsReplaceRecordSetW: Pointer;
2273
DnsReplaceRecordSetWnull2274 function DnsReplaceRecordSetW;
2275 begin
2276 GetProcedureAddress(_DnsReplaceRecordSetW, dnsapi, 'DnsReplaceRecordSetW');
2277 asm
2278 MOV ESP, EBP
2279 POP EBP
2280 JMP [_DnsReplaceRecordSetW]
2281 end;
2282 end;
2283
2284 var
2285 _DnsReplaceRecordSetA: Pointer;
2286
DnsReplaceRecordSetAnull2287 function DnsReplaceRecordSetA;
2288 begin
2289 GetProcedureAddress(_DnsReplaceRecordSetA, dnsapi, 'DnsReplaceRecordSetA');
2290 asm
2291 MOV ESP, EBP
2292 POP EBP
2293 JMP [_DnsReplaceRecordSetA]
2294 end;
2295 end;
2296
2297 var
2298 _DnsReplaceRecordSetUTF8: Pointer;
2299
DnsReplaceRecordSetUTF8null2300 function DnsReplaceRecordSetUTF8;
2301 begin
2302 GetProcedureAddress(_DnsReplaceRecordSetUTF8, dnsapi, 'DnsReplaceRecordSetUTF8');
2303 asm
2304 MOV ESP, EBP
2305 POP EBP
2306 JMP [_DnsReplaceRecordSetUTF8]
2307 end;
2308 end;
2309
2310 var
2311 _DnsReplaceRecordSet: Pointer;
2312
DnsReplaceRecordSetnull2313 function DnsReplaceRecordSet;
2314 begin
2315 GetProcedureAddress(_DnsReplaceRecordSet, dnsapi, 'DnsReplaceRecordSet' + AWSuffix);
2316 asm
2317 MOV ESP, EBP
2318 POP EBP
2319 JMP [_DnsReplaceRecordSet]
2320 end;
2321 end;
2322
2323 var
2324 _DnsValidateName_UTF8: Pointer;
2325
DnsValidateName_UTF8null2326 function DnsValidateName_UTF8;
2327 begin
2328 GetProcedureAddress(_DnsValidateName_UTF8, dnsapi, 'DnsValidateName_UTF8');
2329 asm
2330 MOV ESP, EBP
2331 POP EBP
2332 JMP [_DnsValidateName_UTF8]
2333 end;
2334 end;
2335
2336 var
2337 _DnsValidateName_W: Pointer;
2338
DnsValidateName_Wnull2339 function DnsValidateName_W;
2340 begin
2341 GetProcedureAddress(_DnsValidateName_W, dnsapi, 'DnsValidateName_W');
2342 asm
2343 MOV ESP, EBP
2344 POP EBP
2345 JMP [_DnsValidateName_W]
2346 end;
2347 end;
2348
2349 var
2350 _DnsValidateName_A: Pointer;
2351
DnsValidateName_Anull2352 function DnsValidateName_A;
2353 begin
2354 GetProcedureAddress(_DnsValidateName_A, dnsapi, 'DnsValidateName_A');
2355 asm
2356 MOV ESP, EBP
2357 POP EBP
2358 JMP [_DnsValidateName_A]
2359 end;
2360 end;
2361
2362 var
2363 _DnsNameCompare_A: Pointer;
2364
DnsNameCompare_Anull2365 function DnsNameCompare_A;
2366 begin
2367 GetProcedureAddress(_DnsNameCompare_A, dnsapi, 'DnsNameCompare_A');
2368 asm
2369 MOV ESP, EBP
2370 POP EBP
2371 JMP [_DnsNameCompare_A]
2372 end;
2373 end;
2374
2375 var
2376 _DnsNameCompare_W: Pointer;
2377
DnsNameCompare_Wnull2378 function DnsNameCompare_W;
2379 begin
2380 GetProcedureAddress(_DnsNameCompare_W, dnsapi, 'DnsNameCompare_W');
2381 asm
2382 MOV ESP, EBP
2383 POP EBP
2384 JMP [_DnsNameCompare_W]
2385 end;
2386 end;
2387
2388 var
2389 _DnsNameCompare: Pointer;
2390
DnsNameComparenull2391 function DnsNameCompare;
2392 begin
2393 GetProcedureAddress(_DnsNameCompare, dnsapi, 'DnsNameCompare_' + AWSuffix);
2394 asm
2395 MOV ESP, EBP
2396 POP EBP
2397 JMP [_DnsNameCompare]
2398 end;
2399 end;
2400
2401 var
2402 _DnsWriteQuestionToBuffer_W: Pointer;
2403
DnsWriteQuestionToBuffer_Wnull2404 function DnsWriteQuestionToBuffer_W;
2405 begin
2406 GetProcedureAddress(_DnsWriteQuestionToBuffer_W, dnsapi, 'DnsWriteQuestionToBuffer_W');
2407 asm
2408 MOV ESP, EBP
2409 POP EBP
2410 JMP [_DnsWriteQuestionToBuffer_W]
2411 end;
2412 end;
2413
2414 var
2415 _DnsWriteQuestionToBuffer_UTF8: Pointer;
2416
DnsWriteQuestionToBuffer_UTF8null2417 function DnsWriteQuestionToBuffer_UTF8;
2418 begin
2419 GetProcedureAddress(_DnsWriteQuestionToBuffer_UTF8, dnsapi, 'DnsWriteQuestionToBuffer_UTF8');
2420 asm
2421 MOV ESP, EBP
2422 POP EBP
2423 JMP [_DnsWriteQuestionToBuffer_UTF8]
2424 end;
2425 end;
2426
2427 var
2428 _DnsExtractRecordsFromMessage_W: Pointer;
2429
DnsExtractRecordsFromMessage_Wnull2430 function DnsExtractRecordsFromMessage_W;
2431 begin
2432 GetProcedureAddress(_DnsExtractRecordsFromMessage_W, dnsapi, 'DnsExtractRecordsFromMessage_W');
2433 asm
2434 MOV ESP, EBP
2435 POP EBP
2436 JMP [_DnsExtractRecordsFromMessage_W]
2437 end;
2438 end;
2439
2440 var
2441 _DnsExtractRecFromMessage_UTF8: Pointer;
2442
DnsExtractRecordsFromMessage_UTF8null2443 function DnsExtractRecordsFromMessage_UTF8;
2444 begin
2445 GetProcedureAddress(_DnsExtractRecFromMessage_UTF8, dnsapi, 'DnsExtractRecordsFromMessage_UTF8');
2446 asm
2447 MOV ESP, EBP
2448 POP EBP
2449 JMP [_DnsExtractRecFromMessage_UTF8]
2450 end;
2451 end;
2452
2453 {$ELSE}
2454
DnsQueryConfignull2455 function DnsQueryConfig; external dnsapi name 'DnsQueryConfig';
DnsRecordCopyExnull2456 function DnsRecordCopyEx; external dnsapi name 'DnsRecordCopyEx';
DnsRecordSetCopyExnull2457 function DnsRecordSetCopyEx; external dnsapi name 'DnsRecordSetCopyEx';
DnsRecordComparenull2458 function DnsRecordCompare; external dnsapi name 'DnsRecordCompare';
DnsRecordSetComparenull2459 function DnsRecordSetCompare; external dnsapi name 'DnsRecordSetCompare';
DnsRecordSetDetachnull2460 function DnsRecordSetDetach; external dnsapi name 'DnsRecordSetDetach';
2461 procedure DnsFreeRecordListDeep; external dnsapi name 'DnsRecordListFree';
2462 procedure DnsRecordListFree; external dnsapi name 'DnsRecordListFree';
2463 procedure DnsFree; external dnsapi name 'DnsFree';
DnsQuery_Anull2464 function DnsQuery_A; external dnsapi name 'DnsQuery_A';
DnsQuery_UTF8null2465 function DnsQuery_UTF8; external dnsapi name 'DnsQuery_UTF8';
DnsQuery_Wnull2466 function DnsQuery_W; external dnsapi name 'DnsQuery_W';
DnsQuerynull2467 function DnsQuery; external dnsapi name 'DnsQuery_' + AWSuffix;
DnsAcquireContextHandle_Wnull2468 function DnsAcquireContextHandle_W; external dnsapi name 'DnsAcquireContextHandle_W';
DnsAcquireContextHandle_Anull2469 function DnsAcquireContextHandle_A; external dnsapi name 'DnsAcquireContextHandle_A';
DnsAcquireContextHandlenull2470 function DnsAcquireContextHandle; external dnsapi name 'DnsAcquireContextHandle_' + AWSuffix;
2471 procedure DnsReleaseContextHandle; external dnsapi name 'DnsReleaseContextHandle';
DnsModifyRecordsInSet_Wnull2472 function DnsModifyRecordsInSet_W; external dnsapi name 'DnsModifyRecordsInSet_W';
DnsModifyRecordsInSet_Anull2473 function DnsModifyRecordsInSet_A; external dnsapi name 'DnsModifyRecordsInSet_A';
DnsModifyRecordsInSet_UTF8null2474 function DnsModifyRecordsInSet_UTF8; external dnsapi name 'DnsModifyRecordsInSet_UTF8';
DnsModifyRecordsInSetnull2475 function DnsModifyRecordsInSet; external dnsapi name 'DnsModifyRecordsInSet_' + AWSuffix;
DnsReplaceRecordSetWnull2476 function DnsReplaceRecordSetW; external dnsapi name 'DnsReplaceRecordSetW';
DnsReplaceRecordSetAnull2477 function DnsReplaceRecordSetA; external dnsapi name 'DnsReplaceRecordSetA';
DnsReplaceRecordSetUTF8null2478 function DnsReplaceRecordSetUTF8; external dnsapi name 'DnsReplaceRecordSetUTF8';
DnsReplaceRecordSetnull2479 function DnsReplaceRecordSet; external dnsapi name 'DnsReplaceRecordSet' + AWSuffix;
DnsValidateName_UTF8null2480 function DnsValidateName_UTF8; external dnsapi name 'DnsValidateName_UTF8';
DnsValidateName_Wnull2481 function DnsValidateName_W; external dnsapi name 'DnsValidateName_W';
DnsValidateName_Anull2482 function DnsValidateName_A; external dnsapi name 'DnsValidateName_A';
DnsNameCompare_Anull2483 function DnsNameCompare_A; external dnsapi name 'DnsNameCompare_A';
DnsNameCompare_Wnull2484 function DnsNameCompare_W; external dnsapi name 'DnsNameCompare_W';
DnsNameComparenull2485 function DnsNameCompare; external dnsapi name 'DnsNameCompare_' + AWSuffix;
DnsWriteQuestionToBuffer_Wnull2486 function DnsWriteQuestionToBuffer_W; external dnsapi name 'DnsWriteQuestionToBuffer_W';
DnsWriteQuestionToBuffer_UTF8null2487 function DnsWriteQuestionToBuffer_UTF8; external dnsapi name 'DnsWriteQuestionToBuffer_UTF8';
DnsExtractRecordsFromMessage_Wnull2488 function DnsExtractRecordsFromMessage_W; external dnsapi name 'DnsExtractRecordsFromMessage_W';
DnsExtractRecordsFromMessage_UTF8null2489 function DnsExtractRecordsFromMessage_UTF8; external dnsapi name 'DnsExtractRecordsFromMessage_UTF8';
2490
2491 {$ENDIF DYNAMIC_LINK}
2492
2493 {$ENDIF JWA_INTERFACESECTION}
2494
2495
2496 {$IFNDEF JWA_OMIT_SECTIONS}
2497 end.
2498 {$ENDIF JWA_OMIT_SECTIONS}
2499