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